Java Code Examples for org.eclipse.jdt.core.dom.IBinding#TYPE

private static int getNeededVisibility(ASTNode currNode, ITypeBinding targetType, IBinding binding) {
	ITypeBinding currNodeBinding = Bindings.getBindingOfParentType(currNode);
	if (currNodeBinding == null) { // import
		return Modifier.PUBLIC;
	}

	if (Bindings.isSuperType(targetType, currNodeBinding)) {
		if (binding != null && (JdtFlags.isProtected(binding) || binding.getKind() == IBinding.TYPE)) {
			return Modifier.PUBLIC;
		}
		return Modifier.PROTECTED;
	}

	if (currNodeBinding.getPackage().getKey().equals(targetType.getPackage().getKey())) {
		return 0;
	}
	return Modifier.PUBLIC;
}
 

@Override
public String getName() {
	IBinding binding= fName.resolveBinding();
	String name= BasicElementLabels.getJavaElementName(fName.getIdentifier());
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return Messages.format(CorrectionMessages.RemoveDeclarationCorrectionProposal_removeunusedtype_description, name);
		case IBinding.METHOD:
			if (((IMethodBinding) binding).isConstructor()) {
				return Messages.format(CorrectionMessages.RemoveDeclarationCorrectionProposal_removeunusedconstructor_description, name);
			} else {
				return Messages.format(CorrectionMessages.RemoveDeclarationCorrectionProposal_removeunusedmethod_description, name);
			}
		case IBinding.VARIABLE:
			if (((IVariableBinding) binding).isField()) {
				return Messages.format(CorrectionMessages.RemoveDeclarationCorrectionProposal_removeunusedfield_description, name);
			} else {
				return Messages.format(CorrectionMessages.RemoveDeclarationCorrectionProposal_removeunusedvar_description, name);
			}
		default:
			return super.getDisplayString();
	}
}
 

private static int getNeededVisibility(ASTNode currNode, ITypeBinding targetType, IBinding binding) {
	ITypeBinding currNodeBinding= Bindings.getBindingOfParentType(currNode);
	if (currNodeBinding == null) { // import
		return Modifier.PUBLIC;
	}

	if (Bindings.isSuperType(targetType, currNodeBinding)) {
		if (binding != null && (JdtFlags.isProtected(binding) || binding.getKind() == IBinding.TYPE)) {
			return Modifier.PUBLIC;
		}
		return Modifier.PROTECTED;
	}

	if (currNodeBinding.getPackage().getKey().equals(targetType.getPackage().getKey())) {
		return 0;
	}
	return Modifier.PUBLIC;
}
 

private static Map<String, String> getCleanUpOptions(IBinding binding, boolean removeAll) {
	Map<String, String> result= new Hashtable<String, String>();

	result.put(CleanUpConstants.REMOVE_UNUSED_CODE_PRIVATE_MEMBERS, CleanUpOptions.TRUE);
	switch (binding.getKind()) {
		case IBinding.TYPE:
			result.put(CleanUpConstants.REMOVE_UNUSED_CODE_PRIVATE_TYPES, CleanUpOptions.TRUE);
			break;
		case IBinding.METHOD:
			if (((IMethodBinding) binding).isConstructor()) {
				result.put(CleanUpConstants.REMOVE_UNUSED_CODE_PRIVATE_CONSTRUCTORS, CleanUpOptions.TRUE);
			} else {
				result.put(CleanUpConstants.REMOVE_UNUSED_CODE_PRIVATE_METHODS, CleanUpOptions.TRUE);
			}
			break;
		case IBinding.VARIABLE:
			if (removeAll)
				return null;

			result.put(CleanUpConstants.REMOVE_UNUSED_CODE_PRIVATE_FELDS, CleanUpOptions.TRUE);
			result.put(CleanUpConstants.REMOVE_UNUSED_CODE_LOCAL_VARIABLES, CleanUpOptions.TRUE);
			break;
	}

	return result;
}
 

private static String getDisplayString(SimpleName simpleName, IBinding binding, boolean removeAllAssignements) {
	String name= BasicElementLabels.getJavaElementName(simpleName.getIdentifier());
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return Messages.format(FixMessages.UnusedCodeFix_RemoveType_description, name);
		case IBinding.METHOD:
			if (((IMethodBinding) binding).isConstructor()) {
				return Messages.format(FixMessages.UnusedCodeFix_RemoveConstructor_description, name);
			} else {
				return Messages.format(FixMessages.UnusedCodeFix_RemoveMethod_description, name);
			}
		case IBinding.VARIABLE:
			if (removeAllAssignements) {
				return Messages.format(FixMessages.UnusedCodeFix_RemoveFieldOrLocalWithInitializer_description, name);
			} else {
				return Messages.format(FixMessages.UnusedCodeFix_RemoveFieldOrLocal_description, name);
			}
		default:
			return ""; //$NON-NLS-1$
	}
}
 

