Preserve casts pinning generic-method return type in lambdas

Without the cast, calls like `<T extends SourceFile> T withSourcePath(Path)`
inside a lambda lose `T` to its bound during outer inference (e.g.
`Optional.map(...).ifPresent(generated::add)`), causing compilation errors.

Fixes #871

Author: timtebeek

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

@@ -131,6 +131,23 @@ public J visitTypeCast(J.TypeCast typeCast, ExecutionContext ctx) {
                     }
                 }
 
+                // A cast inside a lambda body may pin the inferred return type of a generic method call
+                // so outer inference (e.g. Optional.map -> ifPresent) doesn't lose it to the type bound.
+                if (parentValue instanceof J.Lambda && typeCast.getExpression() instanceof J.MethodInvocation) {
+                    JavaType.Method invokedMethod = ((J.MethodInvocation) typeCast.getExpression()).getMethodType();
+                    if (invokedMethod != null && invokedMethod.getDeclaringType() != null) {
+                        for (JavaType.Method declared : invokedMethod.getDeclaringType().getMethods()) {
+                            if (declared.getName().equals(invokedMethod.getName()) &&
+                                    declared.getParameterTypes().size() == invokedMethod.getParameterTypes().size() &&
+                                    declared.getReturnType() instanceof JavaType.GenericTypeVariable &&
+                                    declared.getDeclaredFormalTypeNames().contains(
+                                            ((JavaType.GenericTypeVariable) declared.getReturnType()).getName())) {
+                                return visitedTypeCast;
+                            }
+                        }
+                    }
+                }
+
                 if (!(targetType instanceof JavaType.Array) && TypeUtils.isOfClassType(targetType, "java.lang.Object") ||
                     TypeUtils.isOfType(targetType, expressionType) ||
                     TypeUtils.isAssignableTo(targetType, expressionType)) {

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

@@ -612,6 +612,33 @@ private ChildBar getChildBar() {
         );
     }
 
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/871")
+    @Test
+    void doNotRemoveCastNeededForGenericMethodInferenceInLambda() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.nio.file.Path;
+              import java.util.List;
+              import java.util.Optional;
+
+              interface SourceFile {
+                  <T extends SourceFile> T withSourcePath(Path path);
+              }
+
+              class Test {
+                  void foo(Optional<? extends SourceFile> opt, Path targetPath, List<SourceFile> generated) {
+                      opt
+                          .map(sourceFile -> (SourceFile) sourceFile.withSourcePath(targetPath))
+                          .ifPresent(generated::add);
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/221")
     @Test
     void doNotRemoveCharacterCastInGenericContext() {