Java Name.resolveBinding方法代码示例

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
public static void getInvalidQualificationProposals(IInvocationContext context, IProblemLocation problem,
		Collection<CUCorrectionProposal> proposals) {
	ASTNode node= problem.getCoveringNode(context.getASTRoot());
	if (!(node instanceof Name)) {
		return;
	}
	Name name= (Name) node;
	IBinding binding= name.resolveBinding();
	if (!(binding instanceof ITypeBinding)) {
		return;
	}
	ITypeBinding typeBinding= (ITypeBinding)binding;

	AST ast= node.getAST();
	ASTRewrite rewrite= ASTRewrite.create(ast);
	rewrite.replace(name, ast.newName(typeBinding.getQualifiedName()), null);

	String label= CorrectionMessages.JavadocTagsSubProcessor_qualifylinktoinner_description;
	ASTRewriteCorrectionProposal proposal = new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(),
			rewrite, IProposalRelevance.QUALIFY_INNER_TYPE_NAME);

	proposals.add(proposal);
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
/**
 * @return <code>null</code> if the selection is invalid or does not cover a temp declaration or
 *     reference.
 */
public static VariableDeclaration findTempDeclaration(
    CompilationUnit cu, int selectionOffset, int selectionLength) {
  TempSelectionAnalyzer analyzer = new TempSelectionAnalyzer(selectionOffset, selectionLength);
  cu.accept(analyzer);

  ASTNode[] selected = analyzer.getSelectedNodes();
  if (selected == null || selected.length != 1) return null;

  ASTNode selectedNode = selected[0];
  if (selectedNode instanceof VariableDeclaration) return (VariableDeclaration) selectedNode;

  if (selectedNode instanceof Name) {
    Name reference = (Name) selectedNode;
    IBinding binding = reference.resolveBinding();
    if (binding == null) return null;
    ASTNode declaringNode = cu.findDeclaringNode(binding);
    if (declaringNode instanceof VariableDeclaration) return (VariableDeclaration) declaringNode;
    else return null;
  } else if (selectedNode instanceof VariableDeclarationStatement) {
    VariableDeclarationStatement vds = (VariableDeclarationStatement) selectedNode;
    if (vds.fragments().size() != 1) return null;
    return (VariableDeclaration) vds.fragments().get(0);
  }
  return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
private Name findConstantNameNode() {
  ASTNode node =
      NodeFinder.perform(fSelectionCuRewrite.getRoot(), fSelectionStart, fSelectionLength);
  if (node == null) return null;
  if (node instanceof FieldAccess) node = ((FieldAccess) node).getName();
  if (!(node instanceof Name)) return null;
  Name name = (Name) node;
  IBinding binding = name.resolveBinding();
  if (!(binding instanceof IVariableBinding)) return null;
  IVariableBinding variableBinding = (IVariableBinding) binding;
  if (!variableBinding.isField() || variableBinding.isEnumConstant()) return null;
  int modifiers = binding.getModifiers();
  if (!(Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers))) return null;

  return name;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
private boolean visitNameNode(Name node) {
	IBinding binding = node.resolveBinding();
	if (binding instanceof IVariableBinding) {
		IVariableBinding variableBindig = (IVariableBinding) binding;
		if (variableBindig.isField()) {
			ITypeBinding declaringClass = variableBindig.getDeclaringClass();
			handleTypeBinding(node, declaringClass, false);
			handleFieldBinding(node, variableBindig);
		} else if (!variableBindig.isEnumConstant()) {
			handleVariableBinding(node, variableBindig);
		}
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
public static IMethodBinding getMethodBinding(Name node) {
	IBinding binding= node.resolveBinding();
	if (binding instanceof IMethodBinding) {
		return (IMethodBinding)binding;
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
public static IVariableBinding getVariableBinding(Name node) {
	IBinding binding= node.resolveBinding();
	if (binding instanceof IVariableBinding) {
		return (IVariableBinding)binding;
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
public static ITypeBinding getTypeBinding(Name node) {
	IBinding binding= node.resolveBinding();
	if (binding instanceof ITypeBinding) {
		return (ITypeBinding)binding;
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的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.Name; //导入方法依赖的package包/类
private IMethodBinding getMethodBinding(Name name) {
	if (name == null) {
		return null;
	}
	IBinding binding = name.resolveBinding();
	if (binding instanceof IMethodBinding) {
		return (IMethodBinding) binding;
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
private void addStaticImports(List<SimpleName> staticReferences, ImportRewrite importsStructure) {
  for (int i = 0; i < staticReferences.size(); i++) {
    Name name = staticReferences.get(i);
    IBinding binding = name.resolveBinding();
    if (binding != null) { // paranoia check
      importsStructure.addStaticImport(binding);
    }
  }
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的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.Name; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean visit(final MethodInvocation node) {
  if (!fRemoveMethodQualifiers) return true;

  Expression expression = node.getExpression();
  if (!(expression instanceof ThisExpression)) return true;

  final SimpleName name = node.getName();
  if (name.resolveBinding() == null) return true;

  if (hasConflict(
      expression.getStartPosition(),
      name,
      ScopeAnalyzer.METHODS | ScopeAnalyzer.CHECK_VISIBILITY)) return true;

  Name qualifier = ((ThisExpression) expression).getQualifier();
  if (qualifier != null) {
    ITypeBinding declaringClass = ((IMethodBinding) name.resolveBinding()).getDeclaringClass();
    if (declaringClass == null) return true;

    ITypeBinding caller = getDeclaringType(node);
    if (caller == null) return true;

    ITypeBinding callee = (ITypeBinding) qualifier.resolveBinding();
    if (callee == null) return true;

    if (callee.isAssignmentCompatible(declaringClass)
        && caller.isAssignmentCompatible(declaringClass)) return true;
  }

  fOperations.add(
      new CompilationUnitRewriteOperation() {
        @Override
        public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model)
            throws CoreException {
          ASTRewrite rewrite = cuRewrite.getASTRewrite();
          TextEditGroup group =
              createTextEditGroup(
                  FixMessages.CodeStyleFix_removeThis_groupDescription, cuRewrite);
          rewrite.remove(node.getExpression(), group);
        }
      });
  return super.visit(node);
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
/**
 * Collects the necessary imports for an element represented by the specified AST node.
 *
 * @param project the java project containing the element
 * @param node the AST node specifying the element for which imports should be collected
 * @param typeBindings the set of type bindings (element type: Set <ITypeBinding>).
 * @param staticBindings the set of bindings (element type: Set <IBinding>).
 * @param excludeBindings the set of bindings to exclude (element type: Set <IBinding>).
 * @param declarations <code>true</code> if method declarations are treated as abstract, <code>
 *     false</code> otherwise
 */
public static void collectImports(
    final IJavaProject project,
    final ASTNode node,
    final Collection<ITypeBinding> typeBindings,
    final Collection<IBinding> staticBindings,
    final Collection<IBinding> excludeBindings,
    final boolean declarations) {
  Assert.isNotNull(project);
  Assert.isNotNull(node);
  Assert.isNotNull(typeBindings);
  Assert.isNotNull(staticBindings);
  final Set<SimpleName> types = new HashSet<SimpleName>();
  final Set<SimpleName> members = new HashSet<SimpleName>();

  ImportReferencesCollector.collect(node, project, null, declarations, types, members);

  Name name = null;
  IBinding binding = null;
  for (final Iterator<SimpleName> iterator = types.iterator(); iterator.hasNext(); ) {
    name = iterator.next();
    binding = name.resolveBinding();
    if (binding instanceof ITypeBinding) {
      final ITypeBinding type = (ITypeBinding) binding;
      if (excludeBindings == null || !excludeBindings.contains(type)) typeBindings.add(type);
    }
  }
  for (final Iterator<SimpleName> iterator = members.iterator(); iterator.hasNext(); ) {
    name = iterator.next();
    binding = name.resolveBinding();
    if (binding != null && (excludeBindings == null || !excludeBindings.contains(binding)))
      staticBindings.add(binding);
  }
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
private static VariableDeclaration getVariableDeclaration(Name node) {
  IBinding binding = node.resolveBinding();
  if (binding == null && node.getParent() instanceof VariableDeclaration)
    return (VariableDeclaration) node.getParent();

  if (binding != null && binding.getKind() == IBinding.VARIABLE) {
    CompilationUnit cu = (CompilationUnit) ASTNodes.getParent(node, CompilationUnit.class);
    return ASTNodes.findVariableDeclaration(((IVariableBinding) binding), cu);
  }
  return null;
}
 

import org.eclipse.jdt.core.dom.Name; //导入方法依赖的package包/类
public static boolean isEnumCase(ASTNode node) {
  if (node instanceof SwitchCase) {
    final SwitchCase caze = (SwitchCase) node;
    final Expression expression = caze.getExpression();
    if (expression instanceof Name) {
      final Name name = (Name) expression;
      final IBinding binding = name.resolveBinding();
      if (binding instanceof IVariableBinding) {
        IVariableBinding variableBinding = (IVariableBinding) binding;
        return variableBinding.isEnumConstant();
      }
    }
  }
  return false;
}