Java SuggestedFix.replace方法代码示例

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
public Description describe(MethodTree tree, VisitorState state) {
  SuggestedFix fix = new SuggestedFix();

  MethodSymbol method = (MethodSymbol) ASTHelpers.getSymbol(tree);

  if (supermethod == null){
    throw new IllegalStateException("Matching supermethod was not found");
  }

  for (int x = 0; x < method.params.size(); x++) {
    Type methodParamType = method.params.get(x).type;
    Type supermethodParamType = supermethod.params.get(x).type;
    if (methodParamType.tsym.name.contentEquals(supermethodParamType.tsym.name)
        && !state.getTypes().isSameType(methodParamType, supermethodParamType)) {
      VariableTree param = tree.getParameters().get(x);

      // TODO(scottjohnson): Name is most likely more qualified than necessary.
      Name replacement = supermethodParamType.tsym.getQualifiedName();
      fix.replace(param, replacement.toString() + " " + param.getName().toString());
    }
  }

  return describeMatch(tree, 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 matchBinary(BinaryTree tree, VisitorState state) {
  if (!BINARY_TREE_MATCHER.matches(tree, state)) {
    return Description.NO_MATCH;
  }

  /*
   * For shift amounts in [32, 63], cast the left operand to long.  Otherwise change the shift
   * amount to whatever would actually be used.
   */
  int intValue = ((Number) ((LiteralTree) tree.getRightOperand()).getValue()).intValue();

  Fix fix;
  if (intValue >= 32 && intValue <= 63) {
    if (tree.getLeftOperand().getKind() == Kind.INT_LITERAL) {
      fix = SuggestedFix.postfixWith(tree.getLeftOperand(), "L");
    } else {
      fix = SuggestedFix.prefixWith(tree, "(long) ");
    }
  } else {
    // This is the equivalent shift distance according to JLS 15.19.
    String actualShiftDistance = Integer.toString(intValue & 0x1f);
    fix = SuggestedFix.replace(tree.getRightOperand(), actualShiftDistance);
  }
  return describeMatch(tree, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/** Constructor a fix that deletes the set of type arguments. */
private Fix buildFix(Tree tree, List<? extends Tree> arguments, VisitorState state) {

  JCTree node = (JCTree) tree;
  int startAbsolute = node.getStartPosition();
  int lower = ((JCTree) arguments.get(0)).getStartPosition() - startAbsolute;
  int upper = state.getEndPosition(arguments.get(arguments.size() - 1)) - startAbsolute;

  CharSequence source = state.getSourceForNode(node);

  while (lower >= 0 && source.charAt(lower) != '<') {
    lower--;
  }
  while (upper < source.length() && source.charAt(upper) != '>') {
    upper++;
  }

  // There's a small chance that the fix will be incorrect because there's a '<' or '>' in
  // a comment (e.g. `this.</*<*/T/*>*/>f()`), it should never be the case that we don't find
  // any angle brackets.
  verify(source.charAt(lower) == '<' && source.charAt(upper) == '>');

  Fix fix = SuggestedFix.replace(startAbsolute + lower, startAbsolute + upper + 1, "");
  return fix;
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
public Description describe(MethodInvocationTree t, VisitorState state) {
  LiteralTree formatTree = (LiteralTree) t.getArguments().get(1);

  String fixedFormatString = state.getSourceForNode((JCTree) formatTree).toString()
      .replaceAll(BAD_PLACEHOLDER_REGEX, "%s");
  SuggestedFix fix = new SuggestedFix();
  if (expectedArguments(fixedFormatString) == t.getArguments().size() - 2) {
    fix.replace(formatTree, fixedFormatString);
    return describeMatch(formatTree, fix);
  } else {
    int missing = t.getArguments().size() - 2 - expectedArguments(fixedFormatString);
    StringBuilder builder = new StringBuilder(fixedFormatString);
    builder.deleteCharAt(builder.length() - 1);
    builder.append(" [%s");
    for (int i = 1; i < missing; i++) {
      builder.append(", %s");
    }
    builder.append("]\"");
    fix.replace(formatTree, builder.toString());
    return describeMatch(t, fix);
  }
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Description.Builder addSuppressWarningsFix(
    Tree suggestTree, Description.Builder builder, String checkerName) {
  SuppressWarnings extantSuppressWarnings =
      ASTHelpers.getAnnotation(suggestTree, SuppressWarnings.class);
  SuggestedFix fix;
  if (extantSuppressWarnings == null) {
    fix = SuggestedFix.prefixWith(suggestTree, "@SuppressWarnings(\"" + checkerName + "\") ");
  } else {
    // need to update the existing list of warnings
    List<String> suppressions = Lists.newArrayList(extantSuppressWarnings.value());
    suppressions.add(checkerName);
    // find the existing annotation, so we can replace it
    ModifiersTree modifiers =
        (suggestTree instanceof MethodTree)
            ? ((MethodTree) suggestTree).getModifiers()
            : ((VariableTree) suggestTree).getModifiers();
    List<? extends AnnotationTree> annotations = modifiers.getAnnotations();
    // noinspection ConstantConditions
    com.google.common.base.Optional<? extends AnnotationTree> suppressWarningsAnnot =
        Iterables.tryFind(
            annotations,
            annot -> annot.getAnnotationType().toString().endsWith("SuppressWarnings"));
    if (!suppressWarningsAnnot.isPresent()) {
      throw new AssertionError("something went horribly wrong");
    }
    String replacement =
        "@SuppressWarnings({"
            + Joiner.on(',').join(Iterables.transform(suppressions, s -> '"' + s + '"'))
            + "}) ";
    fix = SuggestedFix.replace(suppressWarningsAnnot.get(), replacement);
  }
  return builder.addFix(fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Suggested fixes are as follows.  For the byte case, convert the literal to its byte
 * representation. For example, "255" becomes "-1.  For the character case, replace the
 * comparison with "true"/"false" since it's not clear what was intended and that is
 * semantically equivalent.
 *
 * TODO(eaftan): Suggested fixes don't handle side-effecting expressions, such as
 * (d = reader.read()) == -1.  Maybe add special case handling for assignments.
 */
public Description describe(BinaryTree tree, VisitorState state) {
  @SuppressWarnings("unchecked")
  List<ExpressionTree> binaryTreeMatches = ASTHelpers.matchBinaryTree(tree,
      Arrays.asList(Matchers.<ExpressionTree>isInstance(JCLiteral.class),
          Matchers.<ExpressionTree>anything()),
      state);
  if (binaryTreeMatches == null) {
    throw new IllegalStateException("Expected one of the operands to be a literal");
  }
  JCLiteral literal = (JCLiteral) binaryTreeMatches.get(0);
  JCTree nonLiteralOperand = (JCTree) binaryTreeMatches.get(1);
  boolean byteMatch = state.getTypes().isSameType(nonLiteralOperand.type,
      state.getSymtab().byteType);

  boolean willEvaluateTo = (tree.getKind() != Kind.EQUAL_TO);
  SuggestedFix fix = new SuggestedFix();
  String customDiagnosticMessage;
  if (byteMatch) {
    String replacement = Byte.toString(((Number) literal.getValue()).byteValue());

    // Correct for poor javac 6 literal parsing.
    int actualStart = ASTHelpers.getActualStartPosition(literal, state.getSourceCode());
    if (actualStart != literal.getStartPosition()) {
      fix.replace(literal, replacement, actualStart - literal.getStartPosition(), 0);
    } else {
      fix.replace(literal, replacement);
    }
    customDiagnosticMessage = getDiagnosticMessage("byte", (int) Byte.MIN_VALUE,
        (int) Byte.MAX_VALUE, literal.toString(), Boolean.toString(willEvaluateTo));
  } else {
    fix.replace(tree, Boolean.toString(willEvaluateTo));
    customDiagnosticMessage = getDiagnosticMessage("char", (int) Character.MIN_VALUE,
        (int) Character.MAX_VALUE, literal.toString(), Boolean.toString(willEvaluateTo));
  }
  return new Description(tree, pattern, customDiagnosticMessage, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchLiteral(LiteralTree literalTree, VisitorState state) {
  if (!matcher.matches(literalTree, state)) {
    return Description.NO_MATCH;
  }
  StringBuilder longLiteral = new StringBuilder(getLongLiteral(literalTree, state));
  longLiteral.setCharAt(longLiteral.length() - 1, 'L');
  Fix fix = SuggestedFix.replace(literalTree, longLiteral.toString());
  return describeMatch(literalTree, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Description matchTypeCast(TypeCastTree tree, VisitorState state) {
  // Check for a narrowing match first as its simplest match to test.
  if (!matches(tree, state)) {
    return Description.NO_MATCH;
  }

  // Test that the match is in a Comparable.compareTo or Comparator.compare method.
  ClassTree declaringClass = ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class);
  if (!COMPARABLE_CLASS_MATCHER.matches(declaringClass, state)
      && !COMPARATOR_CLASS_MATCHER.matches(declaringClass, state)) {
    return Description.NO_MATCH;
  }
  MethodTree method = ASTHelpers.findEnclosingNode(state.getPath(), MethodTree.class);
  if (method == null) {
    return Description.NO_MATCH;
  }
  if (!COMPARABLE_METHOD_MATCHER.matches(method, state)
      && !COMPARATOR_METHOD_MATCHER.matches(method, state)) {
    return Description.NO_MATCH;
  }

  // Get the unparenthesized expression.
  BinaryTree subtract = (BinaryTree) ASTHelpers.stripParentheses(tree.getExpression());
  ExpressionTree lhs = subtract.getLeftOperand();
  ExpressionTree rhs = subtract.getRightOperand();
  Fix fix;
  if (ASTHelpers.getType(lhs).isPrimitive()) {
    fix = SuggestedFix.replace(tree, "Long.compare(" + lhs + ", " + rhs + ")");
  } else {
    fix = SuggestedFix.replace(tree, lhs + ".compareTo(" + rhs + ")");
  }
  return describeMatch(tree, 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包/类
@Nullable
protected static Fix fieldFix(Tree toReplace, VisitorState state) {
  TreePath path = state.getPath();
  while (path != null
      && path.getLeaf().getKind() != Kind.CLASS
      && path.getLeaf().getKind() != Kind.BLOCK) {
    path = path.getParentPath();
  }
  if (path == null) {
    return null;
  }
  List<? extends JCTree> members;
  // Must be block or class
  if (path.getLeaf().getKind() == Kind.CLASS) {
    members = ((JCClassDecl) path.getLeaf()).getMembers();
  } else {
    members = ((JCBlock) path.getLeaf()).getStatements();
  }
  for (JCTree jcTree : members) {
    if (jcTree.getKind() == Kind.VARIABLE) {
      JCVariableDecl declaration = (JCVariableDecl) jcTree;
      TypeSymbol variableTypeSymbol =
          state.getTypes().erasure(ASTHelpers.getType(declaration)).tsym;

      if (ASTHelpers.getSymbol(toReplace).isMemberOf(variableTypeSymbol, state.getTypes())) {
        if (toReplace.getKind() == Kind.IDENTIFIER) {
          return SuggestedFix.prefixWith(toReplace, declaration.getName() + ".");
        } else {
          return SuggestedFix.replace(
              ((JCFieldAccess) toReplace).getExpression(), declaration.getName().toString());
        }
      }
    }
  }
  return null;
}
 

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包/类
/**
 * Creates a SuggestedFix that replaces the checkNotNull call with a checkArgument or checkState
 * call.
 */
private Fix createCheckArgumentOrStateCall(MethodInvocationTree methodInvocationTree,
    VisitorState state, ExpressionTree arg1) {
  SuggestedFix fix = new SuggestedFix();
  String replacementMethod = "checkState";
  if (hasMethodParameter(state.getPath(), arg1)) {
    replacementMethod = "checkArgument";
  }

  StringBuilder replacement = new StringBuilder();

  // Was the original call to Preconditions.checkNotNull a static import or not?
  if (methodInvocationTree.getMethodSelect().getKind() == Kind.IDENTIFIER) {
    replacement.append(replacementMethod + "(");
    fix.addStaticImport("com.google.common.base.Preconditions." + replacementMethod);
  } else {
    replacement.append("Preconditions." + replacementMethod + "(");
  }

  // Create argument list.
  for (ExpressionTree arg : methodInvocationTree.getArguments()) {
    replacement.append(arg.toString());
    replacement.append(", ");
  }
  replacement.delete(replacement.length() - 2, replacement.length());
  replacement.append(")");
  fix.replace(methodInvocationTree, replacement.toString());
  return fix;
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Fix replaceMethodName(MethodInvocationTree tree, VisitorState state, String newName) {
  String source = state.getSourceForNode((JCTree) tree.getMethodSelect());
  int idx = source.lastIndexOf("contains");
  String replacement =
      source.substring(0, idx) + newName + source.substring(idx + "contains".length());
  Fix fix = SuggestedFix.replace(tree.getMethodSelect(), replacement);
  return fix;
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/** Suggests removing getClass() or changing to Class.class. */
@Override
public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
  if (getClassMethodMatcher.matches(tree, state)) {
    String methodInvoker = ASTHelpers.getReceiver(tree).toString();
    Fix removeGetClass = SuggestedFix.replace(tree, methodInvoker);
    Fix changeToClassDotClass = SuggestedFix.replace(tree, "Class.class");
    return buildDescription(tree).addFix(removeGetClass).addFix(changeToClassDotClass).build();
  }
  return Description.NO_MATCH;
}