@Override
public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel linkedModel) throws CoreException {
	ASTRewrite rewrite= cuRewrite.getASTRewrite();
	IBinding binding= fUnusedName.resolveBinding();
	CompilationUnit root= (CompilationUnit) fUnusedName.getRoot();
	String displayString= FixMessages.UnusedCodeFix_RemoveUnusedTypeParameter_description;
	TextEditGroup group= createTextEditGroup(displayString, cuRewrite);

	if (binding.getKind() == IBinding.TYPE) {
		ITypeBinding decl= ((ITypeBinding) binding).getTypeDeclaration();
		ASTNode declaration= root.findDeclaringNode(decl);
		if (declaration.getParent() instanceof TypeDeclarationStatement) {
			declaration= declaration.getParent();
		}
		rewrite.remove(declaration, group);
	}
}
 

private static String getSignature(IBinding binding) {
	if (binding != null) {
		switch (binding.getKind()) {
			case IBinding.METHOD:
				StringBuffer buf= new StringBuffer();
				buf.append('M');
				buf.append(binding.getName()).append('(');
				ITypeBinding[] parameters= ((IMethodBinding) binding).getParameterTypes();
				for (int i= 0; i < parameters.length; i++) {
					if (i > 0) {
						buf.append(',');
					}
					ITypeBinding paramType= parameters[i].getErasure();
					buf.append(paramType.getQualifiedName());
				}
				buf.append(')');
				return buf.toString();
			case IBinding.VARIABLE:
				return 'V' + binding.getName();
			case IBinding.TYPE:
				return 'T' + binding.getName();
		}
	}
	return null;
}
 

public static String getImportName(IBinding binding) {
	ITypeBinding declaring= null;
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return getRawQualifiedName((ITypeBinding) binding);
		case IBinding.PACKAGE:
			return binding.getName() + ".*"; //$NON-NLS-1$
		case IBinding.METHOD:
			declaring= ((IMethodBinding) binding).getDeclaringClass();
			break;
		case IBinding.VARIABLE:
			declaring= ((IVariableBinding) binding).getDeclaringClass();
			if (declaring == null) {
				return binding.getName(); // array.length
			}

			break;
		default:
			return binding.getName();
	}
	return JavaModelUtil.concatenateName(getRawQualifiedName(declaring), binding.getName());
}
 

private static ITypeBinding getDeclaringType(IBinding binding) {
	switch (binding.getKind()) {
		case IBinding.VARIABLE:
			return ((IVariableBinding) binding).getDeclaringClass();
		case IBinding.METHOD:
			return ((IMethodBinding) binding).getDeclaringClass();
		case IBinding.TYPE:
			ITypeBinding typeBinding= (ITypeBinding) binding;
			if (typeBinding.getDeclaringClass() != null) {
				return typeBinding;
			}
			return typeBinding;
	}
	return null;
}
 

/**
 * Tries to find the given type name and add it to the import structure.
 * @param ref the name node
 */
public void add(SimpleName ref) {
	String typeName= ref.getIdentifier();

	if (fImportsAdded.contains(typeName)) {
		return;
	}

	IBinding binding= ref.resolveBinding();
	if (binding != null) {
		if (binding.getKind() != IBinding.TYPE) {
			return;
		}
		ITypeBinding typeBinding= (ITypeBinding) binding;
		if (typeBinding.isArray()) {
			typeBinding= typeBinding.getElementType();
		}
		typeBinding= typeBinding.getTypeDeclaration();
		if (!typeBinding.isRecovered()) {
			if (needsImport(typeBinding, ref)) {
				fImpStructure.addImport(typeBinding);
				fImportsAdded.add(typeName);
			}
			return;
		}
	} else {
		if (fDoIgnoreLowerCaseNames && typeName.length() > 0) {
			char ch= typeName.charAt(0);
			if (Strings.isLowerCase(ch) && Character.isLetter(ch)) {
				return;
			}
		}
	}
	fImportsAdded.add(typeName);
	fUnresolvedTypes.put(typeName, new UnresolvedTypeData(ref));
}
 

private void possibleTypeRefFound(Name node) {
	while (node.isQualifiedName()) {
		node= ((QualifiedName) node).getQualifier();
	}
	IBinding binding= node.resolveBinding();
	if (binding == null || binding.getKind() == IBinding.TYPE) {
		// if the binding is null, we cannot determine if
		// we have a type binding or not, so we will assume
		// we do.
		addReference((SimpleName) node);
	}
}
 

public static IBinding getDeclaration(IBinding binding) {
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return ((ITypeBinding) binding).getTypeDeclaration();
		case IBinding.VARIABLE:
			return ((IVariableBinding) binding).getVariableDeclaration();
		case IBinding.METHOD:
			return ((IMethodBinding) binding).getMethodDeclaration();
	}
	return binding;
}
 

