Use lambda parameter counts and block bodies for improved resolution

johannescoetzee · johannescoetzee · commit 67cd6ea94054 · 2025-05-22T12:14:37.000+02:00
diff --git a/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java b/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/MethodResolutionLogic.java
@@ -24,6 +24,7 @@
 import com.github.javaparser.resolution.MethodUsage;
 import com.github.javaparser.resolution.TypeSolver;
 import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.model.LambdaArgumentTypePlaceholder;
 import com.github.javaparser.resolution.model.SymbolReference;
 import com.github.javaparser.resolution.model.typesystem.ReferenceTypeImpl;
 import com.github.javaparser.resolution.types.*;
@@ -67,6 +68,43 @@ public static boolean isApplicable(
         return isApplicable(method, name, argumentsTypes, typeSolver, false);
     }
 
+    private static boolean isConflictingLambdaType(
+            LambdaArgumentTypePlaceholder lambdaPlaceholder, ResolvedType expectedType) {
+        // TODO: It might be possible to use the resolved type variable here, but that would either require
+        //  a type parameters map to be passed in, or the type variable to be resolved here which could lead
+        //  to duplicated work or maybe infinite recursion.
+        if (!expectedType.isReferenceType()) {
+            return false;
+        }
+        Optional<MethodUsage> maybeFunctionalInterface = FunctionalInterfaceLogic.getFunctionalMethod(expectedType);
+        if (maybeFunctionalInterface.isPresent()) {
+            MethodUsage functionalInterface = maybeFunctionalInterface.get();
+            // If the lambda expression does not have the same number of parameters as the functional interface
+            // method, the lambda cannot implement that interface.
+            if (lambdaPlaceholder.getParameterCount().isPresent()
+                    && functionalInterface.getNoParams()
+                            != lambdaPlaceholder.getParameterCount().get()) {
+                return true;
+            }
+            // If the lambda method has a block body then:
+            //   1. If the block contains a return statement with a returned value, the lambda can only implement
+            //      non-void methods.
+            //   2. If the block contains an empty return statement, or no return statement, the lambda can only
+            //      implement void methods.
+            if (lambdaPlaceholder.bodyBlockHasExplicitNonVoidReturn().isPresent()) {
+                boolean lambdaReturnIsVoid =
+                        !lambdaPlaceholder.bodyBlockHasExplicitNonVoidReturn().get();
+                if (lambdaReturnIsVoid && !functionalInterface.returnType().isVoid()) {
+                    return true;
+                }
+                if (!lambdaReturnIsVoid && functionalInterface.returnType().isVoid()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     /**
      * Note the specific naming here -- parameters are part of the method declaration,
      * while arguments are the values passed when calling a method.
@@ -145,6 +183,11 @@ private static boolean isApplicable(
         for (int i = 0; i < countOfMethodParametersDeclared; i++) {
             ResolvedType expectedDeclaredType = methodDeclaration.getParam(i).getType();
             ResolvedType actualArgumentType = needleArgumentTypes.get(i);
+            if (actualArgumentType instanceof LambdaArgumentTypePlaceholder
+                    && isConflictingLambdaType(
+                            (LambdaArgumentTypePlaceholder) actualArgumentType, expectedDeclaredType)) {
+                return false;
+            }
             if ((expectedDeclaredType.isTypeVariable() && !(expectedDeclaredType.isWildcard()))
                     && expectedDeclaredType.asTypeParameter().declaredOnMethod()) {
                 matchedParameters.put(expectedDeclaredType.asTypeParameter().getName(), actualArgumentType);
diff --git a/javaparser-core/src/main/java/com/github/javaparser/resolution/model/LambdaArgumentTypePlaceholder.java b/javaparser-core/src/main/java/com/github/javaparser/resolution/model/LambdaArgumentTypePlaceholder.java
@@ -22,6 +22,7 @@
 
 import com.github.javaparser.resolution.declarations.ResolvedMethodLikeDeclaration;
 import com.github.javaparser.resolution.types.ResolvedType;
+import java.util.Optional;
 
 /**
  * Placeholder used to represent a lambda argument type while it is being
@@ -33,10 +34,31 @@ public class LambdaArgumentTypePlaceholder implements ResolvedType {
 
     private int pos;
 
+    private final Optional<Integer> parameterCount;
+
+    private final Optional<Boolean> bodyBlockHasExplicitNonVoidReturn;
+
     private SymbolReference<? extends ResolvedMethodLikeDeclaration> method;
 
     public LambdaArgumentTypePlaceholder(int pos) {
         this.pos = pos;
+        this.parameterCount = Optional.empty();
+        this.bodyBlockHasExplicitNonVoidReturn = Optional.empty();
+    }
+
+    public LambdaArgumentTypePlaceholder(
+            int pos, int parameterCount, Optional<Boolean> bodyBlockHasExplicitNonVoidReturn) {
+        this.pos = pos;
+        this.parameterCount = Optional.of(parameterCount);
+        this.bodyBlockHasExplicitNonVoidReturn = bodyBlockHasExplicitNonVoidReturn;
+    }
+
+    public Optional<Integer> getParameterCount() {
+        return parameterCount;
+    }
+
+    public Optional<Boolean> bodyBlockHasExplicitNonVoidReturn() {
+        return bodyBlockHasExplicitNonVoidReturn;
     }
 
     @Override
diff --git a/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java
@@ -33,6 +33,7 @@
 import com.github.javaparser.ast.expr.*;
 import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt;
 import com.github.javaparser.ast.stmt.ForEachStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
 import com.github.javaparser.ast.type.Type;
 import com.github.javaparser.resolution.*;
 import com.github.javaparser.resolution.declarations.*;
@@ -264,7 +265,25 @@ private void solveArguments(
             while (parameterValue instanceof EnclosedExpr) {
                 parameterValue = ((EnclosedExpr) parameterValue).getInner();
             }
-            if (parameterValue.isLambdaExpr() || parameterValue.isMethodReferenceExpr()) {
+            if (parameterValue.isLambdaExpr()) {
+                LambdaExpr lambdaExpr = parameterValue.asLambdaExpr();
+                Optional<Boolean> bodyBlockHasExplicitNonVoidReturn;
+                if (!lambdaExpr.getBody().isBlockStmt()) {
+                    bodyBlockHasExplicitNonVoidReturn = Optional.empty();
+                } else {
+                    Optional<ReturnStmt> explicitReturn = lambdaExpr.getBody().findFirst(ReturnStmt.class);
+                    if (explicitReturn.isPresent()) {
+                        bodyBlockHasExplicitNonVoidReturn =
+                                Optional.of(explicitReturn.get().getExpression().isPresent());
+                    } else {
+                        bodyBlockHasExplicitNonVoidReturn = Optional.of(false);
+                    }
+                }
+                LambdaArgumentTypePlaceholder placeholder = new LambdaArgumentTypePlaceholder(
+                        i, lambdaExpr.getParameters().size(), bodyBlockHasExplicitNonVoidReturn);
+                argumentTypes.add(placeholder);
+                placeholders.add(placeholder);
+            } else if (parameterValue.isMethodReferenceExpr()) {
                 LambdaArgumentTypePlaceholder placeholder = new LambdaArgumentTypePlaceholder(i);
                 argumentTypes.add(placeholder);
                 placeholders.add(placeholder);
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/LambdaResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/LambdaResolutionTest.java
@@ -21,6 +21,7 @@
 
 package com.github.javaparser.symbolsolver.resolution;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import com.github.javaparser.StaticJavaParser;
@@ -35,6 +36,7 @@
 import com.github.javaparser.symbolsolver.JavaSymbolSolver;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 class LambdaResolutionTest extends AbstractResolutionTest {
@@ -211,4 +213,144 @@ void lambdaAsVararg() {
                 "java.util.function.Consumer<java.lang.String>",
                 lambda.calculateResolvedType().describe());
     }
+
+    @Test
+    void lambdaOverloadsWithDifferentParameterCounts1() {
+        String source = "import java.util.function.Consumer;\n" + "class Test {\n"
+                + "    void foo(Consumer<String> consumer) {}\n"
+                + "    void foo(Runnable r) {}\n"
+                + "    void test() {\n"
+                + "        foo(input -> {});\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertEquals(
+                "Test.foo(java.util.function.Consumer<java.lang.String>)",
+                call.resolve().getQualifiedSignature());
+        assertEquals("void", call.calculateResolvedType().describe());
+    }
+
+    @Test
+    void lambdaOverloadsWithDifferentParameterCounts2() {
+        String source = "import java.util.function.Consumer;\n" + "class Test {\n"
+                + "    void foo(Consumer<java.lang.String> consumer) {}\n"
+                + "    void foo(Runnable r) {}\n"
+                + "    void test() {\n"
+                + "        foo(() -> {});\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertEquals("Test.foo(java.lang.Runnable)", call.resolve().getQualifiedSignature());
+        assertEquals("void", call.calculateResolvedType().describe());
+    }
+
+    @Test
+    void lambdaOverloadsWithDifferentReturnTypes1() {
+        String source = "import java.util.function.Consumer;\n" + "import java.util.function.Function;\n"
+                + "class Test {\n"
+                + "    void foo(Consumer<String> consumer) {}\n"
+                + "    void foo(Function<Integer, String> func) {}\n"
+                + "    void test() {\n"
+                + "        foo(input -> {});\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertEquals(
+                "Test.foo(java.util.function.Consumer<java.lang.String>)",
+                call.resolve().getQualifiedSignature());
+        assertEquals("void", call.calculateResolvedType().describe());
+    }
+
+    @Test
+    void lambdaOverloadsWithDifferentReturnTypes2() {
+        String source = "import java.util.function.Consumer;\n" + "import java.util.function.Function;\n"
+                + "class Test {\n"
+                + "    void foo(Consumer<String> consumer) {}\n"
+                + "    void foo(Function<Integer, String> func) {}\n"
+                + "    void test() {\n"
+                + "        foo(input -> { return \"\"; });\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertEquals(
+                "Test.foo(java.util.function.Function<java.lang.Integer, java.lang.String>)",
+                call.resolve().getQualifiedSignature());
+        assertEquals("void", call.calculateResolvedType().describe());
+    }
+
+    @Test
+    void lambdaUsedAsPolymorphicArgument() {
+        String source = "import java.util.function.Consumer;\n" + "import java.util.HashMap;"
+                + "class Test {\n"
+                + "    void test() {\n"
+                + "        HashMap<String, Consumer> map = new HashMap<>();"
+                + "        map.put(\"\", input -> {});\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertDoesNotThrow(() -> call.resolve().getQualifiedSignature());
+        assertDoesNotThrow(() -> call.calculateResolvedType().describe());
+        assertEquals("java.util.HashMap.put(K, V)", call.resolve().getQualifiedSignature());
+    }
+
+    @Test
+    void lambdaUsedAsOverloadedArrayAlternativeArgument() {
+        String source = "import java.util.function.Consumer;\n" + "import java.util.function.Function;\n"
+                + "class Foo<S extends Consumer, T> {\n"
+                + "    void foo(Object[] ts) {}\n"
+                + "    void foo(T t) {}\n"
+                + "}\n"
+                + "class Test {\n"
+                + "    void test() {\n"
+                + "        Foo<Consumer<Integer>, Function<Integer, Integer>> foo = new Foo<>();\n"
+                + "        foo.foo(value -> { return 2; });\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertDoesNotThrow(() -> call.resolve().getQualifiedSignature());
+        assertDoesNotThrow(() -> call.calculateResolvedType().describe());
+        assertEquals("Foo.foo(T)", call.resolve().getQualifiedSignature());
+    }
+
+    @Disabled("Disambiguation for lambdas used as polymorphic is not supported yet.")
+    @Test
+    void lambdaUsedAsOverloadedPolymorphicArgument1() {
+
+        String source = "import java.util.function.Consumer;\n" + "import java.util.function.Function;\n"
+                + "class Foo<S extends Consumer, T> {\n"
+                + "    void foo(T t) {}\n"
+                + "    void foo(S s) {}\n"
+                + "}\n"
+                + "class Test {\n"
+                + "    void test() {\n"
+                + "        Foo<Consumer<Integer>, Function<Integer, Integer>> foo = new Foo<>();\n"
+                + "        foo.foo(value -> { return 2; });\n"
+                + "    }\n"
+                + "}";
+
+        StaticJavaParser.getParserConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
+        final CompilationUnit cu = StaticJavaParser.parse(source);
+        final MethodCallExpr call = cu.findFirst(MethodCallExpr.class).get();
+        assertDoesNotThrow(() -> call.resolve().getQualifiedSignature());
+        assertDoesNotThrow(() -> call.calculateResolvedType().describe());
+        assertEquals("Foo.foo(java.util.function.Function)", call.resolve().getQualifiedSignature());
+    }
 }
