Java IExpressionFragment类代码示例

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private boolean isLiteralNodeSelected() throws JavaModelException {
  IExpressionFragment fragment = getSelectedExpression();
  if (fragment == null) return false;
  Expression expression = fragment.getAssociatedExpression();
  if (expression == null) return false;
  switch (expression.getNodeType()) {
    case ASTNode.BOOLEAN_LITERAL:
    case ASTNode.CHARACTER_LITERAL:
    case ASTNode.NULL_LITERAL:
    case ASTNode.NUMBER_LITERAL:
      return true;

    default:
      return false;
  }
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private RefactoringStatus checkInitializer() {
  Expression initializer = getInitializer();
  if (initializer == null)
    return RefactoringStatus.createStatus(
        RefactoringStatus.FATAL,
        RefactoringCoreMessages.InlineConstantRefactoring_blank_finals,
        null,
        Corext.getPluginId(),
        RefactoringStatusCodes.CANNOT_INLINE_BLANK_FINAL,
        null);

  fInitializerAllStaticFinal =
      ConstantChecks.isStaticFinalConstant(
          (IExpressionFragment) ASTFragmentFactory.createFragmentForFullSubtree(initializer));
  fInitializerChecked = true;
  return new RefactoringStatus();
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
@Override
public boolean visit(MethodInvocation node) {
  if (node.getExpression() == null) {
    visitName(node.getName());
  } else {
    fResult &=
        new LoadTimeConstantChecker(
                (IExpressionFragment)
                    ASTFragmentFactory.createFragmentForFullSubtree(node.getExpression()))
            .check();
  }

  return false;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private RefactoringStatus checkSelection(IProgressMonitor pm) throws JavaModelException {
  try {
    pm.beginTask("", 2); // $NON-NLS-1$

    IExpressionFragment selectedExpression = getSelectedExpression();

    if (selectedExpression == null) {
      String message = RefactoringCoreMessages.ExtractConstantRefactoring_select_expression;
      return CodeRefactoringUtil.checkMethodSyntaxErrors(
          fSelectionStart, fSelectionLength, fCuRewrite.getRoot(), message);
    }
    pm.worked(1);

    RefactoringStatus result = new RefactoringStatus();
    result.merge(checkExpression());
    if (result.hasFatalError()) return result;
    pm.worked(1);

    return result;
  } finally {
    pm.done();
  }
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private static boolean depends(IExpressionFragment selected, BodyDeclaration bd) {
  /* We currently consider selected to depend on bd only if db includes a declaration
   * of a static field on which selected depends.
   *
   * A more accurate strategy might be to also check if bd contains (or is) a
   * static initializer containing code which changes the value of a static field on
   * which selected depends.  However, if a static is written to multiple times within
   * during class initialization, it is difficult to predict which value should be used.
   * This would depend on which value is used by expressions instances for which the new
   * constant will be substituted, and there may be many of these; in each, the
   * static field in question may have taken on a different value (if some of these uses
   * occur within static initializers).
   */

  if (bd instanceof FieldDeclaration) {
    FieldDeclaration fieldDecl = (FieldDeclaration) bd;
    for (Iterator<VariableDeclarationFragment> fragments = fieldDecl.fragments().iterator();
        fragments.hasNext(); ) {
      VariableDeclarationFragment fragment = fragments.next();
      SimpleName staticFieldName = fragment.getName();
      if (selected.getSubFragmentsMatching(
                  ASTFragmentFactory.createFragmentForFullSubtree(staticFieldName))
              .length
          != 0) return true;
    }
  }
  return false;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private void initializeSelectedExpression(CompilationUnitRewrite cuRewrite) throws JavaModelException {
	IASTFragment fragment= ASTFragmentFactory.createFragmentForSourceRange(
			new SourceRange(fSelectionStart, fSelectionLength), cuRewrite.getRoot(), cuRewrite.getCu());

	if (! (fragment instanceof IExpressionFragment))
		return;

	//TODO: doesn't handle selection of partial Expressions
	Expression expression= ((IExpressionFragment) fragment).getAssociatedExpression();
	if (fragment.getStartPosition() != expression.getStartPosition()
			|| fragment.getLength() != expression.getLength())
		return;

	if (Checks.isInsideJavadoc(expression))
		return;
	//TODO: exclude invalid selections
	if (Checks.isEnumCase(expression.getParent()))
		return;

	fSelectedExpression= expression;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private boolean isLiteralNodeSelected() throws JavaModelException {
	IExpressionFragment fragment= getSelectedExpression();
	if (fragment == null)
		return false;
	Expression expression= fragment.getAssociatedExpression();
	if (expression == null)
		return false;
	switch (expression.getNodeType()) {
		case ASTNode.BOOLEAN_LITERAL:
		case ASTNode.CHARACTER_LITERAL:
		case ASTNode.NULL_LITERAL:
		case ASTNode.NUMBER_LITERAL:
			return true;

		default:
			return false;
	}
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private RefactoringStatus checkSelection(IProgressMonitor pm) throws JavaModelException {
	try {
		pm.beginTask("", 2); //$NON-NLS-1$

		IExpressionFragment selectedExpression= getSelectedExpression();

		if (selectedExpression == null) {
			String message= RefactoringCoreMessages.ExtractConstantRefactoring_select_expression;
			return CodeRefactoringUtil.checkMethodSyntaxErrors(fSelectionStart, fSelectionLength, fCuRewrite.getRoot(), message);
		}
		pm.worked(1);

		RefactoringStatus result= new RefactoringStatus();
		result.merge(checkExpression());
		if (result.hasFatalError())
			return result;
		pm.worked(1);

		return result;
	} finally {
		pm.done();
	}
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private boolean isLiteralNodeSelected() throws JavaModelException {
	IExpressionFragment fragment= getSelectedExpression();
	if (fragment == null)
		return false;
	Expression expression= fragment.getAssociatedExpression();
	if (expression == null)
		return false;
	switch (expression.getNodeType()) {
		case ASTNode.BOOLEAN_LITERAL :
		case ASTNode.CHARACTER_LITERAL :
		case ASTNode.NULL_LITERAL :
		case ASTNode.NUMBER_LITERAL :
			return true;

		default :
			return false;
	}
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private RefactoringStatus checkExpression() throws JavaModelException {
	RefactoringStatus result= new RefactoringStatus();
	result.merge(checkExpressionBinding());
	if(result.hasFatalError())
		return result;
	checkAllStaticFinal();

	IExpressionFragment selectedExpression= getSelectedExpression();
	Expression associatedExpression= selectedExpression.getAssociatedExpression();
	if (associatedExpression instanceof NullLiteral)
		result.merge(RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ExtractConstantRefactoring_null_literals));
	else if (!ConstantChecks.isLoadTimeConstant(selectedExpression))
		result.merge(RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ExtractConstantRefactoring_not_load_time_constant));
	else if (associatedExpression instanceof SimpleName) {
		if (associatedExpression.getParent() instanceof QualifiedName && associatedExpression.getLocationInParent() == QualifiedName.NAME_PROPERTY
				|| associatedExpression.getParent() instanceof FieldAccess && associatedExpression.getLocationInParent() == FieldAccess.NAME_PROPERTY)
			return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ExtractConstantRefactoring_select_expression);
	}

	return result;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private static boolean depends(IExpressionFragment selected, BodyDeclaration bd) {
	/* We currently consider selected to depend on bd only if db includes a declaration
	 * of a static field on which selected depends.
	 *
	 * A more accurate strategy might be to also check if bd contains (or is) a
	 * static initializer containing code which changes the value of a static field on
	 * which selected depends.  However, if a static is written to multiple times within
	 * during class initialization, it is difficult to predict which value should be used.
	 * This would depend on which value is used by expressions instances for which the new
	 * constant will be substituted, and there may be many of these; in each, the
	 * static field in question may have taken on a different value (if some of these uses
	 * occur within static initializers).
	 */

	if(bd instanceof FieldDeclaration) {
		FieldDeclaration fieldDecl = (FieldDeclaration) bd;
		for(Iterator<VariableDeclarationFragment> fragments = fieldDecl.fragments().iterator(); fragments.hasNext();) {
			VariableDeclarationFragment fragment = fragments.next();
			SimpleName staticFieldName = fragment.getName();
			if(selected.getSubFragmentsMatching(ASTFragmentFactory.createFragmentForFullSubtree(staticFieldName)).length != 0)
				return true;
		}
	}
	return false;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private IExpressionFragment getFirstReplacedExpression() throws JavaModelException {
  if (!fReplaceAllOccurrences) return getSelectedExpression();
  IASTFragment[] nodesToReplace = retainOnlyReplacableMatches(getMatchingFragments());
  if (nodesToReplace.length == 0) return getSelectedExpression();
  Comparator<IASTFragment> comparator =
      new Comparator<IASTFragment>() {

        public int compare(IASTFragment o1, IASTFragment o2) {
          return o1.getStartPosition() - o2.getStartPosition();
        }
      };
  Arrays.sort(nodesToReplace, comparator);
  return (IExpressionFragment) nodesToReplace[0];
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private String[] getExcludedVariableNames() {
  if (fExcludedVariableNames == null) {
    try {
      IExpressionFragment expr = getSelectedExpression();
      Collection<String> takenNames =
          new ScopeAnalyzer(fCuRewrite.getRoot())
              .getUsedVariableNames(expr.getStartPosition(), expr.getLength());
      fExcludedVariableNames = takenNames.toArray(new String[takenNames.size()]);
    } catch (JavaModelException e) {
      fExcludedVariableNames = new String[0];
    }
  }
  return fExcludedVariableNames;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private RefactoringStatus checkExpression() throws JavaModelException {
  RefactoringStatus result = new RefactoringStatus();
  result.merge(checkExpressionBinding());
  if (result.hasFatalError()) return result;
  checkAllStaticFinal();

  IExpressionFragment selectedExpression = getSelectedExpression();
  Expression associatedExpression = selectedExpression.getAssociatedExpression();
  if (associatedExpression instanceof NullLiteral)
    result.merge(
        RefactoringStatus.createFatalErrorStatus(
            RefactoringCoreMessages.ExtractConstantRefactoring_null_literals));
  else if (!ConstantChecks.isLoadTimeConstant(selectedExpression))
    result.merge(
        RefactoringStatus.createFatalErrorStatus(
            RefactoringCoreMessages.ExtractConstantRefactoring_not_load_time_constant));
  else if (associatedExpression instanceof SimpleName) {
    if (associatedExpression.getParent() instanceof QualifiedName
            && associatedExpression.getLocationInParent() == QualifiedName.NAME_PROPERTY
        || associatedExpression.getParent() instanceof FieldAccess
            && associatedExpression.getLocationInParent() == FieldAccess.NAME_PROPERTY)
      return RefactoringStatus.createFatalErrorStatus(
          RefactoringCoreMessages.ExtractConstantRefactoring_select_expression);
  }

  return result;
}
 

import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment; //导入依赖的package包/类
private void createConstantDeclaration() throws CoreException {
  Type type = getConstantType();

  IExpressionFragment fragment = getSelectedExpression();
  Expression initializer =
      getSelectedExpression().createCopyTarget(fCuRewrite.getASTRewrite(), true);

  AST ast = fCuRewrite.getAST();
  VariableDeclarationFragment variableDeclarationFragment = ast.newVariableDeclarationFragment();
  variableDeclarationFragment.setName(ast.newSimpleName(fConstantName));
  variableDeclarationFragment.setInitializer(initializer);

  FieldDeclaration fieldDeclaration = ast.newFieldDeclaration(variableDeclarationFragment);
  fieldDeclaration.setType(type);
  Modifier.ModifierKeyword accessModifier = Modifier.ModifierKeyword.toKeyword(fVisibility);
  if (accessModifier != null) fieldDeclaration.modifiers().add(ast.newModifier(accessModifier));
  fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
  fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));

  boolean createComments =
      JavaPreferencesSettings.getCodeGenerationSettings(fCu.getJavaProject()).createComments;
  if (createComments) {
    String comment =
        CodeGeneration.getFieldComment(
            fCu, getConstantTypeName(), fConstantName, StubUtility.getLineDelimiterUsed(fCu));
    if (comment != null && comment.length() > 0) {
      Javadoc doc =
          (Javadoc) fCuRewrite.getASTRewrite().createStringPlaceholder(comment, ASTNode.JAVADOC);
      fieldDeclaration.setJavadoc(doc);
    }
  }

  AbstractTypeDeclaration parent = getContainingTypeDeclarationNode();
  ListRewrite listRewrite =
      fCuRewrite.getASTRewrite().getListRewrite(parent, parent.getBodyDeclarationsProperty());
  TextEditGroup msg =
      fCuRewrite.createGroupDescription(
          RefactoringCoreMessages.ExtractConstantRefactoring_declare_constant);
  if (insertFirst()) {
    listRewrite.insertFirst(fieldDeclaration, msg);
  } else {
    listRewrite.insertAfter(fieldDeclaration, getNodeToInsertConstantDeclarationAfter(), msg);
  }

  if (fLinkedProposalModel != null) {
    ASTRewrite rewrite = fCuRewrite.getASTRewrite();
    LinkedProposalPositionGroup nameGroup = fLinkedProposalModel.getPositionGroup(KEY_NAME, true);
    nameGroup.addPosition(rewrite.track(variableDeclarationFragment.getName()), true);

    String[] nameSuggestions = guessConstantNames();
    if (nameSuggestions.length > 0 && !nameSuggestions[0].equals(fConstantName)) {
      nameGroup.addProposal(fConstantName, null, nameSuggestions.length + 1);
    }
    for (int i = 0; i < nameSuggestions.length; i++) {
      nameGroup.addProposal(nameSuggestions[i], null, nameSuggestions.length - i);
    }

    LinkedProposalPositionGroup typeGroup = fLinkedProposalModel.getPositionGroup(KEY_TYPE, true);
    typeGroup.addPosition(rewrite.track(type), true);

    ITypeBinding typeBinding = guessBindingForReference(fragment.getAssociatedExpression());
    if (typeBinding != null) {
      ITypeBinding[] relaxingTypes = ASTResolving.getNarrowingTypes(ast, typeBinding);
      for (int i = 0; i < relaxingTypes.length; i++) {
        typeGroup.addProposal(relaxingTypes[i], fCuRewrite.getCu(), relaxingTypes.length - i);
      }
    }
    boolean isInterface =
        parent.resolveBinding() != null && parent.resolveBinding().isInterface();
    ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
        fLinkedProposalModel, rewrite, fieldDeclaration.modifiers(), isInterface);
  }
}