LombokValueToRecord should rewrite method references too

src/main/java/org/openrewrite/java/migrate/lombok/LombokValueToRecord.java

@@ -254,6 +254,28 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                     );
         }
 
+        @Override
+        public J.MemberReference visitMemberReference(J.MemberReference memberReference, ExecutionContext ctx) {
+            // when "memberReference" is "a::getTest"
+            // memberReference.getMethodType() == null
+            JavaType.Method methodType = memberReference.getMethodType();
+            if(methodType == null) {
+                return memberReference;
+            }
+
+            JavaType.FullyQualified declaringType = methodType.getDeclaringType();
+            String methodName = methodType.getName();
+            String classFqn = declaringType.getFullyQualifiedName();
+            if(recordTypeToMembers.containsKey(classFqn) &&
+                    recordTypeToMembers.get(classFqn).contains(getterMethodNameToFluentMethodName(methodName)) &&
+                    methodName.startsWith(STANDARD_GETTER_PREFIX)) {
+                return memberReference.withMethodType(methodType.withName(getterMethodNameToFluentMethodName(methodName)));
+            }
+
+            return memberReference;
+        }
+
+
         private boolean isMethodInvocationOnRecordTypeClassMember(J.MethodInvocation methodInvocation) {
             Expression expression = methodInvocation.getSelect();
             if (!isClassExpression(expression)) {

src/test/java/org/openrewrite/java/migrate/lombok/LombokValueToRecordTest.java

@@ -24,6 +24,8 @@
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.TypeValidation;
 
+import java.util.function.Supplier;
+
 import static org.openrewrite.java.Assertions.*;
 
 class LombokValueToRecordTest implements RewriteTest {
@@ -277,6 +279,76 @@ public record A(
 
     }
 
+    public static class A  {
+        String test;
+
+        public String getTest() {
+            return test;
+        }
+    }
+    @Test
+    @Issue("https://github.com/openrewrite/rewrite-migrate-java/issues/449")
+    void methodReferences() {
+
+        var a = new A();
+
+        //language=java
+        rewriteRun(
+          s -> s.typeValidationOptions(TypeValidation.none()),
+          java(
+            """
+              package example;
+
+              import lombok.Value;
+              import java.util.function.Supplier;
+
+              @Value
+              public class A {
+                String test;
+
+              }
+
+              class B {
+
+
+                public static String classMethod() {
+                    return "foo";
+                }
+
+              }
+
+              class Using {
+
+                 Supplier<String> usingMethodReference() {
+                    A a = new A("foo");
+                    return a::getTest;
+                }
+
+              }
+              """,
+            """
+              package example;
+
+              import java.util.function.Supplier;
+
+              public record A(
+                String test) {
+              }
+
+              class Using {
+
+                 Supplier<String> usingMethodReference() {
+                    A a = new A("foo");
+                    return a::test;
+                }
+
+              }
+              """
+          )
+        );
+
+    }
+
     @Nested
     class Unchanged {
         @Test