Reconcile BugChecker#isSuppressed with suppression handling in ErrorProneScanner

This makes the full, dizzying complexity of `ErrorProneScanner`'s suppression
handling available in `BugChecker#isSuppressed`, including handling of custom
suppression annotations and `-XepDisableWarningsInGeneratedCode`.

#3094

PiperOrigin-RevId: 441580794

Author: cushon

check_api/src/main/java/com/google/errorprone/VisitorState.java

@@ -262,6 +262,10 @@ public ErrorProneOptions errorProneOptions() {
     return sharedState.errorProneOptions;
   }
 
+  public Map<String, SeverityLevel> severityMap() {
+    return sharedState.severityMap;
+  }
+
   public void reportMatch(Description description) {
     checkNotNull(description, "Use Description.NO_MATCH to denote an absent finding.");
     if (description == Description.NO_MATCH) {

check_api/src/main/java/com/google/errorprone/bugpatterns/BugChecker.java

@@ -19,12 +19,15 @@
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.errorprone.util.ASTHelpers.getModifiers;
 import static com.google.errorprone.util.ASTHelpers.getStartPosition;
+import static com.google.errorprone.util.ASTHelpers.getSymbol;
 
 import com.google.common.collect.ImmutableRangeSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Range;
 import com.google.errorprone.BugCheckerInfo;
 import com.google.errorprone.BugPattern.SeverityLevel;
+import com.google.errorprone.ErrorProneOptions;
+import com.google.errorprone.SuppressionInfo;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.annotations.CheckReturnValue;
 import com.google.errorprone.fixes.Fix;
@@ -248,17 +251,17 @@ public boolean suppressedByAnyOf(Set<Name> annotations, VisitorState s) {
   }
 
   /**
-   * Returns true if the given tree is annotated with a {@code @SuppressWarnings} that disables this
-   * bug checker.
+   * @deprecated use {@link #isSuppressed(Tree, VisitorState)} instead
    */
+  @Deprecated
   public boolean isSuppressed(Tree tree) {
     return isSuppressed(ASTHelpers.getAnnotation(tree, SuppressWarnings.class));
   }
 
   /**
-   * Returns true if the given symbol is annotated with a {@code @SuppressWarnings} that disables
-   * this bug checker.
+   * @deprecated use {@link #isSuppressed(Symbol, VisitorState)} instead
    */
+  @Deprecated
   public boolean isSuppressed(Symbol symbol) {
     return isSuppressed(ASTHelpers.getAnnotation(symbol, SuppressWarnings.class));
   }
@@ -268,13 +271,45 @@ private boolean isSuppressed(SuppressWarnings suppression) {
         && !Collections.disjoint(Arrays.asList(suppression.value()), allNames());
   }
 
+  /**
+   * Returns true if the given tree is annotated with a {@code @SuppressWarnings} that disables this
+   * bug checker.
+   */
+  public boolean isSuppressed(Tree tree, VisitorState state) {
+    Symbol sym = getSymbol(tree);
+    return sym != null && isSuppressed(sym, state);
+  }
+
+  /**
+   * Returns true if the given symbol is annotated with a {@code @SuppressWarnings} or other
+   * annotation that disables this bug checker.
+   */
+  public boolean isSuppressed(Symbol sym, VisitorState state) {
+    ErrorProneOptions errorProneOptions = state.errorProneOptions();
+    boolean suppressedInGeneratedCode =
+        errorProneOptions.disableWarningsInGeneratedCode()
+            && state.severityMap().get(canonicalName()) != SeverityLevel.ERROR;
+    SuppressionInfo.SuppressedState suppressedState =
+        SuppressionInfo.EMPTY
+            .withExtendedSuppressions(sym, state, customSuppressionAnnotationNames.get(state))
+            .suppressedState(BugChecker.this, suppressedInGeneratedCode, state);
+    return suppressedState == SuppressionInfo.SuppressedState.SUPPRESSED;
+  }
+
+  private final Supplier<? extends Set<? extends Name>> customSuppressionAnnotationNames =
+      VisitorState.memoize(
+          state ->
+              customSuppressionAnnotations().stream()
+                  .map(a -> state.getName(a.getName()))
+                  .collect(toImmutableSet()));
+
   /** Computes a RangeSet of code regions which are suppressed by this bug checker. */
   public ImmutableRangeSet<Integer> suppressedRegions(VisitorState state) {
     ImmutableRangeSet.Builder<Integer> suppressedRegions = ImmutableRangeSet.builder();
     new TreeScanner<Void, Void>() {
       @Override
       public Void scan(Tree tree, Void unused) {
-        if (getModifiers(tree) != null && isSuppressed(tree)) {
+        if (getModifiers(tree) != null && isSuppressed(tree, state)) {
           suppressedRegions.add(Range.closed(getStartPosition(tree), state.getEndPosition(tree)));
         } else {
           super.scan(tree, null);
@@ -517,11 +552,34 @@ public int hashCode() {
 
   /** A {@link TreePathScanner} which skips trees which are suppressed for this check. */
   protected class SuppressibleTreePathScanner<A, B> extends TreePathScanner<A, B> {
+
+    // TODO(cushon): make this protected once it is required; currently it would shadow
+    // other variables named state and break checks that pass the deprecated constructor
+    private final VisitorState state;
+
+    public SuppressibleTreePathScanner(VisitorState state) {
+      this.state = state;
+    }
+
+    /**
+     * @deprecated use {@link #SuppressibleTreePathScanner(VisitorState)} instead
+     */
+    @Deprecated
+    public SuppressibleTreePathScanner() {
+      this(null);
+    }
+
     @Override
     public A scan(Tree tree, B b) {
       boolean isSuppressible =
           tree instanceof ClassTree || tree instanceof MethodTree || tree instanceof VariableTree;
-      return isSuppressible && isSuppressed(tree) ? null : super.scan(tree, b);
+      if (isSuppressible) {
+        boolean suppressed = state != null ? isSuppressed(tree, state) : isSuppressed(tree);
+        if (suppressed) {
+          return null;
+        }
+      }
+      return super.scan(tree, b);
     }
   }
 }

core/src/main/java/com/google/errorprone/bugpatterns/AlreadyChecked.java

@@ -80,6 +80,7 @@ private final class IfScanner extends SuppressibleTreePathScanner<Void, Void> {
     private final VisitorState state;
 
     private IfScanner(VisitorState state) {
+      super(state);
       this.state = state;
     }
 

core/src/main/java/com/google/errorprone/bugpatterns/AmbiguousMethodReference.java

@@ -67,7 +67,7 @@ public Description matchClass(ClassTree tree, VisitorState state) {
         continue;
       }
       MethodSymbol msym = getSymbol((MethodTree) member);
-      if (isSuppressed(msym)) {
+      if (isSuppressed(msym, state)) {
         continue;
       }
       List<MethodSymbol> clash = methods.remove(methodReferenceDescriptor(types, msym));

core/src/main/java/com/google/errorprone/bugpatterns/AutoValueImmutableFields.java

@@ -131,7 +131,7 @@ private static Matcher<MethodTree> returning(String type) {
   public Description matchClass(ClassTree tree, VisitorState state) {
     if (ASTHelpers.hasAnnotation(tree, "com.google.auto.value.AutoValue", state)) {
       for (Tree memberTree : tree.getMembers()) {
-        if (memberTree instanceof MethodTree && !isSuppressed(memberTree)) {
+        if (memberTree instanceof MethodTree && !isSuppressed(memberTree, state)) {
           MethodTree methodTree = (MethodTree) memberTree;
           if (ABSTRACT_MATCHER.matches(methodTree, state)) {
             for (Map.Entry<String, Matcher<MethodTree>> entry : REPLACEMENT_TO_MATCHERS.entries()) {

core/src/main/java/com/google/errorprone/bugpatterns/AutoValueSubclassLeaked.java

@@ -66,7 +66,7 @@ private void scanAndReportAutoValueReferences(
       CompilationUnitTree tree,
       ImmutableSet<Type> autoValueClassesFromThisFile,
       VisitorState state) {
-    new SuppressibleTreePathScanner<Void, Void>() {
+    new SuppressibleTreePathScanner<Void, Void>(state) {
 
       @Override
       public Void visitClass(ClassTree classTree, Void unused) {

core/src/main/java/com/google/errorprone/bugpatterns/BadImport.java

@@ -171,7 +171,7 @@ private Description buildDescription(
     CompilationUnitTree compilationUnit = state.getPath().getCompilationUnit();
     TreePath path = TreePath.getPath(compilationUnit, compilationUnit);
     IdentifierTree firstFound =
-        new SuppressibleTreePathScanner<IdentifierTree, Void>() {
+        new SuppressibleTreePathScanner<IdentifierTree, Void>(state) {
           @Override
           public IdentifierTree reduce(IdentifierTree r1, IdentifierTree r2) {
             return (r2 != null) ? r2 : r1;
@@ -180,7 +180,7 @@ public IdentifierTree reduce(IdentifierTree r1, IdentifierTree r2) {
           @Override
           public IdentifierTree visitIdentifier(IdentifierTree node, Void unused) {
             Symbol nodeSymbol = getSymbol(node);
-            if (symbols.contains(nodeSymbol) && !isSuppressed(node)) {
+            if (symbols.contains(nodeSymbol) && !isSuppressed(node, state)) {
               if (getCurrentPath().getParentPath().getLeaf().getKind() != Kind.CASE) {
                 builder.prefixWith(node, enclosingReplacement);
                 moveTypeAnnotations(node);

core/src/main/java/com/google/errorprone/bugpatterns/ClassName.java

@@ -52,7 +52,7 @@ public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState s
     for (Tree member : tree.getTypeDecls()) {
       if (member instanceof ClassTree) {
         ClassTree classMember = (ClassTree) member;
-        if (isSuppressed(classMember)) {
+        if (isSuppressed(classMember, state)) {
           // If any top-level classes have @SuppressWarnings("ClassName"), ignore
           // this compilation unit. We can't rely on the normal suppression
           // mechanism because the only enclosing element is the package declaration,

core/src/main/java/com/google/errorprone/bugpatterns/DefaultPackage.java

@@ -39,7 +39,7 @@ public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState s
     if (state.errorProneOptions().isTestOnlyTarget()) {
       return Description.NO_MATCH;
     }
-    if (tree.getTypeDecls().stream().anyMatch(s -> isSuppressed(s))) {
+    if (tree.getTypeDecls().stream().anyMatch(s -> isSuppressed(s, state))) {
       return Description.NO_MATCH;
     }
     if (tree.getTypeDecls().stream()

core/src/main/java/com/google/errorprone/bugpatterns/DoNotCallChecker.java

@@ -185,7 +185,7 @@ public Description matchMethod(MethodTree tree, VisitorState state) {
   public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState state) {
     ImmutableListMultimap<VarSymbol, Type> assignedTypes = getAssignedTypes(state);
 
-    new SuppressibleTreePathScanner<Void, Void>() {
+    new SuppressibleTreePathScanner<Void, Void>(state) {
       @Override
       public Void visitMethodInvocation(MethodInvocationTree tree, Void unused) {
         handleTree(tree, getSymbol(tree));