Fix ReplaceLambdaWithMethodReference for local records and classes (#336) (#777)

The recipe was generating malformed method references like `1R::s` instead
of `R::s` when converting lambdas that reference locally-defined records or
classes. This occurred because local classes in Java bytecode are named with
patterns like `OuterClass$1LocalName`, where the digit indicates the method
scope.

The fix modifies `JavaElementFactory.className()` to detect local classes
(by checking for `$<digit>` patterns) and extract just the simple class name
without the numeric prefix.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: timtebeek

src/main/java/org/openrewrite/staticanalysis/JavaElementFactory.java

@@ -80,6 +80,20 @@ static Expression className(JavaType type, boolean qualified) {
             qualifiedName = type.toString();
         }
 
+        // Check if this is a local class (contains $<digit>)
+        // Local classes have names like "Outer$1LocalName" where the digit indicates the scope
+        // For method references, we should use only the simple name without the numeric prefix
+        if (qualifiedName.matches(".*\\$\\d+.*")) {
+            // Extract the simple name after the last $<digit> sequence
+            String simpleName = qualifiedName.replaceAll(".*\\$\\d+", "");
+            // Remove any remaining $ characters and get just the class name
+            simpleName = simpleName.replace('$', '.');
+            if (simpleName.indexOf('.') > 0) {
+                simpleName = simpleName.substring(simpleName.lastIndexOf('.') + 1);
+            }
+            return new J.Identifier(randomId(), Space.EMPTY, Markers.EMPTY, emptyList(), simpleName, type, null);
+        }
+
         Scanner scanner = new Scanner(qualifiedName.replace('$', '.')).useDelimiter("\\.");
         for (int i = 0; scanner.hasNext(); i++) {
             String part = scanner.next();

src/test/java/org/openrewrite/staticanalysis/ReplaceLambdaWithMethodReferenceTest.java

@@ -1636,4 +1636,154 @@ void bar() {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/336")
+    @Test
+    void localRecordMethodReference() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.stream.Stream;
+
+              class Test {
+                  String method() {
+                      record R(String s) {}
+                      return Stream.of(new R("hello world"))
+                          .map(r -> r.s())
+                          .findFirst()
+                          .orElse(null);
+                  }
+              }
+              """,
+            """
+              import java.util.stream.Stream;
+
+              class Test {
+                  String method() {
+                      record R(String s) {}
+                      return Stream.of(new R("hello world"))
+                          .map(R::s)
+                          .findFirst()
+                          .orElse(null);
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/336")
+    @Test
+    void localClassMethodReference() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.stream.Stream;
+
+              class Test {
+                  String method() {
+                      class Local {
+                          String getValue() { return "test"; }
+                      }
+                      return Stream.of(new Local())
+                          .map(l -> l.getValue())
+                          .findFirst()
+                          .orElse(null);
+                  }
+              }
+              """,
+            """
+              import java.util.stream.Stream;
+
+              class Test {
+                  String method() {
+                      class Local {
+                          String getValue() { return "test"; }
+                      }
+                      return Stream.of(new Local())
+                          .map(Local::getValue)
+                          .findFirst()
+                          .orElse(null);
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/336")
+    @Test
+    void localRecordWithInstanceOfCheck() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  List<Object> method(List<Object> input) {
+                      record R(String s) {}
+                      return input.stream()
+                          .filter(o -> o instanceof R)
+                          .collect(Collectors.toList());
+                  }
+              }
+              """,
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  List<Object> method(List<Object> input) {
+                      record R(String s) {}
+                      return input.stream()
+                          .filter(R.class::isInstance)
+                          .collect(Collectors.toList());
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/336")
+    @Test
+    void localRecordWithCast() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  List<Object> method(List<Object> input) {
+                      record R(String s) {}
+                      return input.stream()
+                          .filter(R.class::isInstance)
+                          .map(o -> (R) o)
+                          .collect(Collectors.toList());
+                  }
+              }
+              """,
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  List<Object> method(List<Object> input) {
+                      record R(String s) {}
+                      return input.stream()
+                          .filter(R.class::isInstance)
+                          .map(R.class::cast)
+                          .collect(Collectors.toList());
+                  }
+              }
+              """
+          )
+        );
+    }
 }