Add Type information to the generated Lambda of MemberReferenceToMethodInvocation (#774)

Author: Jenson3210

build.gradle.kts

@@ -59,6 +59,7 @@ recipeDependencies {
     parserClasspath("org.springframework.boot:spring-boot:3.+")
 
     parserClasspath("org.springframework.boot:spring-boot-autoconfigure:2.+")
+    parserClasspath("org.springframework.boot:spring-boot-autoconfigure:3.+")
     parserClasspath("org.springframework.boot:spring-boot-actuator:2.+")
     parserClasspath("org.springframework.boot:spring-boot-actuator:2.5.+")
     parserClasspath("org.springframework.boot:spring-boot-test:2.+")

src/main/java/org/openrewrite/java/spring/util/MemberReferenceToMethodInvocation.java

@@ -15,9 +15,12 @@
  */
 package org.openrewrite.java.spring.util;
 
+import lombok.RequiredArgsConstructor;
 import lombok.Value;
 import org.openrewrite.ExecutionContext;
+import org.openrewrite.internal.ListUtils;
 import org.openrewrite.internal.StringUtils;
+import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.JavaTemplate;
 import org.openrewrite.java.JavaVisitor;
 import org.openrewrite.java.VariableNameUtils;
@@ -26,6 +29,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 import static java.util.stream.Collectors.joining;
 
@@ -50,14 +54,16 @@ public J visitMemberReference(J.MemberReference memberRef, ExecutionContext ctx)
                     mr.getContaining(),
                     mr.getReference().getSimpleName());
         } else {
-            templateCode = String.format("(%s) -> %s.%s()",
-                    args.stream().map(Param::toString).collect(joining(", ")),
+            templateCode = String.format("%1$s -> %1$s.%2$s()",
                     args.get(0).getName(),
                     mr.getReference().getSimpleName());
         }
-        return JavaTemplate.builder(templateCode)
+        J.Lambda lambda = JavaTemplate.builder(templateCode)
                 .contextSensitive()
-                .build().apply(getCursor(), mr.getCoordinates().replace())
+                .build()
+                .apply(getCursor(), mr.getCoordinates().replace());
+
+        return new AddLambdaTypeInformation(mr, args).visitNonNull(lambda, ctx)
                 .withPrefix(mr.getPrefix());
     }
 
@@ -76,13 +82,41 @@ private List<Param> getLambdaArgNames(JavaType.Method methodType) {
         }
         if (params.isEmpty()) {
             JavaType.FullyQualified type = methodType.getDeclaringType();
-            String uniqueVariableName = VariableNameUtils.generateVariableName(StringUtils.uncapitalize(type.getClassName()), getCursor(), VariableNameUtils.GenerationStrategy.INCREMENT_NUMBER);
+            String uniqueVariableName = VariableNameUtils.generateVariableName(StringUtils.uncapitalize(keepFromLastCapitalLetter(type.getClassName())), getCursor(), VariableNameUtils.GenerationStrategy.INCREMENT_NUMBER);
 
             params.add(new Param(type, uniqueVariableName));
         }
         return params;
     }
 
+    @RequiredArgsConstructor
+    private static class AddLambdaTypeInformation extends JavaIsoVisitor<ExecutionContext> {
+
+        private final J.MemberReference mr;
+        private final List<Param> args;
+
+        @Override
+        public J.Identifier visitIdentifier(J.Identifier ident, ExecutionContext ctx) {
+            Optional<Param> arg = args.stream().filter(a -> a.getName().equals(ident.getSimpleName())).findFirst();
+            if (arg.isPresent()) {
+                JavaType type = arg.get().getType();
+                return ident.withType(type).withFieldType(ident.getFieldType() == null ? null : ident.getFieldType().withType(type));
+            }
+            return super.visitIdentifier(ident, ctx);
+        }
+
+        @Override
+        public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations mv, ExecutionContext ctx) {
+            return mv.withVariables(ListUtils.map(mv.getVariables(), (index, variable) -> variable.withType(args.get(index).getType())));
+        }
+
+        @Override
+        public J.MethodInvocation visitMethodInvocation(J.MethodInvocation mi, ExecutionContext ctx) {
+            return mi.withMethodType(mr.getMethodType());
+        }
+
+    }
+
     @Value
     class Param {
         JavaType type;
@@ -93,4 +127,13 @@ public String toString() {
             return String.format("%s %s", type.toString().replaceFirst("^java.lang.", ""), name);
         }
     }
+
+    private static String keepFromLastCapitalLetter(String input) {
+        for (int i = input.length() - 1; i >= 0; i--) {
+            if (Character.isUpperCase(input.charAt(i))) {
+                return input.substring(i);
+            }
+        }
+        return input;
+    }
 }

src/main/resources/META-INF/rewrite/classpath.tsv.zip

@@ -32,7 +32,7 @@ class MemberReferenceToMethodInvocationTest implements RewriteTest {
     @Override
     public void defaults(RecipeSpec spec) {
         spec.recipe(toRecipe(MemberReferenceToMethodInvocation::new))
-          .parser(JavaParser.fromJavaVersion().classpathFromResources(new InMemoryExecutionContext(), "spring-core-6"));
+          .parser(JavaParser.fromJavaVersion().classpathFromResources(new InMemoryExecutionContext(), "spring-core-6", "spring-boot-autoconfigure-3.+"));
     }
 
     @DocumentExample
@@ -84,7 +84,7 @@ void test() {
 
               class A {
                   void test() {
-                      byte[] result = Optional.of("Test").map((String string) -> string.getBytes()).orElse(null);
+                      byte[] result = Optional.of("Test").map(string -> string.getBytes()).orElse(null);
                   }
               }
               """
@@ -121,4 +121,39 @@ public Supplier<String> getString() {
           )
         );
     }
+
+    @Test
+    void typesArePresent() {
+        //language=java
+        rewriteRun(
+          java(
+            """
+              import org.springframework.boot.autoconfigure.kafka.KafkaConnectionDetails;
+              import java.util.List;
+              import java.util.Optional;
+
+              public class KafkaConfig {
+                  public List<String> getProducerServers(KafkaConnectionDetails connectionDetails) {
+                      return Optional.ofNullable(connectionDetails)
+                          .map(KafkaConnectionDetails::getProducerBootstrapServers)
+                          .orElse(null);
+                  }
+              }
+              """,
+            """
+              import org.springframework.boot.autoconfigure.kafka.KafkaConnectionDetails;
+              import java.util.List;
+              import java.util.Optional;
+
+              public class KafkaConfig {
+                  public List<String> getProducerServers(KafkaConnectionDetails connectionDetails) {
+                      return Optional.ofNullable(connectionDetails)
+                          .map(details -> details.getProducerBootstrapServers())
+                          .orElse(null);
+                  }
+              }
+              """
+          )
+        );
+    }
 }