Java IBinding.getKind方法代码示例

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
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());
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
@Override
public boolean visit(SimpleName node) {
	IBinding binding= node.resolveBinding();
	if (binding == null) {
		return false;
	}
	binding= getDeclaration(binding);

	if (fBinding == binding) {
		fResult.add(node);
	} else if (binding.getKind() != fBinding.getKind()) {
		return false;
	} else if (binding.getKind() == IBinding.METHOD) {
		IMethodBinding curr= (IMethodBinding) binding;
		IMethodBinding methodBinding= (IMethodBinding) fBinding;
		if (methodBinding.overrides(curr) || curr.overrides(methodBinding)) {
			fResult.add(node);
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
@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);
	}
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
private String getDisplayString(IBinding binding) {
	switch (binding.getKind()) {
	case IBinding.TYPE:
		return FixMessages.UnusedCodeFix_RemoveUnusedType_description;
	case IBinding.METHOD:
		if (((IMethodBinding) binding).isConstructor()) {
			return FixMessages.UnusedCodeFix_RemoveUnusedConstructor_description;
		} else {
			return FixMessages.UnusedCodeFix_RemoveUnusedPrivateMethod_description;
		}
	case IBinding.VARIABLE:
		if (((IVariableBinding) binding).isField()) {
			return FixMessages.UnusedCodeFix_RemoveUnusedField_description;
		} else {
			return FixMessages.UnusedCodeFix_RemoveUnusedVariabl_description;
		}
	default:
		return ""; //$NON-NLS-1$
	}
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
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());
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
@Override
public boolean consumes(final SemanticToken token) {
  final SimpleName node = token.getNode();
  if (node.isDeclaration()) {
    return false;
  }

  final IBinding binding = token.getBinding();
  if (binding == null || binding.getKind() != IBinding.VARIABLE) {
    return false;
  }

  ITypeBinding currentType = Bindings.getBindingOfParentType(node);
  ITypeBinding declaringType = ((IVariableBinding) binding).getDeclaringClass();
  if (declaringType == null || currentType == declaringType) return false;

  return Bindings.isSuperType(declaringType, currentType);
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
@Override
public boolean visit(SimpleName node) {
  IBinding binding = node.resolveBinding();
  if (binding == null) {
    return false;
  }
  binding = getDeclaration(binding);

  if (fBinding == binding) {
    fResult.add(node);
  } else if (binding.getKind() != fBinding.getKind()) {
    return false;
  } else if (binding.getKind() == IBinding.METHOD) {
    IMethodBinding curr = (IMethodBinding) binding;
    IMethodBinding methodBinding = (IMethodBinding) fBinding;
    if (methodBinding.overrides(curr) || curr.overrides(methodBinding)) {
      fResult.add(node);
    }
  }
  return false;
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
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$
  }
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
private void visitExpressionIfName(Expression expression) {
  if (!(expression instanceof Name)) {
    return;
  }
  IBinding binding = ((Name) expression).resolveBinding();
  if (binding != null && binding.getKind() == IBinding.VARIABLE) {
    return;
  }
  addType(
      expression.resolveTypeBinding(),
      extractClassNameFromQualifiedName(((Name) expression).getFullyQualifiedName()),
      expression.getStartPosition());
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
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;
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
/**
 * Answer the annotation binding representing a nullness default
 * effective at the point denoted by 'contextBinding'.
 * @param contextBinding method binding or type binding denoting the location of interest
 * @param javaProject the containing java project, consulted for the actual name of
 *  the annotation used for nullness defaults (default: <code>@NonNullByDefault</code>).
 * @return binding for the effective nullness default annotation
 * 	or null if no nullness default is effective at the context location.
 */
public static IAnnotationBinding findNullnessDefault(IBinding contextBinding, IJavaProject javaProject) {
	if (JavaCore.ENABLED.equals(javaProject.getOption(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, true))) {
		String annotationName= javaProject.getOption(JavaCore.COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME, true);
		while (contextBinding != null) {
			for (IAnnotationBinding annotation : contextBinding.getAnnotations()) {
				ITypeBinding annotationType= annotation.getAnnotationType();
				if (annotationType != null && annotationType.getQualifiedName().equals(annotationName)) {
					return annotation;
				}
			}
			// travel out:
			switch (contextBinding.getKind()) {
			case IBinding.METHOD:
				IMethodBinding methodBinding= (IMethodBinding) contextBinding;
				contextBinding= methodBinding.getDeclaringMember();
				if (contextBinding == null) {
					contextBinding= methodBinding.getDeclaringClass();
				}
				break;
			case IBinding.VARIABLE:
				IVariableBinding variableBinding= (IVariableBinding) contextBinding;
				contextBinding= variableBinding.getDeclaringMethod();
				if (contextBinding == null) {
					contextBinding= variableBinding.getDeclaringClass();
				}
				break;
			case IBinding.TYPE:
				ITypeBinding currentClass= (ITypeBinding) contextBinding;
				contextBinding= currentClass.getDeclaringMember();
				if (contextBinding == null) {
					contextBinding= currentClass.getDeclaringMethod();
					if (contextBinding == null) {
						contextBinding= currentClass.getDeclaringClass();
						if (contextBinding == null) {
							contextBinding= currentClass.getPackage();
						}
					}
				}
				break;
			default:
				contextBinding= null;
				break;
			}
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
/**
 * 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));
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
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);
	}
}
 

import org.eclipse.jdt.core.dom.IBinding; //导入方法依赖的package包/类
private static Map<String, String> getCleanUpOptions(IBinding binding, boolean removeAll) {
	Map<String, String> result= new Hashtable<>();

	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;
}