Update MethodCanBeStatic to be able to detect and trigger on Guice @provides methods.

PiperOrigin-RevId: 802239934

Author: java-team-github-bot

check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java

@@ -156,6 +156,7 @@
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.type.TypeKind;
@@ -1018,29 +1019,46 @@ public static boolean hasDirectAnnotationWithSimpleName(Symbol sym, String simpl
     if (sym instanceof VarSymbol varSymbol) {
       return hasDirectAnnotationWithSimpleName(varSymbol, simpleName);
     }
-    return hasDirectAnnotationWithSimpleName(sym.getAnnotationMirrors().stream(), simpleName);
+    return hasDirectAnnotation(
+        sym.getAnnotationMirrors().stream(),
+        element -> element.getSimpleName().contentEquals(simpleName));
   }
 
   public static boolean hasDirectAnnotationWithSimpleName(MethodSymbol sym, String simpleName) {
-    return hasDirectAnnotationWithSimpleName(
+    return hasDirectAnnotation(
         Streams.concat(
             sym.getAnnotationMirrors().stream(),
             sym.getReturnType().getAnnotationMirrors().stream()),
-        simpleName);
+        element -> element.getSimpleName().contentEquals(simpleName));
   }
 
   public static boolean hasDirectAnnotationWithSimpleName(VarSymbol sym, String simpleName) {
-    return hasDirectAnnotationWithSimpleName(
+    return hasDirectAnnotation(
         Streams.concat(
             sym.getAnnotationMirrors().stream(), sym.asType().getAnnotationMirrors().stream()),
-        simpleName);
+        element -> element.getSimpleName().contentEquals(simpleName));
   }
 
-  private static boolean hasDirectAnnotationWithSimpleName(
-      Stream<? extends AnnotationMirror> annotations, String simpleName) {
+  /**
+   * Check for the presence of an annotation with the given qualified name directly on this symbol
+   * or its type. (If the given symbol is a method symbol, the type searched for annotations is its
+   * return type.)
+   *
+   * <p>This method looks only a annotations that are directly present. It does <b>not</b> consider
+   * annotation inheritance (see JLS 9.6.4.3).
+   */
+  public static boolean hasDirectAnnotation(MethodSymbol sym, String qualifiedName) {
+    return hasDirectAnnotation(
+        Streams.concat(
+            sym.getAnnotationMirrors().stream(),
+            sym.getReturnType().getAnnotationMirrors().stream()),
+        element -> ((Symbol) element).getQualifiedName().contentEquals(qualifiedName));
+  }
+
+  private static boolean hasDirectAnnotation(
+      Stream<? extends AnnotationMirror> annotations, Predicate<Element> matcher) {
     return annotations.anyMatch(
-        annotation ->
-            annotation.getAnnotationType().asElement().getSimpleName().contentEquals(simpleName));
+        annotation -> matcher.test(annotation.getAnnotationType().asElement()));
   }
 
   /**

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

@@ -68,6 +68,10 @@
     severity = SUGGESTION,
     documentSuppression = false)
 public class MethodCanBeStatic extends BugChecker implements CompilationUnitTreeMatcher {
+
+  private static final ImmutableSet<String> GUICE_PROVIDES_ANNOTATION_NAMES =
+      ImmutableSet.of("com.google.inject.Provides");
+
   private final FindingOutputStyle findingOutputStyle;
 
   private final WellKnownKeep wellKnownKeep;
@@ -249,9 +253,17 @@ private boolean isExcluded(MethodTree tree, VisitorState state) {
     if (sym.isConstructor() || !disjoint(EXCLUDED_MODIFIERS, sym.getModifiers())) {
       return true;
     }
-    if (!ASTHelpers.canBeRemoved(sym, state) || wellKnownKeep.shouldKeep(tree)) {
-      return true;
+
+    boolean isGuiceProvidesMethod =
+        GUICE_PROVIDES_ANNOTATION_NAMES.stream()
+            .anyMatch(annotationName -> ASTHelpers.hasDirectAnnotation(sym, annotationName));
+
+    if (!isGuiceProvidesMethod) {
+      if (!ASTHelpers.canBeRemoved(sym, state) || wellKnownKeep.shouldKeep(tree)) {
+        return true;
+      }
     }
+
     switch (enclosingClass(sym).getNestingKind()) {
       case TOP_LEVEL -> {}
       case MEMBER -> {

core/src/test/java/com/google/errorprone/bugpatterns/MethodCanBeStaticTest.java

@@ -731,4 +731,62 @@ public int get() {
             """)
         .doTest();
   }
+
+  @Test
+  public void guiceProvidesMethod_madeStatic() {
+    refactoringHelper
+        .addInputLines(
+            "Test.java",
+            """
+            import com.google.inject.AbstractModule;
+            import com.google.inject.Provides;
+
+            class MadeStatic extends AbstractModule {
+              @Provides
+              Boolean provideBoolean() {
+                return false;
+              }
+            }
+            """)
+        .addOutputLines(
+            "Test.java",
+            """
+            import com.google.inject.AbstractModule;
+            import com.google.inject.Provides;
+
+            class MadeStatic extends AbstractModule {
+              @Provides
+              static Boolean provideBoolean() {
+                return false;
+              }
+            }
+            """)
+        .doTest();
+  }
+
+  @Test
+  public void guiceProvidesMethod_withInstanceState_cannotBeMadeStatic() {
+    testHelper
+        .addSourceLines(
+            "Test.java",
+            """
+            import com.google.inject.AbstractModule;
+            import com.google.inject.Provides;
+
+            class Test extends AbstractModule {
+
+              private final int value;
+
+              public Test(int value) {
+                this.value = value;
+              }
+
+              @Provides
+              int provideInteger() {
+                return value;
+              }
+            }
+            """)
+        .doTest();
+  }
 }