Fix UnnecessaryExplicitTypeArguments within lambda return statements (#858)

* Fix UnnecessaryExplicitTypeArguments within lambda return statements (#670)

* Extract findMethodIfUnambiguous and getLambdaReturnType methods

Author: timtebeek

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

@@ -21,6 +21,8 @@
 import org.openrewrite.java.tree.*;
 import org.openrewrite.staticanalysis.java.JavaFileChecker;
 
+import org.jspecify.annotations.Nullable;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -90,7 +92,7 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                             inferredType = methodDeclaration.getReturnTypeExpression().getType();
                         }
                     } else if (e instanceof J.Lambda) {
-                        inferredType = ((J.Lambda) e).getType();
+                        inferredType = getLambdaReturnType(((J.Lambda) e).getType());
                     }
                 }
 
@@ -101,6 +103,46 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                 return m;
             }
 
+            private JavaType.@Nullable Method findMethodIfUnambiguous(JavaType.FullyQualified type) {
+                JavaType.Method sam = null;
+                for (JavaType.Method candidate : type.getMethods()) {
+                    if (candidate.hasFlags(Flag.Default) || candidate.hasFlags(Flag.Static)) {
+                        continue;
+                    }
+                    if (sam != null) {
+                        return null;
+                    }
+                    sam = candidate;
+                }
+                return sam;
+            }
+
+            private @Nullable JavaType getLambdaReturnType(@Nullable JavaType lambdaType) {
+                JavaType.Parameterized parameterized = TypeUtils.asParameterized(lambdaType);
+                if (parameterized == null) {
+                    return null;
+                }
+                JavaType.Method sam = findMethodIfUnambiguous(parameterized);
+                if (sam == null) {
+                    return null;
+                }
+                JavaType samReturn = sam.getReturnType();
+                if (samReturn instanceof JavaType.GenericTypeVariable) {
+                    String name = ((JavaType.GenericTypeVariable) samReturn).getName();
+                    List<JavaType> formalParams = parameterized.getType().getTypeParameters();
+                    List<JavaType> actualParams = parameterized.getTypeParameters();
+                    for (int i = 0; i < formalParams.size() && i < actualParams.size(); i++) {
+                        JavaType formal = formalParams.get(i);
+                        if (formal instanceof JavaType.GenericTypeVariable &&
+                                name.equals(((JavaType.GenericTypeVariable) formal).getName())) {
+                            return actualParams.get(i);
+                        }
+                    }
+                    return null;
+                }
+                return samReturn;
+            }
+
             private boolean shouldRetainOnStaticMethod(JavaType.Method methodType) {
                 if (!methodType.hasFlags(Flag.Static)) {
                     return false;

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

@@ -71,7 +71,7 @@ Object o() {
         );
     }
 
-    @ExpectedToFail("Not implemented yet")
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/670")
     @Test
     void withinLambda() {
         rewriteRun(