public StyledString getStyledViolation() {
	StyledString styledString = new StyledString();
	BoldStyler boldStyler = new BoldStyler();
	NormalStyler normalStyler = new NormalStyler();
	if(type.equals(PreconditionViolationType.INFEASIBLE_UNIFICATION_DUE_TO_VARIABLE_TYPE_MISMATCH)) {
		Expression expression1 = this.expression1.getExpression();
		Expression expression2 = this.expression2.getExpression();
		if(expression1 instanceof Name && ((Name)expression1).resolveBinding().getKind() == IBinding.TYPE &&
				expression2 instanceof Name && ((Name)expression2).resolveBinding().getKind() == IBinding.TYPE) {
			styledString.append("Type ", normalStyler);
			styledString.append(expression1.resolveTypeBinding().getQualifiedName(), boldStyler);
			styledString.append(" does not match with ", normalStyler);
			styledString.append("type ", normalStyler);
			styledString.append(expression2.resolveTypeBinding().getQualifiedName(), boldStyler);
		}
		else {
			expression1 = ASTNodeDifference.getParentExpressionOfMethodNameOrTypeName(expression1);
			expression2 = ASTNodeDifference.getParentExpressionOfMethodNameOrTypeName(expression2);
			styledString.append("Type ", normalStyler);
			styledString.append(expression1.resolveTypeBinding().getQualifiedName(), boldStyler);
			styledString.append(" of variable ", normalStyler);
			styledString.append(expression1.toString(), boldStyler);
			styledString.append(" does not match with ", normalStyler);
			styledString.append("type ", normalStyler);
			styledString.append(expression2.resolveTypeBinding().getQualifiedName(), boldStyler);
			styledString.append(" of variable ", normalStyler);
			styledString.append(expression2.toString(), boldStyler);
		}
	}
	return styledString;
}
 

/**
 * Tests if the given node is a declaration, not a instance of a generic type, method or field.
 * Declarations can be found in AST with CompilationUnit.findDeclaringNode
 * @param binding binding to test
 * @return returns <code>true</code> if the binding is a declaration binding
 */
public static boolean isDeclarationBinding(IBinding binding) {
	switch (binding.getKind()) {
		case IBinding.TYPE:
			return ((ITypeBinding) binding).getTypeDeclaration() == binding;
		case IBinding.VARIABLE:
			return ((IVariableBinding) binding).getVariableDeclaration() == binding;
		case IBinding.METHOD:
			return ((IMethodBinding) binding).getMethodDeclaration() == binding;
	}
	return true;
}
 

private IBinding getBindingDeclaration(IBinding binding) {
	switch (binding.getKind()) {
		case IBinding.TYPE :
			return ((ITypeBinding)binding).getTypeDeclaration();
		case IBinding.METHOD :
			return ((IMethodBinding)binding).getMethodDeclaration();
		case IBinding.VARIABLE :
			return ((IVariableBinding)binding).getVariableDeclaration();
		default:
			return binding;
	}
}
 

boolean markOccurrencesOfType(IBinding binding) {

		if (binding == null)
			return false;

		int kind= binding.getKind();

		if (fMarkTypeOccurrences && kind == IBinding.TYPE)
			return true;

		if (fMarkMethodOccurrences && kind == IBinding.METHOD)
			return true;

		if (kind == IBinding.VARIABLE) {
			IVariableBinding variableBinding= (IVariableBinding)binding;
			if (variableBinding.isField()) {
				int constantModifier= IModifierConstants.ACC_STATIC | IModifierConstants.ACC_FINAL;
				boolean isConstant= (variableBinding.getModifiers() & constantModifier) == constantModifier;
				if (isConstant)
					return fMarkConstantOccurrences;
				else
					return fMarkFieldOccurrences;
			}

			return fMarkLocalVariableypeOccurrences;
		}

		return false;
	}
 

private int evaluateModifiers(ASTNode targetTypeDecl) {
	if (getSenderBinding().isAnnotation()) {
		return 0;
	}
	if (getSenderBinding().isInterface()) {
		// for interface and annotation members copy the modifiers from an existing field
		MethodDeclaration[] methodDecls= ((TypeDeclaration) targetTypeDecl).getMethods();
		if (methodDecls.length > 0) {
			return methodDecls[0].getModifiers();
		}
		return 0;
	}
	ASTNode invocationNode= getInvocationNode();
	if (invocationNode instanceof MethodInvocation) {
		int modifiers= 0;
		Expression expression= ((MethodInvocation)invocationNode).getExpression();
		if (expression != null) {
			if (expression instanceof Name && ((Name) expression).resolveBinding().getKind() == IBinding.TYPE) {
				modifiers |= Modifier.STATIC;
			}
		} else if (ASTResolving.isInStaticContext(invocationNode)) {
			modifiers |= Modifier.STATIC;
		}
		ASTNode node= ASTResolving.findParentType(invocationNode);
		if (targetTypeDecl.equals(node)) {
			modifiers |= Modifier.PRIVATE;
		} else if (node instanceof AnonymousClassDeclaration && ASTNodes.isParent(node, targetTypeDecl)) {
			modifiers |= Modifier.PROTECTED;
			if (ASTResolving.isInStaticContext(node) && expression == null) {
				modifiers |= Modifier.STATIC;
			}
		} else {
			modifiers |= Modifier.PUBLIC;
		}
		return modifiers;
	}
	return Modifier.PUBLIC;
}
 

