Distinguish between no declared arguments and an empty argument list

in a function literal
If there are no arguments, any number of them might be expected

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java

@@ -233,7 +233,7 @@ public class ArgumentTypeResolver {
         boolean isFunctionLiteral = function instanceof JetFunctionLiteral;
         if (function.getValueParameterList() == null && isFunctionLiteral) {
             return expectedTypeIsUnknown
-                   ? ErrorUtils.createFunctionPlaceholderType(Collections.<JetType>emptyList())
+                   ? ErrorUtils.createFunctionPlaceholderType(Collections.<JetType>emptyList(), /* hasDeclaredArguments = */ false)
                    : builtIns.getFunctionType(Annotations.EMPTY, null, Collections.<JetType>emptyList(), DONT_CARE);
         }
         List<JetParameter> valueParameters = function.getValueParameters();
@@ -248,7 +248,7 @@ public class ArgumentTypeResolver {
         JetType receiverType = resolveTypeRefWithDefault(function.getReceiverTypeReference(), scope, temporaryTrace, null);
 
         return expectedTypeIsUnknown && isFunctionLiteral
-               ? ErrorUtils.createFunctionPlaceholderType(parameterTypes)
+               ? ErrorUtils.createFunctionPlaceholderType(parameterTypes, /* hasDeclaredArguments = */ true)
                : builtIns.getFunctionType(Annotations.EMPTY, receiverType, parameterTypes, returnType);
     }
 

compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(g: () -> Int) {}
+fun foo(f: (Int) -> Int) {}
+
+fun test() {
+    foo { -> 42 }
+}

compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.txt

@@ -0,0 +1,5 @@
+package
+
+internal fun foo(/*0*/ g: () -> kotlin.Int): kotlin.Unit
+internal fun foo(/*0*/ f: (kotlin.Int) -> kotlin.Int): kotlin.Unit
+internal fun test(): kotlin.Unit

compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java

@@ -9012,6 +9012,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("EmptyArgumentListInLambda.kt")
+            public void testEmptyArgumentListInLambda() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("ExtFunDifferentReceiver.kt")
             public void testExtFunDifferentReceiver() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ExtFunDifferentReceiver.kt");

core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt

@@ -423,10 +423,9 @@ fun createCorrespondingFunctionTypeForFunctionPlaceholder(
 ): JetType {
     assert(ErrorUtils.isFunctionPlaceholder(functionPlaceholder)) { "Function placeholder type expected: $functionPlaceholder" }
     val functionPlaceholderTypeConstructor = functionPlaceholder.getConstructor() as FunctionPlaceholderTypeConstructor
-    val declaredArgumentTypes = functionPlaceholderTypeConstructor.getArgumentTypes()
 
     val isExtension = KotlinBuiltIns.isExtensionFunctionType(expectedType)
-    val newArgumentTypes = if (declaredArgumentTypes.isEmpty()) {
+    val newArgumentTypes = if (!functionPlaceholderTypeConstructor.hasDeclaredArguments()) {
         val typeParamSize = expectedType.getConstructor().getParameters().size()
         // the first parameter is receiver (if present), the last one is return type,
         // the remaining are function arguments
@@ -436,7 +435,7 @@ fun createCorrespondingFunctionTypeForFunctionPlaceholder(
         result
     }
     else {
-        declaredArgumentTypes
+        functionPlaceholderTypeConstructor.getArgumentTypes()
     }
     val receiverType = if (isExtension) DONT_CARE else null
     return KotlinBuiltIns.getInstance().getFunctionType(Annotations.EMPTY, receiverType, newArgumentTypes, DONT_CARE)

core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java

@@ -546,19 +546,21 @@ public class ErrorUtils {
     }
 
     @NotNull
-    public static JetType createFunctionPlaceholderType(@NotNull List<JetType> argumentTypes) {
+    public static JetType createFunctionPlaceholderType(@NotNull List<JetType> argumentTypes, boolean hasDeclaredArguments) {
         return new ErrorTypeImpl(
-                new FunctionPlaceholderTypeConstructor(argumentTypes),
+                new FunctionPlaceholderTypeConstructor(argumentTypes, hasDeclaredArguments),
                 createErrorScope("Scope for function placeholder type"));
     }
 
     public static class FunctionPlaceholderTypeConstructor implements TypeConstructor {
         private final TypeConstructor errorTypeConstructor;
         private final List<JetType> argumentTypes;
+        private final boolean hasDeclaredArguments;
 
-        private FunctionPlaceholderTypeConstructor(@NotNull List<JetType> argumentTypes) {
+        private FunctionPlaceholderTypeConstructor(@NotNull List<JetType> argumentTypes, boolean hasDeclaredArguments) {
             errorTypeConstructor = createErrorTypeConstructorWithCustomDebugName("PLACEHOLDER_FUNCTION_TYPE" + argumentTypes);
             this.argumentTypes = argumentTypes;
+            this.hasDeclaredArguments = hasDeclaredArguments;
         }
 
         @NotNull
@@ -566,6 +568,10 @@ public class ErrorUtils {
             return argumentTypes;
         }
 
+        public boolean hasDeclaredArguments() {
+            return hasDeclaredArguments;
+        }
+
         @NotNull
         @Override
         public List<TypeParameterDescriptor> getParameters() {