fix(LambdaBlockToExpression): convert lambda with method invocation in assertThrows as well

build.gradle.kts

@@ -7,6 +7,10 @@ plugins {
 group = "org.openrewrite.recipe"
 description = "The first Static Analysis and REMEDIATION tool"
 
+recipeDependencies {
+    parserClasspath("org.junit.jupiter:junit-jupiter-api:latest.release")
+}
+
 val rewriteVersion = rewriteRecipe.rewriteVersion.get()
 dependencies {
     compileOnly("org.projectlombok:lombok:latest.release")

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

@@ -23,8 +23,10 @@
 import org.openrewrite.java.tree.*;
 import org.openrewrite.staticanalysis.java.JavaFileChecker;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 public class LambdaBlockToExpression extends Recipe {
     @Override
@@ -70,7 +72,7 @@ public J.Lambda visitLambda(J.Lambda lambda, ExecutionContext ctx) {
 
                     @Override
                     public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
-                        if (hasLambdaArgument(method) && hasMethodOverloading(method)) {
+                        if (hasLambdaArgument(method) && hasAmbiguousMethodOverloading(method)) {
                             return method;
                         }
                         return super.visitMethodInvocation(method, ctx);
@@ -79,42 +81,66 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
         );
     }
 
+    private static boolean hasLambdaArgument(J.MethodInvocation method) {
+        boolean hasLambdaArgument = false;
+        for (Expression arg : method.getArguments()) {
+            if (arg instanceof J.Lambda) {
+                hasLambdaArgument = true;
+                break;
+            }
+        }
+        return hasLambdaArgument;
+    }
+
     // Check whether a method has overloading methods in the declaring class
-    private static boolean hasMethodOverloading(J.MethodInvocation method) {
+    static boolean hasAmbiguousMethodOverloading(MethodCall method) {
         JavaType.Method methodType = method.getMethodType();
-        return methodType != null && hasMethodOverloading(methodType);
+        return methodType != null
+                && hasAmbiguousMethodOverloading(methodType, method.getArguments(), methodType.getName());
     }
 
     // TODO this is actually more complex in the presence of generics and inheritance
-    static boolean hasMethodOverloading(JavaType.Method methodType) {
-        String methodName = methodType.getName();
-        return Optional.of(methodType)
+    static boolean hasAmbiguousMethodOverloading(JavaType.Method methodType, List<Expression> arguments, String methodName) {
+        int numberOfArguments = arguments.size();
+
+        //all methods of the given type
+        List<JavaType.Method> methodsOfType = Optional.of(methodType)
                 .map(JavaType.Method::getDeclaringType)
                 .filter(JavaType.Class.class::isInstance)
                 .map(JavaType.Class.class::cast)
                 .map(JavaType.Class::getMethods)
-                .map(methods -> {
-                    int overloadingCount = 0;
-                    for (JavaType.Method dm : methods) {
-                        if (dm.getName().equals(methodName)) {
-                            if (++overloadingCount > 1) {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                })
-                .orElse(false);
-    }
+                .orElse(Collections.emptyList());
 
-    private static boolean hasLambdaArgument(J.MethodInvocation method) {
-        boolean hasLambdaArgument = false;
-        for (Expression arg : method.getArguments()) {
-            if (arg instanceof J.Lambda) {
-                hasLambdaArgument = true;
-                break;
+        List<JavaType.Method> potentiallyOverLoadedMethods = methodsOfType.stream()
+                .filter(dm -> dm.getName().equals(methodName))
+                .filter(dm -> dm.getParameterTypes().size() == numberOfArguments)
+                .collect(Collectors.toList());
+
+        //if there are less than 2 such methods, then there is no ambiguity
+        if(potentiallyOverLoadedMethods.size() <= 1) {
+            return false;
+        }
+
+        //if there is a position where
+        //  - the argument is a lambda
+        //  - the parameters of all potential methods have the same type
+        // then there is no ambiguity
+        //TODO we currently assume that there is at most one lambda among the arguments. Handing several lambdas will
+        // require a bigger rewrite because `visitMethodInvocation` can only return true or false, but not which lambda
+        // to replace
+        for (int i = 0; i < numberOfArguments; i++) {
+            int finalI = i;
+            if (arguments.get(i) instanceof J.Lambda) {
+                long distinctElementsCount = potentiallyOverLoadedMethods.stream()
+                    .map(m -> m.getParameterTypes().get(finalI))
+                    .distinct().count();
+                if (distinctElementsCount == 1) {
+                    return false;
+                }
             }
         }
-        return hasLambdaArgument;
+        //otherwise, there must be ambiguity
+        return true;
     }
+
 }

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

@@ -24,7 +24,7 @@
 import java.util.List;
 import java.util.Set;
 
-import static org.openrewrite.staticanalysis.LambdaBlockToExpression.hasMethodOverloading;
+import static org.openrewrite.staticanalysis.LambdaBlockToExpression.hasAmbiguousMethodOverloading;
 
 @Incubating(since = "7.23.0")
 public class RemoveRedundantTypeCast extends Recipe {
@@ -74,7 +74,7 @@ public J visitTypeCast(J.TypeCast typeCast, ExecutionContext ctx) {
                 } else if (parentValue instanceof MethodCall) {
                     MethodCall methodCall = (MethodCall) parentValue;
                     JavaType.Method methodType = methodCall.getMethodType();
-                    if (methodType == null || hasMethodOverloading(methodType)) {
+                    if (methodType == null || hasAmbiguousMethodOverloading(methodCall)) {
                         return visited;
                     } else if (!methodType.getParameterTypes().isEmpty()) {
                         List<Expression> arguments = methodCall.getArguments();

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

@@ -17,6 +17,7 @@
 
 import org.junit.jupiter.api.Test;
 import org.openrewrite.DocumentExample;
+import org.openrewrite.InMemoryExecutionContext;
 import org.openrewrite.Issue;
 import org.openrewrite.java.JavaParser;
 import org.openrewrite.test.RecipeSpec;
@@ -25,11 +26,12 @@
 import static org.openrewrite.java.Assertions.java;
 
 class LambdaBlockToExpressionTest implements RewriteTest {
-
     @Override
     public void defaults(RecipeSpec spec) {
         spec.recipe(new LambdaBlockToExpression())
-            .parser(JavaParser.fromJavaVersion().logCompilationWarningsAndErrors(true));
+            .parser(JavaParser.fromJavaVersion()
+              .classpathFromResources(new InMemoryExecutionContext(), "junit-jupiter-api-5.10")
+              .logCompilationWarningsAndErrors(true));
     }
 
     @DocumentExample
@@ -75,7 +77,7 @@ class Test {
             """
               import java.util.function.Function;
               class Test {
-                  Function<Integer, Integer> f = n -> 
+                  Function<Integer, Integer> f = n ->
                       // The buttonType will always be "cancel", even if we pressed one of the entry type buttons
                       n + 1;
               }
@@ -116,7 +118,7 @@ void doTest() {
 
     @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/236")
     @Test
-    void simplifyLambdaBlockReturningVoidAsWell2() {
+    void simplifyLambdaBlockReturningVoidAsWellSimple() {
         //language=java
         rewriteRun(
           java(
@@ -145,4 +147,42 @@ public void run() {
         );
     }
 
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/236")
+    @Test
+    void simplifyLambdaBlockReturningVoidAsWellAssertThrows() {
+        //language=java
+        rewriteRun(
+          java(
+            """
+              import static org.junit.jupiter.api.Assertions.assertThrows;
+
+              import java.math.BigDecimal;
+              import org.junit.jupiter.api.Test;
+
+              public class Main {
+                @Test
+                public void test() {
+                  assertThrows(ArithmeticException.class, () -> {
+                    BigDecimal.ONE.divide(BigDecimal.ZERO);
+                  });
+                }
+              }
+              """,
+            """
+              import static org.junit.jupiter.api.Assertions.assertThrows;
+
+              import java.math.BigDecimal;
+              import org.junit.jupiter.api.Test;
+
+              public class Main {
+                @Test
+                public void test() {
+                  assertThrows(ArithmeticException.class, () ->
+                    BigDecimal.ONE.divide(BigDecimal.ZERO));
+                }
+              }
+              """
+          )
+        );
+    }
 }