Add Functional and self-calls options to MemberReferenceToMethodInvocation (#771)

* Add Functional and self-calls options to `MemberReferenceToMethodInvocation`.

* Update src/test/java/org/openrewrite/java/spring/util/MemberReferenceToMethodInvocationTest.java

Co-authored-by: Tim te Beek <[email protected]>

* Test both `this` and `super`

---------

Co-authored-by: Tim te Beek <[email protected]>

Author: Jenson3210

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

@@ -17,6 +17,7 @@
 
 import lombok.Value;
 import org.openrewrite.ExecutionContext;
+import org.openrewrite.internal.StringUtils;
 import org.openrewrite.java.JavaTemplate;
 import org.openrewrite.java.JavaVisitor;
 import org.openrewrite.java.VariableNameUtils;
@@ -37,11 +38,23 @@ public J visitMemberReference(J.MemberReference memberRef, ExecutionContext ctx)
         }
 
         List<Param> args = getLambdaArgNames(mr.getMethodType());
-        String templateCode = String.format("(%s) -> %s.%s(%s)",
-                args.stream().map(Param::toString).collect(joining(", ")),
-                mr.getContaining(),
-                mr.getReference().getSimpleName(),
-                args.stream().map(Param::getName).collect(joining(", ")));
+        String templateCode;
+        if (!mr.getMethodType().getParameterTypes().isEmpty()) {
+            templateCode = String.format("(%s) -> %s.%s(%s)",
+                    args.stream().map(Param::toString).collect(joining(", ")),
+                    mr.getContaining(),
+                    mr.getReference().getSimpleName(),
+                    args.stream().map(Param::getName).collect(joining(", ")));
+        } else if (mr.getContaining() instanceof J.Identifier && ("this".equals(((J.Identifier) mr.getContaining()).getSimpleName()) || "super".equals(((J.Identifier) mr.getContaining()).getSimpleName()))) {
+            templateCode = String.format("() -> %s.%s()",
+                    mr.getContaining(),
+                    mr.getReference().getSimpleName());
+        } else {
+            templateCode = String.format("(%s) -> %s.%s()",
+                    args.stream().map(Param::toString).collect(joining(", ")),
+                    args.get(0).getName(),
+                    mr.getReference().getSimpleName());
+        }
         return JavaTemplate.builder(templateCode)
                 .contextSensitive()
                 .build().apply(getCursor(), mr.getCoordinates().replace())
@@ -61,6 +74,12 @@ private List<Param> getLambdaArgNames(JavaType.Method methodType) {
 
             params.add(new Param(type, uniqueVariableName));
         }
+        if (params.isEmpty()) {
+            JavaType.FullyQualified type = methodType.getDeclaringType();
+            String uniqueVariableName = VariableNameUtils.generateVariableName(StringUtils.uncapitalize(type.getClassName()), getCursor(), VariableNameUtils.GenerationStrategy.INCREMENT_NUMBER);
+
+            params.add(new Param(type, uniqueVariableName));
+        }
         return params;
     }
 

src/test/java/org/openrewrite/java/spring/util/MemberReferenceToMethodInvocationTest.java

@@ -16,6 +16,8 @@
 package org.openrewrite.java.spring.util;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.openrewrite.DocumentExample;
 import org.openrewrite.InMemoryExecutionContext;
 import org.openrewrite.java.JavaParser;
@@ -62,4 +64,61 @@ void test(ListenableFuture<String> future) {
           )
         );
     }
+
+    @Test
+    void methodReferenceWithoutArguments() {
+        //language=java
+        rewriteRun(
+          java(
+            """
+              import java.util.Optional;
+
+              class A {
+                  void test() {
+                      byte[] result = Optional.of("Test").map(String::getBytes).orElse(null);
+                  }
+              }
+              """,
+            """
+              import java.util.Optional;
+
+              class A {
+                  void test() {
+                      byte[] result = Optional.of("Test").map((String string) -> string.getBytes()).orElse(null);
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"this", "super"})
+    void superMethodReferenceWithoutArguments(String qualifier) {
+        //language=java
+        rewriteRun(
+          java(
+            """
+              import java.util.Optional;
+              import java.util.function.Supplier;
+
+              class A {
+                  public Supplier<String> getString() {
+                      return %s::toString;
+                  }
+              }
+              """.formatted(qualifier),
+            """
+              import java.util.Optional;
+              import java.util.function.Supplier;
+
+              class A {
+                  public Supplier<String> getString() {
+                      return () -> %s.toString();
+                  }
+              }
+              """.formatted(qualifier)
+          )
+        );
+    }
 }