Java Code Examples for org.eclipse.xtext.common.types.JvmMember#getDeclaringType()

protected void process(JvmMember context, Map<String, JvmIdentifiableElement> result) {
	if (context instanceof JvmDeclaredType) {
		if (!result.containsKey(context.getSimpleName()))
			result.put(context.getSimpleName(), context);
		JvmDeclaredType contextType = (JvmDeclaredType) context;
		ContextualVisibilityHelper visibilityHelper = new ContextualVisibilityHelper(this.visibilityHelper, contextType);
		addInnerTypes(contextType, "", visibilityHelper, result);
		
		Set<JvmType> superTypes = rawSuperTypes.collect(contextType);
		for (JvmType superType : superTypes) {
			if (superType instanceof JvmDeclaredType)
				addInnerTypes((JvmDeclaredType) superType, "", visibilityHelper, result);
		}
	}
	if (context instanceof JvmTypeParameterDeclarator)
		addTypeParameters((JvmTypeParameterDeclarator) context, result);
	JvmDeclaredType declaringType = context.getDeclaringType();
	if (declaringType != null)
		process(declaringType, result);
}
 

private String createQualifier(JvmMember jvmMember) {
	String qualifier = null;
	if (jvmMember instanceof JvmFeature) {
		JvmDeclaredType declaringType = jvmMember.getDeclaringType();
		qualifier = getPackageFreeNameForType(declaringType);
	} else if (jvmMember instanceof JvmDeclaredType) {
		if (jvmMember.eContainer() instanceof JvmDeclaredType) {
			qualifier = getPackageFreeNameForType((JvmDeclaredType) jvmMember.eContainer());
		} else {
			JvmDeclaredType jvmDeclaredType = (JvmDeclaredType) jvmMember;
			if (StringUtils.isEmpty(jvmDeclaredType.getPackageName())) {
				qualifier = "(default package)";
			} else {
				qualifier = jvmDeclaredType.getPackageName();
			}
		}
	}
	return qualifier;
}
 

/**
 * Determine whether the given member is visible without considering the class hierarchy.
 */
private boolean isVisible(final JvmMember member, final JvmDeclaredType context) {
  final JvmVisibility visibility = member.getVisibility();
  boolean _equals = Objects.equal(visibility, JvmVisibility.PUBLIC);
  if (_equals) {
    return true;
  }
  JvmDeclaredType _xifexpression = null;
  if ((member instanceof JvmDeclaredType)) {
    _xifexpression = ((JvmDeclaredType)member);
  } else {
    _xifexpression = member.getDeclaringType();
  }
  final JvmDeclaredType type = _xifexpression;
  if ((Objects.equal(type, context) || EcoreUtil.isAncestor(context, type))) {
    return true;
  }
  if (((type != null) && (Objects.equal(visibility, JvmVisibility.DEFAULT) || Objects.equal(visibility, JvmVisibility.PROTECTED)))) {
    if (((Strings.isEmpty(context.getPackageName()) && Strings.isEmpty(type.getPackageName())) || Objects.equal(context.getPackageName(), type.getPackageName()))) {
      return true;
    }
  }
  return false;
}
 

private boolean isNestedTypeOf(JvmType child, JvmDeclaredType parent) {
	if (child instanceof JvmMember) {
		JvmMember member = (JvmMember) child;
		return member.getDeclaringType() == parent;
	}
	return false;
}
 

private boolean removeStaticImport(Map<String, List<XImportDeclaration>> staticImports, JvmMember member) {
	JvmDeclaredType declaringType = member.getDeclaringType();
	String identifier = declaringType.getIdentifier();
	
	List<XImportDeclaration> list = staticImports.get(identifier);
	if (list == null) {
		return false;
	}
	if (list.size() == 1) {
		staticImports.remove(identifier);
		return true;
	}
	int indexToRemove = -1;
	for (int i = 0; i < list.size(); i++) {
		XImportDeclaration staticImportDeclaration = list.get(i);
		if (staticImportDeclaration.isWildcard()) {
			if (indexToRemove == -1) {
				indexToRemove = i;
			}
			continue;
		}
		if (Objects.equal(member.getSimpleName(), staticImportDeclaration.getMemberName())) {
			indexToRemove = i;
			break;
		}
	}
	if (indexToRemove == -1) {
		indexToRemove = 0;
	}
	list.remove(indexToRemove);
	return true;
}
 

@Override
public boolean isVisible(JvmMember member) {
	// TODO private visibility?
	JvmVisibility visibility = member.getVisibility();
	if (visibility == JvmVisibility.PUBLIC) {
		return true;
	}
	JvmDeclaredType type = member instanceof JvmDeclaredType ? (JvmDeclaredType) member : member.getDeclaringType();
	if (type == rawContextType || EcoreUtil.isAncestor(rawContextType, type)) {
		return true;
	}
	if (type != null && visibility == JvmVisibility.PROTECTED) {
		if (superTypeNames == null) {
			this.superTypeNames = computeSuperTypeNames();
		}
		if (superTypeNames.contains(type.getIdentifier())) {
			return true;
		}
		if (type == member) {
			JvmDeclaredType declaringType = member.getDeclaringType();
			if (declaringType != null && superTypeNames.contains(declaringType.getIdentifier())) {
				return true;
			}
		}
	}
	if (type != null 
			&& (rawContextType == null || rawContextType instanceof JvmDeclaredType) 
			&& (visibility == JvmVisibility.DEFAULT || visibility == JvmVisibility.PROTECTED)) {
		if (Strings.isEmpty(packageName) && Strings.isEmpty(type.getPackageName())
				|| (packageName != null && packageName.equals(type.getPackageName()))) {
			return true;
		}
	}
	return parent.isVisible(member);
}
 

