Java VisitorState.reportMatch方法代码示例

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
@Override
public Description matchNewClass(NewClassTree tree, VisitorState state) {
  // check instantiations of `@ImmutableTypeParameter`s in generic constructor invocations
  checkInvocation(
      tree, ((JCNewClass) tree).constructorType, state, ((JCNewClass) tree).constructor);
  // check instantiations of `@ImmutableTypeParameter`s in class constructor invocations
  ImmutableAnalysis analysis = new ImmutableAnalysis(this, state, wellKnownMutability);
  Violation info =
      analysis.checkInstantiation(
          ASTHelpers.getSymbol(tree.getIdentifier()).getTypeParameters(),
          ASTHelpers.getType(tree).getTypeArguments());
  if (info.isPresent()) {
    state.reportMatch(buildDescription(tree).setMessage(info.message()).build());
  }
  return NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
@Override
public Description matchSynchronized(SynchronizedTree tree, VisitorState state) {
  Symbol lock = ASTHelpers.getSymbol(stripParentheses(tree.getExpression()));
  if (!(lock instanceof VarSymbol)) {
    return Description.NO_MATCH;
  }
  if (lock.isStatic()) {
    return Description.NO_MATCH;
  }
  Multimap<VarSymbol, Tree> writes = WriteVisitor.scan(tree.getBlock());
  for (Entry<VarSymbol, Tree> write : writes.entries()) {
    if (!write.getKey().isStatic()) {
      continue;
    }
    state.reportMatch(
        buildDescription(write.getValue()).setMessage(String.format(MESSAGE, lock)).build());
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void reportAnyViolations(
    List<? extends ExpressionTree> arguments,
    List<RequiredType> requiredArgumentTypes,
    VisitorState state) {
  Types types = state.getTypes();
  for (int i = 0; i < requiredArgumentTypes.size(); i++) {
    RequiredType requiredType = requiredArgumentTypes.get(i);
    if (requiredType == null) {
      continue;
    }
    ExpressionTree argument = arguments.get(i);
    Type argType = ASTHelpers.getType(argument);
    if (requiredType.type() != null) {
      // Report a violation for this type
      EqualsIncompatibleType.TypeCompatibilityReport report =
          EqualsIncompatibleType.compatibilityOfTypes(requiredType.type(), argType, state);
      if (!report.compatible()) {
        state.reportMatch(describeViolation(argument, argType, requiredType.type(), types));
      }
    }
  }
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
protected <T extends Tree> void reportMatch(
    Description description, T match, VisitorState state) {
  if (description == null || description == Description.NO_MATCH) {
    return;
  }
  state.reportMatch(description);
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private Description checkDeclarations(List<? extends Tree> children, VisitorState state) {
  PeekingIterator<Tree> it = Iterators.<Tree>peekingIterator(children.iterator());
  while (it.hasNext()) {
    if (it.peek().getKind() != Tree.Kind.VARIABLE) {
      it.next();
      continue;
    }
    VariableTree variableTree = (VariableTree) it.next();
    ArrayList<VariableTree> fragments = new ArrayList<>();
    fragments.add(variableTree);
    // Javac handles multi-variable declarations by lowering them in the parser into a series of
    // individual declarations, all of which have the same start position. We search for the first
    // declaration in the group, which is either the first variable declared in this scope or has
    // a distinct end position from the previous declaration.
    while (it.hasNext()
        && it.peek().getKind() == Tree.Kind.VARIABLE
        && ((JCTree) variableTree).getStartPosition()
            == ((JCTree) it.peek()).getStartPosition()) {
      fragments.add((VariableTree) it.next());
    }
    if (fragments.size() == 1) {
      continue;
    }
    Fix fix =
        SuggestedFix.replace(
            ((JCTree) fragments.get(0)).getStartPosition(),
            state.getEndPosition(Iterables.getLast(fragments)),
            Joiner.on("; ").join(fragments) + ";");
    state.reportMatch(describeMatch(fragments.get(0), fix));
  }
  return NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void checkForHiddenFields(
    List<VariableTree> originalClassMembers,
    Map<Name, VarSymbol> parentMembers,
    Name parentClassName,
    ClassTree classTree,
    VisitorState visitorState) {
  Iterator<VariableTree> origVariableIterator = originalClassMembers.iterator();
  VariableTree origVariable = null;

  while (origVariableIterator.hasNext()) {
    origVariable = origVariableIterator.next();

    if (parentMembers.containsKey(origVariable.getName())) {
      if (isPackagePrivateAndInDiffPackage(
          parentMembers.get(origVariable.getName()), classTree)) {
        continue;
      }

      Builder matchDesc = buildDescription(origVariable);

      matchDesc.setMessage(
          "Hiding fields of superclasses may cause confusion and errors. "
              + "This field is hiding a field of the same name in superclass: "
              + parentClassName);

      visitorState.reportMatch(matchDesc.build());
      origVariableIterator.remove();
    }
  }
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void checkParameter(
    VarSymbol paramSym,
    ExpressionTree a,
    int start,
    Deque<ErrorProneToken> tokens,
    VisitorState state) {
  if (a.getKind() != Kind.BOOLEAN_LITERAL) {
    return;
  }
  String name = paramSym.getSimpleName().toString();
  if (name.length() < 2) {
    // single-character parameter names aren't helpful
    return;
  }
  if (BLACKLIST.contains(name)) {
    return;
  }
  while (!tokens.isEmpty()
      && ((start + tokens.peekFirst().pos()) < ((JCTree) a).getStartPosition())) {
    tokens.removeFirst();
  }
  if (tokens.isEmpty()) {
    return;
  }
  Range<Integer> argRange =
      Range.closedOpen(((JCTree) a).getStartPosition(), state.getEndPosition(a));
  if (!argRange.contains(start + tokens.peekFirst().pos())) {
    return;
  }
  if (hasParameterComment(tokens.removeFirst())) {
    return;
  }
  state.reportMatch(
      describeMatch(
          a, SuggestedFix.prefixWith(a, String.format("/* %s= */", paramSym.getSimpleName()))));
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private Description checkInvocation(
    Tree tree, Type methodType, VisitorState state, Symbol symbol) {
  ImmutableAnalysis analysis = new ImmutableAnalysis(this, state, wellKnownMutability);
  Violation info = analysis.checkInvocation(methodType, symbol);
  if (info.isPresent()) {
    state.reportMatch(buildDescription(tree).setMessage(info.message()).build());
  }
  return NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
@Override
public Description matchClass(ClassTree tree, VisitorState state) {
  ClassSymbol symbol = getSymbol(tree);
  if (symbol == null || !symbol.isEnum()) {
    return NO_MATCH;
  }

  if (ASTHelpers.hasAnnotation(symbol, Immutable.class, state)
      && !implementsImmutableInterface(symbol)) {
    AnnotationTree annotation =
        ASTHelpers.getAnnotationWithSimpleName(tree.getModifiers().getAnnotations(), "Immutable");
    if (annotation != null) {
      state.reportMatch(
          buildDescription(annotation)
              .setMessage(ANNOTATED_ENUM_MESSAGE)
              .addFix(SuggestedFix.delete(annotation))
              .build());
    } else {
      state.reportMatch(buildDescription(tree).setMessage(ANNOTATED_ENUM_MESSAGE).build());
    }
  }

  Violation info =
      new ImmutableAnalysis(
              this,
              state,
              wellKnownMutability,
              ImmutableSet.of(
                  Immutable.class.getName(),
                  javax.annotation.concurrent.Immutable.class.getName()))
          .checkForImmutability(
              Optional.of(tree), ImmutableSet.of(), getType(tree), this::describe);

  if (!info.isPresent()) {
    return NO_MATCH;
  }

  return describe(tree, info).build();
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void processGroupMethods(List<MethodTree> groupMethodTrees, VisitorState state) {
  Preconditions.checkArgument(!groupMethodTrees.isEmpty());
  for (ParameterOrderingViolation violation : getViolations(groupMethodTrees)) {
    MethodSymbol methodSymbol = getSymbol(violation.methodTree());
    if (ASTHelpers.findSuperMethods(methodSymbol, state.getTypes()).isEmpty()) {
      Description.Builder description = buildDescription(violation.methodTree());
      description.setMessage(violation.getDescription());
      state.reportMatch(description.build());
    }
  }
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void checkArgument(
    VarSymbol formal,
    ExpressionTree actual,
    int start,
    ErrorProneToken token,
    VisitorState state) {
  List<Comment> matches = new ArrayList<>();
  for (Comment comment : token.comments()) {
    if (comment.getStyle() != BLOCK) {
      continue;
    }
    Matcher m =
        NamedParameterComment.PARAMETER_COMMENT_PATTERN.matcher(
            Comments.getTextFromComment(comment));
    if (!m.matches()) {
      continue;
    }
    String name = m.group(1);
    if (formal.getSimpleName().contentEquals(name)) {
      // If there are multiple comments, bail if any one of them is an exact match.
      return;
    }
    matches.add(comment);
  }
  for (Comment match : matches) {
    state.reportMatch(
        buildDescription(actual)
            .setMessage(
                String.format(
                    "`%s` does not match formal parameter name `%s`",
                    match.getText(), formal.getSimpleName()))
            .addFix(
                SuggestedFix.replace(
                    start + match.getSourcePos(0),
                    start + match.getSourcePos(match.getText().length() - 1) + 1,
                    String.format("/* %s= */", formal.getSimpleName())))
            .build());
  }
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void checkForThis(
    ExpressionTree node, Name identifier, ClassSymbol thisClass, VisitorState state) {
  if (identifier.contentEquals("this") && thisClass.equals(ASTHelpers.getSymbol(node).owner)) {
    state.reportMatch(describeMatch(node));
  }
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void reportMatch(
    Tree diagnosticPosition, VisitorState state, Tree toReplace, String replaceWith) {
  state.reportMatch(describeMatch(diagnosticPosition, replace(toReplace, replaceWith)));
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
private void report(Description description, VisitorState state) {
  if (description == null || description == NO_MATCH) {
    return;
  }
  state.reportMatch(description);
}
 

import com.google.errorprone.VisitorState; //导入方法依赖的package包/类
@Override
public Description matchClass(ClassTree tree, VisitorState state) {
  ClassSymbol symbol = getSymbol(tree);
  if (symbol == null
      || symbol.isAnnotationType()
      || !WellKnownMutability.isAnnotation(state, symbol.type)) {
    return NO_MATCH;
  }
  if (!Collections.disjoint(getGeneratedBy(symbol, state), PROCESSOR_BLACKLIST)) {
    return NO_MATCH;
  }

  if (ASTHelpers.hasAnnotation(symbol, Immutable.class, state)) {
    AnnotationTree annotation =
        ASTHelpers.getAnnotationWithSimpleName(tree.getModifiers().getAnnotations(), "Immutable");
    if (annotation != null) {
      state.reportMatch(
          buildDescription(annotation)
              .setMessage(ANNOTATED_ANNOTATION_MESSAGE)
              .addFix(SuggestedFix.delete(annotation))
              .build());
    } else {
      state.reportMatch(buildDescription(tree).setMessage(ANNOTATED_ANNOTATION_MESSAGE).build());
    }
  }

  Violation info =
      new ImmutableAnalysis(
              this,
              state,
              wellKnownMutability,
              ImmutableSet.of(
                  Immutable.class.getName(),
                  javax.annotation.concurrent.Immutable.class.getName()))
          .checkForImmutability(
              Optional.of(tree), ImmutableSet.of(), getType(tree), this::describeClass);

  if (!info.isPresent()) {
    return NO_MATCH;
  }
  return describeClass(tree, info).build();
}