Java ASTResolving.findParentMethodDeclaration方法代码示例

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包/类
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包/类
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 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包/类
/**
 * @param root the AST root
 * @param node the selected node
 * @return returns a message if there is a problem
 */
public String initialize(CompilationUnit root, ASTNode node) {
	fASTRoot= root;

	if (node instanceof ReturnStatement) {
		fMethodDeclaration= ASTResolving.findParentMethodDeclaration(node);
		if (fMethodDeclaration == null)
			return SearchMessages.MethodExitsFinder_no_return_type_selected;
		return null;

	}

	Type type= ASTNodes.getTopMostType(node);
	if (type == null)
		return SearchMessages.MethodExitsFinder_no_return_type_selected;
	if (type.getLocationInParent() != MethodDeclaration.RETURN_TYPE2_PROPERTY)
		return SearchMessages.MethodExitsFinder_no_return_type_selected;
	fMethodDeclaration= (MethodDeclaration)type.getParent();

	fExitDescription= Messages.format(SearchMessages.MethodExitsFinder_occurrence_exit_description, BasicElementLabels.getJavaElementName(fMethodDeclaration.getName().toString()));
	return null;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
public static List<IJavaCompletionProposal> createProposalsForProblemOnExtraMethod(
    ASTNode problemNode) {
  MethodDeclaration methodDecl = ASTResolving.findParentMethodDeclaration(problemNode);

  return Collections.<IJavaCompletionProposal> singletonList(new DeleteMethodProposal(
      JavaASTUtils.getCompilationUnit(methodDecl), methodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
/**
 * Finds the related RPC components for a given method: declaring type & peer
 * type.
 * 
 * @param node the method's SimpleName AST node.
 * @param peerResolver mapping function for the associated type.
 * @return the {@link RpcPair} encapsulation of the related components.
 */
protected static RpcPair resolveRpcPair(ASTNode node,
    PeerTypeResolver peerResolver) {

  // Find the source method declaration and its declaring type
  MethodDeclaration methodDecl = ASTResolving.findParentMethodDeclaration(node);
  TypeDeclaration typeDecl = (TypeDeclaration) ASTResolving.findAncestor(
      node, ASTNode.TYPE_DECLARATION);
  assert (typeDecl != null);

  // Find the associated sync/async peer type declaration (update target)
  IType dstType = peerResolver.getPeerType(typeDecl);
  if (dstType == null) {
    return null;
  }

  CompilationUnit astRoot = ASTResolving.createQuickFixAST(
      dstType.getCompilationUnit(), null);
  TypeDeclaration dstTypeDecl = JavaASTUtils.findTypeDeclaration(astRoot,
      dstType.getFullyQualifiedName('.'));

  if (dstTypeDecl == null) {
    return null;
  }

  return new RpcPair(typeDecl, methodDecl, dstTypeDecl);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
public static List<IJavaCompletionProposal> createProposals(
    ASTNode problemNode) {
  MethodDeclaration methodDecl = ASTResolving.findParentMethodDeclaration(problemNode);
  return Collections.<IJavaCompletionProposal> singletonList(new ChangeAsyncMethodReturnTypeProposal(
      methodDecl));
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
public String initialize(CompilationUnit root, ASTNode node) {
	fASTRoot= root;
	if (node == null)
		return SearchMessages.ExceptionOccurrencesFinder_no_exception;
	
	MethodDeclaration method= ASTResolving.findParentMethodDeclaration(node);
	if (method == null)
		return SearchMessages.ExceptionOccurrencesFinder_no_exception;
	
	// The ExceptionOccurrencesFinder selects the whole type, no matter what part of it was selected. MethodExitsFinder behaves similar.
	
	if (node instanceof Name) {
		node= ASTNodes.getTopMostName((Name) node);
	}
	ASTNode parent= node.getParent();
	if (node.getLocationInParent() == TagElement.FRAGMENTS_PROPERTY) {
		// in Javadoc tag:
		TagElement tagElement= (TagElement) parent;
		String tagName= tagElement.getTagName();
		if (node instanceof Name
				&& node == tagElement.fragments().get(0)
				&& (TagElement.TAG_EXCEPTION.equals(tagName) || TagElement.TAG_THROWS.equals(tagName))) {
			fSelectedNode= node;
			fException= ((Name) node).resolveTypeBinding();
			fStart= method;
		}
		
	} else {
		Type type= ASTNodes.getTopMostType(node);
		if (type == null) {
			return SearchMessages.ExceptionOccurrencesFinder_no_exception;
		}
		
		// in method's "throws" list:
		if (type.getLocationInParent() == MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY) {
			fSelectedNode= type;
			fException= type.resolveBinding();
			fStart= method;
		}
		
		// in catch clause:
		Type topType= type;
		if (type.getLocationInParent() == UnionType.TYPES_PROPERTY) {
			topType= (Type) type.getParent();
		}
		if (topType.getLocationInParent() == SingleVariableDeclaration.TYPE_PROPERTY
				&& topType.getParent().getLocationInParent() == CatchClause.EXCEPTION_PROPERTY) {
			fSelectedNode= type;
			fException= type.resolveBinding();
			fTryStatement= (TryStatement) topType.getParent().getParent().getParent();
			fStart= fTryStatement.getBody();
		}
	}
	if (fException == null || fStart == null)
		return SearchMessages.ExceptionOccurrencesFinder_no_exception;
	fDescription= Messages.format(SearchMessages.ExceptionOccurrencesFinder_occurrence_description, BasicElementLabels.getJavaElementName(fException.getName()));
	return null;
}