import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static String getCatchBodyContent(
    ICompilationUnit cu,
    String exceptionType,
    String variableName,
    ASTNode locationInAST,
    String lineDelimiter)
    throws CoreException {
  String enclosingType = ""; // $NON-NLS-1$
  String enclosingMethod = ""; // $NON-NLS-1$

  if (locationInAST != null) {
    MethodDeclaration parentMethod = ASTResolving.findParentMethodDeclaration(locationInAST);
    if (parentMethod != null) {
      enclosingMethod = parentMethod.getName().getIdentifier();
      locationInAST = parentMethod;
    }
    ASTNode parentType = ASTResolving.findParentType(locationInAST);
    if (parentType instanceof AbstractTypeDeclaration) {
      enclosingType = ((AbstractTypeDeclaration) parentType).getName().getIdentifier();
    }
  }
  return getCatchBodyContent(
      cu, exceptionType, variableName, enclosingType, enclosingMethod, lineDelimiter);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean visit(SimpleName node) {
  if (node.getParent() instanceof VariableDeclarationFragment) return super.visit(node);
  if (node.getParent() instanceof SingleVariableDeclaration) return super.visit(node);

  IBinding binding = node.resolveBinding();
  if (!(binding instanceof IVariableBinding)) return super.visit(node);

  binding = ((IVariableBinding) binding).getVariableDeclaration();
  if (ASTResolving.isWriteAccess(node)) {
    List<SimpleName> list;
    if (fResult.containsKey(binding)) {
      list = fResult.get(binding);
    } else {
      list = new ArrayList<SimpleName>();
    }
    list.add(node);
    fResult.put(binding, list);
  }

  return super.visit(node);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
private static CompilationUnit findCUForMethod(
    CompilationUnit compilationUnit, ICompilationUnit cu, IMethodBinding methodBinding) {
  ASTNode methodDecl = compilationUnit.findDeclaringNode(methodBinding.getMethodDeclaration());
  if (methodDecl == null) {
    // is methodDecl defined in another CU?
    ITypeBinding declaringTypeDecl = methodBinding.getDeclaringClass().getTypeDeclaration();
    if (declaringTypeDecl.isFromSource()) {
      ICompilationUnit targetCU = null;
      try {
        targetCU =
            ASTResolving.findCompilationUnitForBinding(cu, compilationUnit, declaringTypeDecl);
      } catch (JavaModelException e) {
        /* can't do better */
      }
      if (targetCU != null) {
        return ASTResolving.createQuickFixAST(targetCU, null);
      }
    }
    return null;
  }
  return compilationUnit;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
/**
 * @param e
 * @return int Checks.IS_RVALUE if e is an rvalue Checks.IS_RVALUE_GUESSED if e is guessed as an
 *     rvalue Checks.NOT_RVALUE_VOID if e is not an rvalue because its type is void
 *     Checks.NOT_RVALUE_MISC if e is not an rvalue for some other reason
 */
public static int checkExpressionIsRValue(Expression e) {
  if (e instanceof Name) {
    if (!(((Name) e).resolveBinding() instanceof IVariableBinding)) {
      return NOT_RVALUE_MISC;
    }
  }
  if (e instanceof Annotation) return NOT_RVALUE_MISC;

  ITypeBinding tb = e.resolveTypeBinding();
  boolean guessingRequired = false;
  if (tb == null) {
    guessingRequired = true;
    tb = ASTResolving.guessBindingForReference(e);
  }
  if (tb == null) return NOT_RVALUE_MISC;
  else if (tb.getName().equals("void")) // $NON-NLS-1$
  return NOT_RVALUE_VOID;

  return guessingRequired ? IS_RVALUE_GUESSED : IS_RVALUE;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
private boolean isVoidMethod() {
  ITypeBinding binding = null;
  LambdaExpression enclosingLambdaExpr =
      ASTResolving.findEnclosingLambdaExpression(getFirstSelectedNode());
  if (enclosingLambdaExpr != null) {
    IMethodBinding methodBinding = enclosingLambdaExpr.resolveMethodBinding();
    if (methodBinding != null) {
      binding = methodBinding.getReturnType();
    }
  } else {
    // if we have an initializer
    if (fEnclosingMethodBinding == null) return true;
    binding = fEnclosingMethodBinding.getReturnType();
  }
  if (fEnclosingBodyDeclaration
      .getAST()
      .resolveWellKnownType("void")
      .equals(binding)) // $NON-NLS-1$
  return true;
  return false;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
private void initializeDestinations() {
  List<ASTNode> result = new ArrayList<ASTNode>();
  BodyDeclaration decl = fAnalyzer.getEnclosingBodyDeclaration();
  ASTNode current = ASTResolving.findParentType(decl.getParent());
  if (fAnalyzer.isValidDestination(current)) {
    result.add(current);
  }
  if (current != null
      && (decl instanceof MethodDeclaration
          || decl instanceof Initializer
          || decl instanceof FieldDeclaration)) {
    ITypeBinding binding = ASTNodes.getEnclosingType(current);
    ASTNode next = ASTResolving.findParentType(current.getParent());
    while (next != null && binding != null && binding.isNested()) {
      if (fAnalyzer.isValidDestination(next)) {
        result.add(next);
      }
      current = next;
      binding = ASTNodes.getEnclosingType(current);
      next = ASTResolving.findParentType(next.getParent());
    }
  }
  fDestinations = result.toArray(new ASTNode[result.size()]);
  fDestination = fDestinations[fDestinationIndex];
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
@Override
protected ASTRewrite getRewrite() throws CoreException {
  CompilationUnit cu = ASTResolving.findParentCompilationUnit(fOriginalNode);
  switch (fVariableKind) {
    case PARAM:
      return doAddParam(cu);
    case FIELD:
    case CONST_FIELD:
      return doAddField(cu);
    case LOCAL:
      return doAddLocal(cu);
    case ENUM_CONST:
      return doAddEnumConst(cu);
    default:
      throw new IllegalArgumentException(
          "Unsupported variable kind: " + fVariableKind); // $NON-NLS-1$
  }
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
private ASTRewrite doAddField(CompilationUnit astRoot) {
  SimpleName node = fOriginalNode;
  boolean isInDifferentCU = false;

  ASTNode newTypeDecl = astRoot.findDeclaringNode(fSenderBinding);
  if (newTypeDecl == null) {
    astRoot = ASTResolving.createQuickFixAST(getCompilationUnit(), null);
    newTypeDecl = astRoot.findDeclaringNode(fSenderBinding.getKey());
    isInDifferentCU = true;
  }
  ImportRewrite imports = createImportRewrite(astRoot);
  ImportRewriteContext importRewriteContext =
      new ContextSensitiveImportRewriteContext(
          ASTResolving.findParentBodyDeclaration(node), imports);

  if (newTypeDecl != null) {
    AST ast = newTypeDecl.getAST();

    ASTRewrite rewrite = ASTRewrite.create(ast);

    VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
    fragment.setName(ast.newSimpleName(node.getIdentifier()));

    Type type = evaluateVariableType(ast, imports, importRewriteContext, fSenderBinding);

    FieldDeclaration newDecl = ast.newFieldDeclaration(fragment);
    newDecl.setType(type);
    newDecl
        .modifiers()
        .addAll(ASTNodeFactory.newModifiers(ast, evaluateFieldModifiers(newTypeDecl)));

    if (fSenderBinding.isInterface() || fVariableKind == CONST_FIELD) {
      fragment.setInitializer(ASTNodeFactory.newDefaultExpression(ast, type, 0));
    }

    ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
    List<BodyDeclaration> decls =
        ASTNodes.<BodyDeclaration>getChildListProperty(newTypeDecl, property);

    int maxOffset = isInDifferentCU ? -1 : node.getStartPosition();

    int insertIndex = findFieldInsertIndex(decls, newDecl, maxOffset);

    ListRewrite listRewriter = rewrite.getListRewrite(newTypeDecl, property);
    listRewriter.insertAt(newDecl, insertIndex, null);

    ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
        getLinkedProposalModel(), rewrite, newDecl.modifiers(), fSenderBinding.isInterface());

    addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
    if (!isInDifferentCU) {
      addLinkedPosition(rewrite.track(node), true, KEY_NAME);
    }
    addLinkedPosition(rewrite.track(fragment.getName()), false, KEY_NAME);

    if (fragment.getInitializer() != null) {
      addLinkedPosition(rewrite.track(fragment.getInitializer()), false, KEY_INITIALIZER);
    }
    return rewrite;
  }
  return null;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public AssignToVariableAssistProposal(
    ICompilationUnit cu,
    int variableKind,
    ExpressionStatement node,
    ITypeBinding typeBinding,
    int relevance) {
  super("", cu, null, relevance, null); // $NON-NLS-1$

  fVariableKind = variableKind;
  fNodeToAssign = node;
  if (typeBinding.isWildcardType()) {
    typeBinding = ASTResolving.normalizeWildcardType(typeBinding, true, node.getAST());
  }

  fTypeBinding = typeBinding;
  if (variableKind == LOCAL) {
    setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntolocal_description);
    setImage(JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL));
  } else {
    setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntofield_description);
    setImage(JavaPluginImages.get(JavaPluginImages.IMG_FIELD_PRIVATE));
  }
  createImportRewrite((CompilationUnit) node.getRoot());
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnAsyncType(
    ASTNode problemNode, String extraSyncMethodBindingKey) {
  TypeDeclaration asyncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      problemNode, ASTNode.TYPE_DECLARATION);
  assert (asyncTypeDecl != null);

  IType syncType = RemoteServiceUtilities.findSyncType(asyncTypeDecl);
  if (syncType == null) {
    return null;
  }

  MethodDeclaration extraSyncMethodDecl = JavaASTUtils.findMethodDeclaration(
      syncType.getCompilationUnit(), extraSyncMethodBindingKey);
  if (extraSyncMethodDecl == null) {
    return null;
  }

  return Collections.<IJavaCompletionProposal> singletonList(new DeleteMethodProposal(
      syncType.getCompilationUnit(), extraSyncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnSyncType(
    ASTNode problemNode, String extraAsyncMethodBindingKey) {
  TypeDeclaration syncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      problemNode, ASTNode.TYPE_DECLARATION);
  assert (syncTypeDecl != null);

  IType asyncType = RemoteServiceUtilities.findAsyncType(syncTypeDecl);
  if (asyncType == null) {
    return null;
  }

  MethodDeclaration extraAsyncMethodDecl = JavaASTUtils.findMethodDeclaration(
      asyncType.getCompilationUnit(), extraAsyncMethodBindingKey);
  if (extraAsyncMethodDecl == null) {
    return null;
  }

  return Collections.<IJavaCompletionProposal> singletonList(new DeleteMethodProposal(
      asyncType.getCompilationUnit(), extraAsyncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
@Override
protected ASTRewrite getRewrite() throws CoreException {
  CompilationUnit targetAstRoot = ASTResolving.createQuickFixAST(
      getCompilationUnit(), null);
  createImportRewrite(targetAstRoot);

  ASTRewrite rewrite = ASTRewrite.create(targetAstRoot.getAST());

  // Find the method declaration in the AST we just generated (the one that
  // the AST rewriter is hooked up to).
  MethodDeclaration rewriterAstMethodDecl = JavaASTUtils.findMethodDeclaration(
      targetAstRoot, methodDecl.resolveBinding().getKey());
  if (rewriterAstMethodDecl == null) {
    return null;
  }

  // Remove the extra method declaration
  rewrite.remove(rewriterAstMethodDecl, null);

  return rewrite;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnAsyncType(
    ICompilationUnit asyncCompilationUnit, ASTNode problemNode,
    String syncMethodBindingKey) {
  TypeDeclaration asyncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      problemNode, ASTNode.TYPE_DECLARATION);
  assert (asyncTypeDecl != null);
  String asyncQualifiedTypeName = asyncTypeDecl.resolveBinding().getQualifiedName();

  // Lookup the sync version of the interface
  IType syncType = RemoteServiceUtilities.findSyncType(asyncTypeDecl);
  if (syncType == null) {
    return Collections.emptyList();
  }

  MethodDeclaration syncMethodDecl = JavaASTUtils.findMethodDeclaration(
      syncType.getCompilationUnit(), syncMethodBindingKey);
  if (syncMethodDecl == null) {
    return Collections.emptyList();
  }

  return Collections.<IJavaCompletionProposal> singletonList(new CreateAsyncMethodProposal(
      asyncCompilationUnit, asyncQualifiedTypeName, syncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnSyncMethod(
    ASTNode problemNode) {
  // Find the problematic sync method declaration and its declaring type
  MethodDeclaration syncMethodDecl = ASTResolving.findParentMethodDeclaration(problemNode);
  TypeDeclaration syncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      syncMethodDecl, ASTNode.TYPE_DECLARATION);
  assert (syncTypeDecl != null);

  // Lookup the async version of the interface
  IType asyncType = RemoteServiceUtilities.findAsyncType(syncTypeDecl);
  if (asyncType == null) {
    return Collections.emptyList();
  }

  return Collections.<IJavaCompletionProposal> singletonList(new CreateAsyncMethodProposal(
      asyncType.getCompilationUnit(), asyncType.getFullyQualifiedName('.'),
      syncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
@Override
protected ASTRewrite getRewrite() {
  MethodDeclaration dstMethod = findBestUpdateMatch(rpcPair);

  CompilationUnit astRoot = ASTResolving.createQuickFixAST(
      getCompilationUnit(), null);
  createImportRewrite(astRoot);

  ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

  MethodDeclaration rewriterDstMethod = JavaASTUtils.findMethodDeclaration(
      astRoot, dstMethod.resolveBinding().getKey());
  if (rewriterDstMethod == null) {
    return null;
  }

  MethodDeclaration newSignature = computeMethodSignature(rewrite.getAST(),
      rpcPair, rewriterDstMethod);

  rewrite.replace(rewriterDstMethod, newSignature, null);

  return rewrite;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
@Override
protected ASTRewrite getRewrite() {
  CompilationUnit targetAstRoot = ASTResolving.createQuickFixAST(
      getCompilationUnit(), null);
  createImportRewrite(targetAstRoot);

  // Find the target type declaration
  TypeDeclaration typeDecl = JavaASTUtils.findTypeDeclaration(targetAstRoot,
      targetQualifiedTypeName);
  if (typeDecl == null) {
    return null;
  }

  ASTRewrite rewrite = ASTRewrite.create(targetAstRoot.getAST());

  // Generate the new method declaration
  MethodDeclaration methodDecl = createMethodDeclaration(rewrite.getAST());

  // Add the new method declaration to the interface
  ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(typeDecl);
  ListRewrite listRewriter = rewrite.getListRewrite(typeDecl, property);
  listRewriter.insertLast(methodDecl, null);

  return rewrite;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnAsyncMethod(
    ASTNode problemNode) {
  // Find the problematic async method declaration and its declaring type
  MethodDeclaration asyncMethodDecl = ASTResolving.findParentMethodDeclaration(problemNode);
  TypeDeclaration asyncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      asyncMethodDecl, ASTNode.TYPE_DECLARATION);
  assert (asyncTypeDecl != null);

  // Lookup the sync version of the interface
  IType syncType = RemoteServiceUtilities.findSyncType(asyncTypeDecl);
  if (syncType == null) {
    return Collections.emptyList();
  }

  return Collections.<IJavaCompletionProposal> singletonList(new CreateSyncMethodProposal(
      syncType.getCompilationUnit(), syncType.getFullyQualifiedName('.'),
      asyncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnSyncType(
    ICompilationUnit syncCompilationUnit, ASTNode problemNode,
    String asyncMethodBindingKey) {
  TypeDeclaration syncTypeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      problemNode, ASTNode.TYPE_DECLARATION);
  assert (syncTypeDecl != null);
  String syncQualifiedTypeName = syncTypeDecl.resolveBinding().getQualifiedName();

  // Lookup the async version of the interface
  IType asyncType = RemoteServiceUtilities.findAsyncType(syncTypeDecl);
  if (asyncType == null) {
    return Collections.emptyList();
  }

  MethodDeclaration asyncMethodDecl = JavaASTUtils.findMethodDeclaration(
      asyncType.getCompilationUnit(), asyncMethodBindingKey);
  if (asyncMethodDecl == null) {
    return Collections.emptyList();
  }

  return Collections.<IJavaCompletionProposal> singletonList(new CreateSyncMethodProposal(
      syncCompilationUnit, syncQualifiedTypeName, asyncMethodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
/**
 * @param e
 * @return int
 *          Checks.IS_RVALUE			if e is an rvalue
 *          Checks.IS_RVALUE_GUESSED	if e is guessed as an rvalue
 *          Checks.NOT_RVALUE_VOID  	if e is not an rvalue because its type is void
 *          Checks.NOT_RVALUE_MISC  	if e is not an rvalue for some other reason
 */
public static int checkExpressionIsRValue(Expression e) {
	if (e instanceof Name) {
		if(!(((Name) e).resolveBinding() instanceof IVariableBinding)) {
			return NOT_RVALUE_MISC;
		}
	}
	if (e instanceof Annotation)
		return NOT_RVALUE_MISC;
		

	ITypeBinding tb= e.resolveTypeBinding();
	boolean guessingRequired= false;
	if (tb == null) {
		guessingRequired= true;
		tb= ASTResolving.guessBindingForReference(e);
	}
	if (tb == null)
		return NOT_RVALUE_MISC;
	else if (tb.getName().equals("void")) //$NON-NLS-1$
		return NOT_RVALUE_VOID;

	return guessingRequired ? IS_RVALUE_GUESSED : IS_RVALUE;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入依赖的package包/类
private boolean isVoidMethod() {
	ITypeBinding binding= null;
	LambdaExpression enclosingLambdaExpr= ASTResolving.findEnclosingLambdaExpression(getFirstSelectedNode());
	if (enclosingLambdaExpr != null) {
		IMethodBinding methodBinding= enclosingLambdaExpr.resolveMethodBinding();
		if (methodBinding != null) {
			binding= methodBinding.getReturnType();
		}
	} else {
		// if we have an initializer
		if (fEnclosingMethodBinding == null)
			return true;
		binding= fEnclosingMethodBinding.getReturnType();
	}
	if (fEnclosingBodyDeclaration.getAST().resolveWellKnownType("void").equals(binding)) //$NON-NLS-1$
		return true;
	return false;
}