Java ASTResolving.findParentType方法代码示例

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包/类
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包/类
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包/类
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包/类
private void initDomAST() {
		if (isReadOnly())
			return;
		
		ASTParser parser= ASTParser.newParser(AST.JLS8);
		parser.setSource(getCompilationUnit());
		parser.setResolveBindings(true);
		org.eclipse.jdt.core.dom.ASTNode domAst = parser.createAST(new NullProgressMonitor());
		
//		org.eclipse.jdt.core.dom.AST ast = domAst.getAST();
		
		NodeFinder nf = new NodeFinder(domAst, getCompletionOffset(), 1);
		org.eclipse.jdt.core.dom.ASTNode cv = nf.getCoveringNode();
		
		bodyDeclaration = ASTResolving.findParentBodyDeclaration(cv);
		parentDeclaration = ASTResolving.findParentType(cv);
		domInitialized = true;
	}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private void initDomAST() {
		if (isReadOnly())
			return;
		
		ASTParser parser= ASTParser.newParser(AST.JLS4);
		parser.setSource(getCompilationUnit());
		parser.setResolveBindings(true);
		org.eclipse.jdt.core.dom.ASTNode domAst = parser.createAST(new NullProgressMonitor());
		
//		org.eclipse.jdt.core.dom.AST ast = domAst.getAST();
		
		NodeFinder nf = new NodeFinder(domAst, getCompletionOffset(), 1);
		org.eclipse.jdt.core.dom.ASTNode cv = nf.getCoveringNode();
		
		bodyDeclaration = ASTResolving.findParentBodyDeclaration(cv);
		parentDeclaration = ASTResolving.findParentType(cv);
		domInitialized = true;
	}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
  RefactoringStatus result =
      Checks.validateModifiesFiles(
          ResourceUtil.getFiles(new ICompilationUnit[] {fCu}), getValidationContext());
  if (result.hasFatalError()) return result;

  initAST(pm);

  if (fTempDeclarationNode == null)
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.PromoteTempToFieldRefactoring_select_declaration);

  if (!Checks.isDeclaredIn(fTempDeclarationNode, MethodDeclaration.class))
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.PromoteTempToFieldRefactoring_only_declared_in_methods);

  if (isMethodParameter())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.PromoteTempToFieldRefactoring_method_parameters);

  if (isTempAnExceptionInCatchBlock())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.PromoteTempToFieldRefactoring_exceptions);

  ASTNode declaringType = ASTResolving.findParentType(fTempDeclarationNode);
  if (declaringType instanceof TypeDeclaration && ((TypeDeclaration) declaringType).isInterface())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.PromoteTempToFieldRefactoring_interface_methods);

  result.merge(checkTempTypeForLocalTypeUsage());
  if (result.hasFatalError()) return result;

  checkTempInitializerForLocalTypeUsage();

  if (!fSelfInitializing) initializeDefaults();
  return result;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private ASTNode[] createCallNodes(SnippetFinder.Match duplicate, int modifiers) {
  List<ASTNode> result = new ArrayList<ASTNode>(2);

  IVariableBinding[] locals = fAnalyzer.getCallerLocals();
  for (int i = 0; i < locals.length; i++) {
    result.add(createDeclaration(locals[i], null));
  }

  MethodInvocation invocation = fAST.newMethodInvocation();
  invocation.setName(fAST.newSimpleName(fMethodName));
  ASTNode typeNode = ASTResolving.findParentType(fAnalyzer.getEnclosingBodyDeclaration());
  RefactoringStatus status = new RefactoringStatus();
  while (fDestination != typeNode) {
    fAnalyzer.checkInput(status, fMethodName, typeNode);
    if (!status.isOK()) {
      SimpleName destinationTypeName =
          fAST.newSimpleName(ASTNodes.getEnclosingType(fDestination).getName());
      if ((modifiers & Modifier.STATIC) == 0) {
        ThisExpression thisExpression = fAST.newThisExpression();
        thisExpression.setQualifier(destinationTypeName);
        invocation.setExpression(thisExpression);
      } else {
        invocation.setExpression(destinationTypeName);
      }
      break;
    }
    typeNode = typeNode.getParent();
  }

  List<Expression> arguments = invocation.arguments();
  for (int i = 0; i < fParameterInfos.size(); i++) {
    ParameterInfo parameter = fParameterInfos.get(i);
    arguments.add(ASTNodeFactory.newName(fAST, getMappedName(duplicate, parameter)));
  }
  if (fLinkedProposalModel != null) {
    LinkedProposalPositionGroup nameGroup = fLinkedProposalModel.getPositionGroup(KEY_NAME, true);
    nameGroup.addPosition(fRewriter.track(invocation.getName()), false);
  }

  ASTNode call;
  int returnKind = fAnalyzer.getReturnKind();
  switch (returnKind) {
    case ExtractMethodAnalyzer.ACCESS_TO_LOCAL:
      IVariableBinding binding = fAnalyzer.getReturnLocal();
      if (binding != null) {
        VariableDeclarationStatement decl =
            createDeclaration(getMappedBinding(duplicate, binding), invocation);
        call = decl;
      } else {
        Assignment assignment = fAST.newAssignment();
        assignment.setLeftHandSide(
            ASTNodeFactory.newName(
                fAST, getMappedBinding(duplicate, fAnalyzer.getReturnValue()).getName()));
        assignment.setRightHandSide(invocation);
        call = assignment;
      }
      break;
    case ExtractMethodAnalyzer.RETURN_STATEMENT_VALUE:
      ReturnStatement rs = fAST.newReturnStatement();
      rs.setExpression(invocation);
      call = rs;
      break;
    default:
      call = invocation;
  }

  if (call instanceof Expression && !fAnalyzer.isExpressionSelected()) {
    call = fAST.newExpressionStatement((Expression) call);
  }
  result.add(call);

  // We have a void return statement. The code looks like
  // extracted();
  // return;
  if (returnKind == ExtractMethodAnalyzer.RETURN_STATEMENT_VOID
      && !fAnalyzer.isLastStatementSelected()) {
    result.add(fAST.newReturnStatement());
  }
  return result.toArray(new ASTNode[result.size()]);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private int evaluateFieldModifiers(ASTNode newTypeDecl) {
  if (fSenderBinding.isAnnotation()) {
    return 0;
  }
  if (fSenderBinding.isInterface()) {
    // for interface members copy the modifiers from an existing field
    FieldDeclaration[] fieldDecls = ((TypeDeclaration) newTypeDecl).getFields();
    if (fieldDecls.length > 0) {
      return fieldDecls[0].getModifiers();
    }
    return 0;
  }
  int modifiers = 0;

  if (fVariableKind == CONST_FIELD) {
    modifiers |= Modifier.FINAL | Modifier.STATIC;
  } else {
    ASTNode parent = fOriginalNode.getParent();
    if (parent instanceof QualifiedName) {
      IBinding qualifierBinding = ((QualifiedName) parent).getQualifier().resolveBinding();
      if (qualifierBinding instanceof ITypeBinding) {
        modifiers |= Modifier.STATIC;
      }
    } else if (ASTResolving.isInStaticContext(fOriginalNode)) {
      modifiers |= Modifier.STATIC;
    }
  }
  ASTNode node = ASTResolving.findParentType(fOriginalNode, true);
  if (newTypeDecl.equals(node)) {
    modifiers |= Modifier.PRIVATE;
  } else if (node instanceof AnonymousClassDeclaration) {
    modifiers |= Modifier.PROTECTED;
  } else {
    modifiers |= Modifier.PUBLIC;
  }

  return modifiers;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
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;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
	RefactoringStatus result= Checks.validateModifiesFiles(
		ResourceUtil.getFiles(new ICompilationUnit[]{fCu}),
		getValidationContext());
	if (result.hasFatalError())
		return result;

	initAST(pm);

	if (fTempDeclarationNode == null)
		return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.PromoteTempToFieldRefactoring_select_declaration);

	if (! Checks.isDeclaredIn(fTempDeclarationNode, MethodDeclaration.class))
		return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.PromoteTempToFieldRefactoring_only_declared_in_methods);

	if (isMethodParameter())
		return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.PromoteTempToFieldRefactoring_method_parameters);

	if (isTempAnExceptionInCatchBlock())
		return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.PromoteTempToFieldRefactoring_exceptions);

	ASTNode declaringType= ASTResolving.findParentType(fTempDeclarationNode);
	if (declaringType instanceof TypeDeclaration && ((TypeDeclaration) declaringType).isInterface())
		return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.PromoteTempToFieldRefactoring_interface_methods);
	
	result.merge(checkTempTypeForLocalTypeUsage());
	if (result.hasFatalError())
	    return result;

	checkTempInitializerForLocalTypeUsage();

	if (!fSelfInitializing)
		initializeDefaults();
	return result;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private int evaluateFieldModifiers(ASTNode newTypeDecl) {
	if (fSenderBinding.isAnnotation()) {
		return 0;
	}
	if (fSenderBinding.isInterface()) {
		// for interface members copy the modifiers from an existing field
		FieldDeclaration[] fieldDecls= ((TypeDeclaration) newTypeDecl).getFields();
		if (fieldDecls.length > 0) {
			return fieldDecls[0].getModifiers();
		}
		return 0;
	}
	int modifiers= 0;

	if (fVariableKind == CONST_FIELD) {
		modifiers |= Modifier.FINAL | Modifier.STATIC;
	} else {
		ASTNode parent= fOriginalNode.getParent();
		if (parent instanceof QualifiedName) {
			IBinding qualifierBinding= ((QualifiedName)parent).getQualifier().resolveBinding();
			if (qualifierBinding instanceof ITypeBinding) {
				modifiers |= Modifier.STATIC;
			}
		} else if (ASTResolving.isInStaticContext(fOriginalNode)) {
			modifiers |= Modifier.STATIC;
		}
	}
	ASTNode node= ASTResolving.findParentType(fOriginalNode, true);
	if (newTypeDecl.equals(node)) {
		modifiers |= Modifier.PRIVATE;
	} else if (node instanceof AnonymousClassDeclaration) {
		modifiers |= Modifier.PROTECTED;
	} else {
		modifiers |= Modifier.PUBLIC;
	}

	return modifiers;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
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;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
public RefactoringStatus checkInitialConditions(ImportRewrite rewriter) {
  RefactoringStatus result = getStatus();
  checkExpression(result);
  if (result.hasFatalError()) return result;

  List<ASTNode> validDestinations = new ArrayList<ASTNode>();
  ASTNode destination = ASTResolving.findParentType(fEnclosingBodyDeclaration.getParent());
  while (destination != null) {
    if (isValidDestination(destination)) {
      validDestinations.add(destination);
    }
    destination = ASTResolving.findParentType(destination.getParent());
  }
  if (validDestinations.size() == 0) {
    result.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_no_valid_destination_type);
    return result;
  }

  fReturnKind = UNDEFINED;
  fMaxVariableId = LocalVariableIndex.perform(fEnclosingBodyDeclaration);
  if (analyzeSelection(result).hasFatalError()) return result;

  int returns = fReturnKind == NO ? 0 : 1;
  if (fReturnValue != null) {
    fReturnKind = ACCESS_TO_LOCAL;
    returns++;
  }
  if (isExpressionSelected()) {
    fReturnKind = EXPRESSION;
    returns++;
  }

  if (returns > 1) {
    result.addFatalError(
        RefactoringCoreMessages.ExtractMethodAnalyzer_ambiguous_return_value,
        JavaStatusContext.create(fCUnit, getSelection()));
    fReturnKind = MULTIPLE;
    return result;
  }
  initReturnType(rewriter);
  return result;
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private static String generateDisplayName(MethodDeclaration methodDecl) {
  TypeDeclaration typeDecl = (TypeDeclaration) ASTResolving.findParentType(methodDecl);
  return MessageFormat.format("Remove method ''{0}'' from type ''{1}''",
      methodDecl.getName().getIdentifier(),
      typeDecl.getName().getIdentifier());
}