protected String getPackageName(JvmMember context) {
	if(context.getDeclaringType() != null)
		return getPackageName(context.getDeclaringType());
	if(context instanceof JvmDeclaredType) 
		return ((JvmDeclaredType)context).getPackageName();
	else  
		return null;
}
 

protected boolean isConflicted(JvmDeclaredType type, String memberName, Set<JvmMember> importedMembers) {
	for (JvmMember importedMember : importedMembers) {
		if (importedMember.getDeclaringType() != type && memberName.equals(importedMember.getSimpleName())) {
			return true;
		}
	}
	return false;
}
 

protected boolean contains(JvmDeclaredType type, String memberName, Set<JvmMember> importedMembers) {
	for (JvmMember staticImport : importedMembers) {
		if (staticImport.getDeclaringType() == type && memberName.equals(staticImport.getSimpleName())) {
			return true;
		}
	}
	return false;
}
 

/**
 * @since 2.3
 */
public IJavaElement getDeclaringTypeElement(JvmMember object) {
	if (object.getDeclaringType() != null) {
		IJavaElement typeElement = doSwitch(object.getDeclaringType());
		return typeElement;
	} 
	return null;
}
 

@Override
protected String getDeclaratorName(JvmMember member) {
	JvmDeclaredType declaringType = member.getDeclaringType();
	if (declaringType.isLocal()) {
		String rawName = Iterables.getLast(declaringType.getSuperTypes()).getType().getSimpleName();
		return "new " + rawName + "(){}";
	} else {
		return super.getDeclaratorName(member);
	}
}
 

@Override
public ITreeAppendable generateVisibilityModifier(final JvmMember it, final ITreeAppendable result) {
  ITreeAppendable _xblockexpression = null;
  {
    JvmVisibility _visibility = it.getVisibility();
    boolean _equals = Objects.equal(_visibility, JvmVisibility.PRIVATE);
    if (_equals) {
      JvmDeclaredType _declaringType = it.getDeclaringType();
      boolean _tripleEquals = (_declaringType == null);
      if (_tripleEquals) {
        return result;
      }
      if ((it.getDeclaringType().isLocal() && (it instanceof JvmOperation))) {
        JvmDeclaredType _declaringType_1 = it.getDeclaringType();
        final JvmGenericType declarator = ((JvmGenericType) _declaringType_1);
        boolean _isAnonymous = declarator.isAnonymous();
        boolean _not = (!_isAnonymous);
        if (_not) {
          return result;
        }
      }
    } else {
      JvmVisibility _visibility_1 = it.getVisibility();
      boolean _equals_1 = Objects.equal(_visibility_1, JvmVisibility.PUBLIC);
      if (_equals_1) {
        if (((it.getDeclaringType() instanceof JvmGenericType) && ((JvmGenericType) it.getDeclaringType()).isInterface())) {
          return result;
        }
      }
    }
    _xblockexpression = super.generateVisibilityModifier(it, result);
  }
  return _xblockexpression;
}
 

@Override
public boolean isVisible(JvmMember member, /* @Nullable */ LightweightTypeReference receiverType, /* @Nullable */ JvmIdentifiableElement receiverFeature) {
	boolean result = isVisible(member);
	if (result && JvmVisibility.PROTECTED == member.getVisibility()) {
		if (receiverFeature != null) {
			// We bypass this check for qualified.this and qualified.super in the scope provider
			// they are considered to be always visible
			/*
			 * class A {
			 *   class B {
			 *     {
			 *       A.super.toString
			 *     }
			 *   }
			 * }
			 */
			if (isThisSuperOrTypeLiteral(receiverFeature)) {
				if (receiverType == null || !receiverType.isType(Class.class)) {
					return true;
				}
			}
		}
		JvmType contextType = visibilityHelper.getRawContextType();
		if (contextType instanceof JvmDeclaredType) {
			String packageName = visibilityHelper.getPackageName();
			JvmDeclaredType declaringType = member.getDeclaringType();
			String memberPackageName = declaringType.getPackageName();
			if (Strings.equal(packageName, memberPackageName)) {
				return true;
			}
		}
		if (receiverType != null) {
			if (receiverType.isSubtypeOf(contextType)) {
				return true;
			}
			EObject container = contextType.eContainer();
			while (container instanceof JvmType) {
				if (receiverType.isSubtypeOf((JvmType)container)) {
					return true;
				}
				container = container.eContainer();
			}
		}
		return false;
	}
	return result;
}
 

protected void acceptStaticImport(JvmMember member) {
	JvmDeclaredType declarator = member.getDeclaringType();
	if (!needsStaticImport(declarator) || implicitStaticImports.contains(declarator))
		return;
	typeUsages.addStaticImport(member);
}
 

protected void acceptStaticExtensionImport(JvmMember member) {
	JvmDeclaredType declarator = member.getDeclaringType();
	if (!needsStaticImport(declarator) || implicitExtensionImports.contains(declarator))
		return;
	typeUsages.addExtensionImport(member);
}
 

private boolean isDeclaredWithinInterface(final JvmMember it) {
  return ((it.getDeclaringType() instanceof JvmGenericType) && ((JvmGenericType) it.getDeclaringType()).isInterface());
}