public boolean visit(SimpleName node) {
	IBinding binding = node.resolveBinding();
	if(binding != null && binding.getKind() == IBinding.TYPE) {
		ITypeBinding typeBinding = (ITypeBinding)binding;
		typeBindings.add(typeBinding);
	}
	return super.visit(node);
}
 

private int evaluateModifiers(ASTNode targetTypeDecl) {
	if (getSenderBinding().isAnnotation()) {
		return 0;
	}
	boolean isTargetInterface= getSenderBinding().isInterface();
	if (isTargetInterface && !JavaModelUtil.is18OrHigher(getCompilationUnit().getJavaProject())) {
		// only abstract methods are allowed for interface present in less than Java 1.8
		return getInterfaceMethodModifiers(targetTypeDecl, true);
	}
	ASTNode invocationNode= getInvocationNode();
	if (invocationNode instanceof MethodInvocation) {
		int modifiers= 0;
		Expression expression= ((MethodInvocation)invocationNode).getExpression();
		if (expression != null) {
			if (expression instanceof Name && ((Name) expression).resolveBinding().getKind() == IBinding.TYPE) {
				modifiers |= Modifier.STATIC;
			}
		} else if (ASTResolving.isInStaticContext(invocationNode)) {
			modifiers |= Modifier.STATIC;
		}
		ASTNode node= ASTResolving.findParentType(invocationNode);
		boolean isParentInterface= node instanceof TypeDeclaration && ((TypeDeclaration) node).isInterface();
		if (isTargetInterface || isParentInterface) {
			if (expression == null && !targetTypeDecl.equals(node)) {
				modifiers|= Modifier.STATIC;
				if (isTargetInterface) {
					modifiers|= getInterfaceMethodModifiers(targetTypeDecl, false);
				} else {
					modifiers|= Modifier.PROTECTED;
				}
			} else if (modifiers == Modifier.STATIC) {
				modifiers= getInterfaceMethodModifiers(targetTypeDecl, false) | Modifier.STATIC;
			} else {
				modifiers= getInterfaceMethodModifiers(targetTypeDecl, true);
			}
		} else if (targetTypeDecl.equals(node)) {
			modifiers |= Modifier.PRIVATE;
		} else if (node instanceof AnonymousClassDeclaration && ASTNodes.isParent(node, targetTypeDecl)) {
			modifiers |= Modifier.PROTECTED;
			if (ASTResolving.isInStaticContext(node) && expression == null) {
				modifiers |= Modifier.STATIC;
			}
		} else {
			modifiers |= Modifier.PUBLIC;
		}
		return modifiers;
	}
	return Modifier.PUBLIC;
}
 

@Override
public boolean visit(SimpleName node) {
    ASTNode parent = node.getParent();
    if (parent instanceof Annotation) {
        addToken(node, TokenType.ANNOTATION);
        return false;
    }

    IBinding binding = node.resolveBinding();
    if (binding == null) {
        return super.visit(node);
    }

    TokenType tokenType = null;
    switch (binding.getKind()) {
        case IBinding.VARIABLE: {
            if (((IVariableBinding) binding).isField()) {
                tokenType = TokenType.PROPERTY;
            } else {
                tokenType = TokenType.VARIABLE;
            }
            break;
        }
        case IBinding.METHOD: {
            tokenType = TokenType.FUNCTION;
            break;
        }
        case IBinding.TYPE: {
            tokenType = TokenType.TYPE;
            break;
        }
        case IBinding.PACKAGE: {
            tokenType = TokenType.NAMESPACE;
            break;
        }
        default:
            break;
    }

    if (tokenType == null) {
        return super.visit(node);
    }

    switch (tokenType) {
        case FUNCTION:
        case VARIABLE:
        case PROPERTY:
        case MEMBER: {
            ITokenModifier[] modifiers = getModifiers(binding);
            addToken(node, tokenType, modifiers);
            break;
        }
        case TYPE:
        case NAMESPACE:
            addToken(node, tokenType, NO_MODIFIERS);
            break;
        default:
            break;
    }

    return super.visit(node);
}