Fix a crash when finding the enclosing method (for a second time).

This made me realise the behaviour is flagrantly inconsistent between lambdas and anonymous classes though, so I fixed that.

PiperOrigin-RevId: 775165446

Author: graememorgan

core/src/main/java/com/google/errorprone/bugpatterns/formatstring/AnnotateFormatMethod.java

@@ -18,16 +18,17 @@
 
 import static com.google.common.collect.Iterables.getLast;
 import static com.google.common.collect.MoreCollectors.toOptional;
+import static com.google.common.collect.Streams.stream;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.Description.NO_MATCH;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static com.google.errorprone.util.ASTHelpers.findEnclosingNode;
 import static com.google.errorprone.util.ASTHelpers.getReceiver;
 import static com.google.errorprone.util.ASTHelpers.getSymbol;
 import static com.google.errorprone.util.ASTHelpers.hasAnnotation;
 import static com.google.errorprone.util.AnnotationNames.FORMAT_METHOD_ANNOTATION;
+import static java.util.stream.Stream.empty;
 
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
@@ -42,6 +43,7 @@
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.VarSymbol;
 import java.util.List;
+import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 
 /** A BugPattern; see the summary. */
@@ -85,27 +87,38 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState
     if (formatString == null || formatArgs == null) {
       return NO_MATCH;
     }
-    MethodTree enclosingMethod = findEnclosingNode(state.getPath(), MethodTree.class);
-    if (enclosingMethod == null
-        || !getSymbol(enclosingMethod).isVarArgs()
-        || hasAnnotation(enclosingMethod, FORMAT_METHOD_ANNOTATION, state)) {
-      return NO_MATCH;
-    }
-    List<? extends VariableTree> enclosingParameters = enclosingMethod.getParameters();
-    VariableTree formatParameter = findParameterWithSymbol(enclosingParameters, formatString);
-    VariableTree argumentsParameter = findParameterWithSymbol(enclosingParameters, formatArgs);
-    if (formatParameter == null || argumentsParameter == null) {
-      return NO_MATCH;
-    }
-    if (!argumentsParameter.equals(getLast(enclosingParameters))) {
-      return NO_MATCH;
-    }
-    // We can only generate a fix if the format string is the penultimate parameter.
-    boolean fixable =
-        formatParameter.equals(enclosingParameters.get(enclosingParameters.size() - 2));
-    return buildDescription(enclosingMethod)
-        .setMessage(fixable ? message() : (message() + REORDER))
-        .build();
+
+    return stream(state.getPath())
+        .flatMap(
+            node -> {
+              if (!(node instanceof MethodTree methodTree)) {
+                return empty();
+              }
+              if (!getSymbol(methodTree).isVarArgs()
+                  || hasAnnotation(methodTree, FORMAT_METHOD_ANNOTATION, state)) {
+                return empty();
+              }
+              List<? extends VariableTree> enclosingParameters = methodTree.getParameters();
+              VariableTree formatParameter =
+                  findParameterWithSymbol(enclosingParameters, formatString);
+              VariableTree argumentsParameter =
+                  findParameterWithSymbol(enclosingParameters, formatArgs);
+              if (formatParameter == null || argumentsParameter == null) {
+                return empty();
+              }
+              if (!argumentsParameter.equals(getLast(enclosingParameters))) {
+                return empty();
+              }
+              // We can only generate a fix if the format string is the penultimate parameter.
+              boolean fixable =
+                  formatParameter.equals(enclosingParameters.get(enclosingParameters.size() - 2));
+              return Stream.of(
+                  buildDescription(methodTree)
+                      .setMessage(fixable ? message() : (message() + REORDER))
+                      .build());
+            })
+        .findFirst()
+        .orElse(NO_MATCH);
   }
 
   private static VariableTree findParameterWithSymbol(

core/src/test/java/com/google/errorprone/bugpatterns/formatstring/AnnotateFormatMethodTest.java

@@ -42,6 +42,43 @@ String formatMe(String formatString, Object... args) {
         .doTest();
   }
 
+  @Test
+  public void passedThroughToLambda() {
+    compilationHelper
+        .addSourceLines(
+            "AnnotateFormatMethodPositiveCases.java",
+            """
+            class AnnotateFormatMethodPositiveCases {
+              // BUG: Diagnostic contains: FormatMethod
+              Runnable formatMe(String formatString, Object... args) {
+                return () -> String.format(formatString, args);
+              }
+            }
+            """)
+        .doTest();
+  }
+
+  @Test
+  public void passedThroughToAnonymousClass() {
+    compilationHelper
+        .addSourceLines(
+            "AnnotateFormatMethodPositiveCases.java",
+            """
+            class AnnotateFormatMethodPositiveCases {
+              // BUG: Diagnostic contains: FormatMethod
+              Runnable formatMe(String formatString, Object... args) {
+                return new Runnable() {
+                  @Override
+                  public void run() {
+                    String.format(formatString, args);
+                  }
+                };
+              }
+            }
+            """)
+        .doTest();
+  }
+
   @Test
   public void formatted() {
     compilationHelper