Java SuggestedFix.delete方法代码示例

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Void scan(Tree tree, Context context) {
  if (tree == null) {
    return null;
  }
  JCCompilationUnit compilationUnit = context.get(JCCompilationUnit.class);
  for (T beforeTemplate : rule().beforeTemplates()) {
    for (M match : beforeTemplate.match((JCTree) tree, context)) {
      if (rule().rejectMatchesWithComments()) {
        String matchContents = match.getRange(compilationUnit);
        if (matchContents.contains("//") || matchContents.contains("/*")) {
          continue;
        }
      }
      Fix fix;
      if (rule().afterTemplate() == null) {
        fix = SuggestedFix.delete(match.getLocation());
      } else {
        fix = rule().afterTemplate().replace(match);
      }
      listener().onDescribed(new Description(
          match.getLocation(), rule().qualifiedTemplateClass(), fix, SeverityLevel.WARNING));
    }
  }
  return super.scan(tree, context);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchNewClass(NewClassTree newClassTree, VisitorState state) {
  if (!MATCHER.matches(newClassTree, state)) {
    return Description.NO_MATCH;
  }

  StatementTree parent = (StatementTree) state.getPath().getParentPath().getLeaf();

  boolean isLastStatement =
      anyOf(
              new ChildOfBlockOrCase<>(
                  ChildMultiMatcher.MatchType.LAST, Matchers.<StatementTree>isSame(parent)),
              // it could also be a bare if statement with no braces
              parentNode(parentNode(kindIs(IF))))
          .matches(newClassTree, state);

  Fix fix;
  if (isLastStatement) {
    fix = SuggestedFix.prefixWith(newClassTree, "throw ");
  } else {
    fix = SuggestedFix.delete(parent);
  }

  return describeMatch(newClassTree, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private List<Fix> literalReplacement(
    MethodInvocationTree methodInvocationTree, VisitorState state, ExpressionTree lhs) {

  Tree parent = state.getPath().getParentPath().getLeaf();

  // If the parent is an ExpressionStatement, the expression value is ignored, so we can delete
  // the call entirely (or replace removeAll with .clear()). Otherwise, we can't provide a good
  // replacement.
  if (parent instanceof ExpressionStatementTree) {
    Fix fix;
    if (instanceMethod().anyClass().named("removeAll").matches(methodInvocationTree, state)) {
      fix = SuggestedFix.replace(methodInvocationTree, lhs + ".clear()");
    } else {
      fix = SuggestedFix.delete(parent);
    }
    return ImmutableList.of(fix);
  }

  return ImmutableList.of();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchMethodInvocation(
    MethodInvocationTree methodInvocationTree, VisitorState state) {
  if (!matcher.matches(methodInvocationTree, state)) {
    return Description.NO_MATCH;
  }

  List<? extends ExpressionTree> arguments = methodInvocationTree.getArguments();
  ExpressionTree stringLiteralValue = arguments.get(0);
  Fix fix;
  if (arguments.size() == 2) {
    fix = SuggestedFix.swap(arguments.get(0), arguments.get(1));
  } else {
    fix = SuggestedFix.delete(state.getPath().getParentPath().getLeaf());
  }
  return describeMatch(stringLiteralValue, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Description matchNewClass(NewClassTree newClassTree, VisitorState state) {
  if (!MATCHER.matches(newClassTree, state)) {
    return Description.NO_MATCH;
  }

  StatementTree parent = (StatementTree) state.getPath().getParentPath().getLeaf();

  boolean isLastStatement = anyOf(
      new Enclosing.BlockOrCase(lastStatement(Matchers.<StatementTree>isSame(parent))),
      // it could also be a bare if statement with no braces
      parentNode(parentNode(kindIs(IF))))
      .matches(newClassTree, state);

  SuggestedFix suggestedFix = new SuggestedFix();
  if (isLastStatement) {
    suggestedFix.prefixWith(newClassTree, "throw ");
  } else {
    suggestedFix.delete(parent);
  }
  return describeMatch(newClassTree, suggestedFix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchMethodInvocation(MethodInvocationTree methodInvocationTree, VisitorState state) {
  if (!matcher.matches(methodInvocationTree, state)) {
    return Description.NO_MATCH;
  }

  List<? extends ExpressionTree> arguments = methodInvocationTree.getArguments();
  ExpressionTree stringLiteralValue = arguments.get(0);
  SuggestedFix fix = new SuggestedFix();
  if (arguments.size() == 2) {
    fix.swap(arguments.get(0), arguments.get(1));
  } else {
    fix.delete(state.getPath().getParentPath().getLeaf());
  }
  return describeMatch(stringLiteralValue, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
protected final Fix getSuggestedFix(AnnotationTree annotationTree) {
  List<String> values = new ArrayList<>();
  for (ExpressionTree argumentTree : annotationTree.getArguments()) {
    AssignmentTree assignmentTree = (AssignmentTree) argumentTree;
    if (assignmentTree.getVariable().toString().equals("value")) {
      ExpressionTree expressionTree = assignmentTree.getExpression();
      switch (expressionTree.getKind()) {
        case STRING_LITERAL:
          values.add(((String) ((JCTree.JCLiteral) expressionTree).value));
          break;
        case NEW_ARRAY:
          NewArrayTree newArrayTree = (NewArrayTree) expressionTree;
          for (ExpressionTree elementTree : newArrayTree.getInitializers()) {
            values.add((String) ((JCTree.JCLiteral) elementTree).value);
          }
          break;
        default:
          throw new AssertionError("Unknown kind: " + expressionTree.getKind());
      }
      processSuppressWarningsValues(values);
    } else {
      throw new AssertionError("SuppressWarnings has an element other than value=");
    }
  }

  if (values.isEmpty()) {
    return SuggestedFix.delete(annotationTree);
  } else if (values.size() == 1) {
    return SuggestedFix.replace(annotationTree, "@SuppressWarnings(\"" + values.get(0) + "\")");
  } else {
    return SuggestedFix.replace(
        annotationTree, "@SuppressWarnings({\"" + Joiner.on("\", \"").join(values) + "\"})");
  }
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
  if (!CHECK_NOT_NULL_MATCHER.matches(tree, state) || tree.getArguments().isEmpty()) {
    return Description.NO_MATCH;
  }

  Fix fix;
  if (parentNode(Matchers.<MethodInvocationTree>kindIs(Kind.EXPRESSION_STATEMENT))
      .matches(tree, state)) {
    fix = SuggestedFix.delete(state.getPath().getParentPath().getLeaf());
  } else {
    fix = SuggestedFix.replace(tree, tree.getArguments().get(0).toString());
  }
  return describeMatch(tree, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Fix removeTypeUse(Target targetAnnotation, AnnotationTree tree) {
  Set<ElementType> elements = EnumSet.copyOf(Arrays.asList(targetAnnotation.value()));
  elements.removeAll(FORBIDDEN_ELEMENT_TYPES);
  if (elements.isEmpty()) {
    return SuggestedFix.delete(tree);
  }
  return InvalidTargetingOnScopingAnnotation.replaceTargetAnnotation(tree, elements);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Fixes the error by assigning the result of the call to the receiver reference, or deleting the
 * method call.
 */
public Description describe(MethodInvocationTree methodInvocationTree, VisitorState state) {
  // Find the root of the field access chain, i.e. a.intern().trim() ==> a.
  ExpressionTree identifierExpr = ASTHelpers.getRootAssignable(methodInvocationTree);
  String identifierStr = null;
  Type identifierType = null;
  if (identifierExpr != null) {
    identifierStr = identifierExpr.toString();
    if (identifierExpr instanceof JCIdent) {
      identifierType = ((JCIdent) identifierExpr).sym.type;
    } else if (identifierExpr instanceof JCFieldAccess) {
      identifierType = ((JCFieldAccess) identifierExpr).sym.type;
    } else {
      throw new IllegalStateException("Expected a JCIdent or a JCFieldAccess");
    }
  }

  Type returnType =
      ASTHelpers.getReturnType(((JCMethodInvocation) methodInvocationTree).getMethodSelect());

  Fix fix;
  if (identifierStr != null
      && !"this".equals(identifierStr)
      && returnType != null
      && state.getTypes().isAssignable(returnType, identifierType)) {
    // Fix by assigning the assigning the result of the call to the root receiver reference.
    fix = SuggestedFix.prefixWith(methodInvocationTree, identifierStr + " = ");
  } else {
    // Unclear what the programmer intended.  Delete since we don't know what else to do.
    Tree parent = state.getPath().getParentPath().getLeaf();
    fix = SuggestedFix.delete(parent);
  }
  return describeMatch(methodInvocationTree, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Match empty statement if:
 * - Parent statement is an if
 * - The then part of the parent if is an empty statement, and
 * - The else part of the parent if does not exist
 */
@Override
public Description matchEmptyStatement(EmptyStatementTree tree, VisitorState state) {
  boolean matches = false;
  Tree parent = state.getPath().getParentPath().getLeaf();
  if (parent.getKind() == IF) {
    IfTree parentAsIf = (IfTree)parent;
    matches = (parentAsIf.getThenStatement() instanceof EmptyStatementTree) &&
        (parentAsIf.getElseStatement() == null);
  }
  if (!matches) {
    return Description.NO_MATCH;
  }

  /*
   * We suggest different fixes depending on what follows the parent if statement.
   * If there is no statement following the if, then suggest deleting the whole
   * if statement. If the next statement is a block, then suggest deleting the
   * empty then part of the if.  If the next statement is not a block, then also
   * suggest deleting the empty then part of the if.
   */
  boolean nextStmtIsNull = parentNode(nextStatement(Matchers.<StatementTree>isSame(null)))
      .matches(tree, state);

  assert(state.getPath().getParentPath().getLeaf().getKind() == IF);
  IfTree ifParent = (IfTree)state.getPath().getParentPath().getLeaf();
  SuggestedFix fix = new SuggestedFix();
  if (nextStmtIsNull) {
    // No following statements. Delete whole if.
    fix.delete(parent);
    return describeMatch(parent, fix);
  } else {
    // There are more statements. Delete the empty then part of the if.
    fix.delete(ifParent.getThenStatement());
    return describeMatch(ifParent.getThenStatement(), fix);
  }
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Matches any method definitions that fit the following:
 * 1) Defined method is named "equals."
 * 2) Defined method returns a boolean.
 * 3) Defined method takes a single parameter of the same type as the enclosing class.
 * 4) The enclosing class does not have a method defined that really overrides Object.equals().
 */
@Override
@SuppressWarnings("unchecked")    // matchers + varargs cause this
public Description matchMethod(MethodTree methodTree, VisitorState state) {
  if (!MATCHER.matches(methodTree, state)) {
    return Description.NO_MATCH;
  }

  SuggestedFix fix = new SuggestedFix();
  JCClassDecl cls = (JCClassDecl) state.findEnclosing(ClassTree.class);

  if ((cls.getModifiers().flags & ENUM) != 0) {
    /* If the enclosing class is an enum, then just delete the equals method since enums
     * should always be compared for reference equality. Enum defines a final equals method for
     * just this reason. */
    fix.delete(methodTree);
  } else {
    /* Otherwise, change the covariant equals method to override Object.equals. */
    JCTree parameterType = (JCTree) methodTree.getParameters().get(0).getType();
    Name parameterName = ((JCVariableDecl) methodTree.getParameters().get(0)).getName();

    // Add @Override annotation if not present.
    boolean hasOverrideAnnotation = false;
    List<JCAnnotation> annotations = ((JCMethodDecl) methodTree).getModifiers().getAnnotations();
    for (JCAnnotation annotation : annotations) {
      if (annotation.annotationType.type.tsym == state.getSymtab().overrideType.tsym) {
        hasOverrideAnnotation = true;
      }
    }
    if (!hasOverrideAnnotation) {
      fix.prefixWith(methodTree, "@Override\n");
    }

    // Change method signature, substituting Object for parameter type.
    fix.replace(parameterType, "Object");

    // If there is a method body...
    if (methodTree.getBody() != null) {

      // Add type check at start
      String typeCheckStmt = "if (!(" + parameterName + " instanceof " + parameterType + ")) {\n"
          + "  return false;\n"
          + "}\n";
      fix.prefixWith(methodTree.getBody().getStatements().get(0), typeCheckStmt);

      // Cast all uses of the parameter name using a recursive TreeScanner.
      new CastScanner().scan(methodTree.getBody(), new CastState(parameterName,
          parameterType.toString(), fix));
    }
  }

  return describeMatch(methodTree, fix);
}