Java SuggestedFix.Builder方法代码示例

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private static Optional<Fix> linkedListFix(Tree tree, VisitorState state) {
  Type type = getTargetType(state);
  if (type == null) {
    return Optional.empty();
  }
  Types types = state.getTypes();
  for (String replacement : ImmutableList.of("java.util.ArrayList", "java.util.ArrayDeque")) {
    Symbol sym = state.getSymbolFromString(replacement);
    if (sym == null) {
      continue;
    }
    if (types.isAssignable(types.erasure(sym.asType()), types.erasure(type))) {
      SuggestedFix.Builder fix = SuggestedFix.builder();
      while (tree instanceof ParameterizedTypeTree) {
        tree = ((ParameterizedTypeTree) tree).getType();
      }
      fix.replace(tree, SuggestedFixes.qualifyType(state, fix, sym));
      return Optional.of(fix.build());
    }
  }
  return Optional.empty();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/** Handles the case "expr1 == expr2" */
private static void suggestFixForSameReference(
    SuggestedFix.Builder fix, AssertTree foundAssert, VisitorState state, boolean isEqual) {

  BinaryTree equalityTree = (BinaryTree) TreeInfo.skipParens((JCTree) foundAssert.getCondition());
  ExpressionTree expr1 = equalityTree.getLeftOperand();
  ExpressionTree expr2 = equalityTree.getRightOperand();

  if (expr1.getKind() == NULL_LITERAL) {
    // case: "assert null [op] expr"
    addFix(fix, (JCExpression) expr2, foundAssert, state, isEqual ? IS_NULL : IS_NOT_NULL);
  } else if (expr2.getKind() == NULL_LITERAL) {
    // case: "assert expr [op] null"
    addFix(fix, (JCExpression) expr1, foundAssert, state, isEqual ? IS_NULL : IS_NOT_NULL);
  } else {
    // case: "assert expr1 [op] expr2"
    addFix(
        fix,
        (JCExpression) expr1,
        foundAssert,
        state,
        String.format(isEqual ? IS_SAME_AS : IS_NOT_SAME_AS, expr2));
  }
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Optional<Fix> rethrowFix(ImmutableList<CatchTree> catchBlocks, VisitorState state) {
  SuggestedFix.Builder fix = SuggestedFix.builder();
  catchBlocks.forEach(
      c -> {
        // e.g.
        // fail("message") -> throw new AssertionError("message", cause);
        // assertWithMessage("message format %s", 42) ->
        //     throw new AssertionError(String.format("message format %s", 42), cause);
        StatementTree statementTree = getOnlyElement(c.getBlock().getStatements());
        MethodInvocationTree methodInvocationTree =
            (MethodInvocationTree) ((ExpressionStatementTree) statementTree).getExpression();
        String message = null;
        if (message == null && !methodInvocationTree.getArguments().isEmpty()) {
          message = getMessageOrFormat(methodInvocationTree, state);
        }
        if (message != null) {
          // only catch and rethrow to add additional context, not for raw `fail()` calls
          fix.replace(
              statementTree,
              String.format(
                  "throw new AssertionError(%s, %s);", message, c.getParameter().getName()));
        }
      });
  return fix.isEmpty() ? Optional.empty() : Optional.of(fix.build());
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Fix appendCharset(
    Tree tree,
    Tree select,
    List<? extends ExpressionTree> arguments,
    VisitorState state,
    CharsetFix charset) {
  SuggestedFix.Builder fix = SuggestedFix.builder();
  if (arguments.isEmpty()) {
    fix.replace(
        state.getEndPosition(select),
        state.getEndPosition(tree),
        String.format("(%s)", charset.replacement()));
  } else {
    fix.postfixWith(Iterables.getLast(arguments), ", " + charset.replacement());
  }
  charset.addImport(fix, state);
  return fix.build();
}
 

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.Builder fix = SuggestedFix.builder();
  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) {
    fix.addStaticImport("com.google.common.base.Preconditions." + replacementMethod);
  } else {
    replacement.append("Preconditions.");
  }
  replacement.append(replacementMethod).append('(');

  Joiner.on(", ").appendTo(replacement, methodInvocationTree.getArguments());

  replacement.append(")");
  fix.replace(methodInvocationTree, replacement.toString());
  return fix.build();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Fix replace(BlockTemplateMatch match) {
  checkNotNull(match);
  SuggestedFix.Builder fix = SuggestedFix.builder();
  Inliner inliner = match.createInliner();
  Context context = inliner.getContext();
  List<JCStatement> targetStatements = match.getStatements();
  try {
    int nTemplates = templateStatements().size();
    int nTargets = targetStatements.size();
    if (nTemplates <= nTargets) {
      for (int i = 0; i < nTemplates; i++) {
        fix.replace(
            targetStatements.get(i), 
            printStatement(context, templateStatements().get(i).inline(inliner)));
      }
      for (int i = templateStatements().size(); i < nTargets; i++) {
        fix.delete(targetStatements.get(i));
      }
    } else {
      for (int i = 0; i < nTargets - 1; i++) {
        fix.replace(
            targetStatements.get(i),
            printStatement(context, templateStatements().get(i).inline(inliner)));
      }
      int last = nTargets - 1;
      ImmutableList<UStatement> remainingTemplate = 
          templateStatements().subList(last, templateStatements().size());
      fix.replace(targetStatements.get(last), 
          printStatements(context, inliner.inlineList(remainingTemplate)));
    }
  } catch (CouldNotResolveImportException e) {
    logger.log(SEVERE, "Failure to resolve import in replacement", e);
  }
  return addImports(inliner, fix);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
protected static Fix addImports(Inliner inliner, SuggestedFix.Builder fix) {
  for (String importToAdd : inliner.getImportsToAdd()) {
    fix.addImport(importToAdd);
  }
  for (String staticImportToAdd : inliner.getStaticImportsToAdd()) {
    fix.addStaticImport(staticImportToAdd);
  }
  return fix.build();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Searches the annotation list for {@code @Test(expected=...)}. If found, deletes the exception
 * attribute from the annotation, and returns its value.
 */
private static JCExpression deleteExpectedException(
    SuggestedFix.Builder fix, List<JCAnnotation> annotations, VisitorState state) {
  Type testAnnotation = state.getTypeFromString(JUnitMatchers.JUNIT4_TEST_ANNOTATION);
  for (JCAnnotation annotationTree : annotations) {
    if (!ASTHelpers.isSameType(testAnnotation, annotationTree.type, state)) {
      continue;
    }
    com.sun.tools.javac.util.List<JCExpression> arguments = annotationTree.getArguments();
    for (JCExpression arg : arguments) {
      if (!arg.hasTag(Tag.ASSIGN)) {
        continue;
      }
      JCAssign assign = (JCAssign) arg;
      if (assign.lhs.hasTag(Tag.IDENT)
          && ((JCIdent) assign.lhs).getName().contentEquals("expected")) {
        if (arguments.size() == 1) {
          fix.replace(annotationTree, "@Test");
        } else {
          removeFromList(fix, state, arguments, assign);
        }
        return assign.rhs;
      }
    }
  }
  return null;
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/** Converts a {@code String} to a {@code File}. */
private Object toFile(VisitorState state, Tree fileArg, SuggestedFix.Builder fix) {
  Type type = ASTHelpers.getType(fileArg);
  if (ASTHelpers.isSubtype(type, state.getSymtab().stringType, state)) {
    fix.addImport("java.io.File");
    return String.format("new File(%s)", state.getSourceForNode(fileArg));
  } else if (ASTHelpers.isSubtype(type, state.getTypeFromString("java.io.File"), state)) {
    return state.getSourceForNode(fileArg);
  } else {
    throw new AssertionError("unexpected type: " + type);
  }
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private SuggestedFix buildFix() {
  ImmutableMap<Name, MethodTree> lastGroupedOccurrences = getLastGroupedOccurrences();

  SuggestedFix.Builder fix = SuggestedFix.builder();
  for (OverloadViolation violation : violations) {
    Name methodName = violation.getMethodName();
    violation.buildFix(fix, state, lastGroupedOccurrences.get(methodName));
  }
  return fix.build();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Description handlePrintWriterOutputStream(NewClassTree tree, VisitorState state) {
  Tree outputStream = tree.getArguments().get(0);
  Description.Builder description = buildDescription(tree);
  for (CharsetFix charsetFix : CharsetFix.values()) {
    SuggestedFix.Builder fix =
        SuggestedFix.builder()
            .prefixWith(outputStream, "new BufferedWriter(new OutputStreamWriter(")
            .postfixWith(outputStream, String.format(", %s))", charsetFix.replacement()));
    charsetFix.addImport(fix, state);
    fix.addImport("java.io.BufferedWriter");
    fix.addImport("java.io.OutputStreamWriter");
    description.addFix(fix.build());
  }
  return description.build();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private static void replaceAssert(
    SuggestedFix.Builder fix, AssertTree foundAssert, VisitorState state) {

  ExpressionTree expr = foundAssert.getCondition();
  expr = (ExpressionTree) TreeInfo.skipParens((JCTree) expr);

  // case: "assert !expr"
  if (expr.getKind().equals(LOGICAL_COMPLEMENT)) {
    addFix(fix, ((JCUnary) expr).getExpression(), foundAssert, state, IS_FALSE);
    return;
  }

  // case: "assert expr1.equals(expr2)"
  if (instanceMethod().onClass(Any.INSTANCE).named("equals").matches(expr, state)) {
    JCMethodInvocation equalsCall = ((JCMethodInvocation) expr);
    JCExpression expr1 = ((JCFieldAccess) ((JCMethodInvocation) expr).meth).selected;
    JCExpression expr2 = equalsCall.getArguments().get(0);

    addFix(
        fix,
        expr1,
        foundAssert,
        state,
        String.format(IS_EQUAL_TO, normalizedSourceForExpression(expr2, state)));
    return;
  }

  // case: "assert expr1 == expr2" or "assert expr1 != expr2"
  if (expr.getKind().equals(Kind.EQUAL_TO) || expr.getKind().equals(Kind.NOT_EQUAL_TO)) {
    suggestFixForSameReference(fix, foundAssert, state, expr.getKind().equals(Kind.EQUAL_TO));
    return;
  }

  // case: "assert expr", which didn't match any of the previous cases.
  addFix(fix, (JCExpression) expr, foundAssert, state, IS_TRUE);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
@Override
public Void visitBinary(BinaryTree tree, SuggestedFix.Builder p) {
  if (tree.getKind() == Kind.AND || tree.getKind() == Kind.OR) {
    p.replace(
        state.getEndPosition(tree.getLeftOperand()),
        ((JCTree) tree.getRightOperand()).getStartPosition(),
        tree.getKind() == Tree.Kind.AND ? " && " : " || ");
  }

  return super.visitBinary(tree, p);
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
private Fix nioFileReaderFix(VisitorState state, Tree arg, Tree toReplace, CharsetFix charset) {
  SuggestedFix.Builder fix = SuggestedFix.builder();
  fix.replace(
      toReplace,
      String.format(
          "Files.newBufferedReader(%s, %s)", toPath(state, arg, fix), charset.replacement()));
  fix.addImport("java.nio.file.Files");
  charset.addImport(fix, state);
  variableTypeFix(fix, state, FileReader.class, Reader.class);
  return fix.build();
}
 

import com.google.errorprone.fixes.SuggestedFix; //导入方法依赖的package包/类
/**
 * Returns a fix that changes a concrete class to an abstract class.
 *
 * <ul>
 *   <li>Removes {@code final} if it was there.
 *   <li>Adds {@code abstract} if it wasn't there.
 *   <li>Adds a private empty constructor if the class was {@code final} and had only a default
 *       constructor.
 * </ul>
 */
static SuggestedFix.Builder makeConcreteClassAbstract(ClassTree classTree, VisitorState state) {
  Set<Modifier> flags = EnumSet.noneOf(Modifier.class);
  flags.addAll(classTree.getModifiers().getFlags());
  boolean wasFinal = flags.remove(FINAL);
  boolean wasAbstract = !flags.add(ABSTRACT);

  if (classTree.getKind().equals(INTERFACE) || (!wasFinal && wasAbstract)) {
    return SuggestedFix.builder(); // no-op
  }

  ImmutableList.Builder<Object> modifiers = ImmutableList.builder();
  for (AnnotationTree annotation : classTree.getModifiers().getAnnotations()) {
    modifiers.add(state.getSourceForNode(annotation));
  }
  modifiers.addAll(flags);

  SuggestedFix.Builder makeAbstract = SuggestedFix.builder();
  if (((JCModifiers) classTree.getModifiers()).pos == -1) {
    makeAbstract.prefixWith(classTree, Joiner.on(' ').join(modifiers.build()));
  } else {
    makeAbstract.replace(classTree.getModifiers(), Joiner.on(' ').join(modifiers.build()));
  }
  if (wasFinal && HAS_GENERATED_CONSTRUCTOR.matches(classTree, state)) {
    makeAbstract.merge(addPrivateConstructor(classTree));
  }
  return makeAbstract;
}