K2: Support callable references adaptation on top-level

^KT-45989 In progress
^KT-54709 Related
^KT-55217 Fixed

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java

@@ -3102,6 +3102,22 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
                 runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt");
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/diagnostics/tests/callableReference/adapted")
+            @TestDataPath("$PROJECT_ROOT")
+            public class Adapted {
+                @Test
+                public void testAllFilesPresentInAdapted() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/adapted"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @Test
+                @TestMetadata("simpleAdaptationOutsideOfCall.kt")
+                public void testSimpleAdaptationOutsideOfCall() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound")
             @TestDataPath("$PROJECT_ROOT")

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java

@@ -3108,6 +3108,22 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                 runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt");
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/diagnostics/tests/callableReference/adapted")
+            @TestDataPath("$PROJECT_ROOT")
+            public class Adapted {
+                @Test
+                public void testAllFilesPresentInAdapted() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/adapted"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @Test
+                @TestMetadata("simpleAdaptationOutsideOfCall.kt")
+                public void testSimpleAdaptationOutsideOfCall() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound")
             @TestDataPath("$PROJECT_ROOT")

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java

@@ -3102,6 +3102,22 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                 runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt");
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/diagnostics/tests/callableReference/adapted")
+            @TestDataPath("$PROJECT_ROOT")
+            public class Adapted {
+                @Test
+                public void testAllFilesPresentInAdapted() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/adapted"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @Test
+                @TestMetadata("simpleAdaptationOutsideOfCall.kt")
+                public void testSimpleAdaptationOutsideOfCall() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound")
             @TestDataPath("$PROJECT_ROOT")

compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/SyntheticCallableId.kt

@@ -34,4 +34,9 @@ object SyntheticCallableId {
         syntheticPackageName,
         Name.identifier("ID_CALL")
     )
+
+    val ACCEPT_SPECIFIC_TYPE = CallableId(
+        syntheticPackageName,
+        Name.identifier("ACCEPT_SPECIFIC_TYPE_CALL")
+    )
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -154,34 +154,36 @@ class FirSyntheticCallGenerator(
     ): FirCallableReferenceAccess? {
         val argumentList = buildUnaryArgumentList(callableReferenceAccess)
 
-        val typeArguments =
+        val parameterTypeRef =
             when {
-                expectedTypeRef is FirResolvedTypeRef && !expectedTypeRef.coneType.isUnitOrFlexibleUnit -> listOf(
+                expectedTypeRef is FirResolvedTypeRef && !expectedTypeRef.coneType.isUnitOrFlexibleUnit -> expectedTypeRef
-                    buildTypeProjectionWithVariance {
+                else -> context.session.builtinTypes.anyType
-                        variance = Variance.INVARIANT
-                        typeRef = expectedTypeRef
-                    }
-                )
-                else -> emptyList()
             }
 
+        val callableId = SyntheticCallableId.ACCEPT_SPECIFIC_TYPE
+        val functionSymbol = FirSyntheticFunctionSymbol(callableId)
+        // fun accept(p: <parameterTypeRef>): Unit
+        val function =
+            generateMemberFunction(functionSymbol, callableId.callableName, returnType = context.session.builtinTypes.unitType).apply {
+                valueParameters += parameterTypeRef.toValueParameter("reference", functionSymbol, isVararg = false)
+            }.build()
+
         val reference =
             generateCalleeReferenceWithCandidate(
                 callableReferenceAccess,
-                idFunction,
+                function,
                 argumentList,
-                SyntheticCallableId.ID.callableName,
+                callableId.callableName,
                 CallKind.SyntheticIdForCallableReferencesResolution,
                 context,
-                typeArguments,
             )
         val fakeCallElement = buildFunctionCall {
             calleeReference = reference
             this.argumentList = argumentList
         }
 
-        val argument = components.callCompleter.completeCall(fakeCallElement, expectedTypeRef).result.argument
+        val argument = components.callCompleter.completeCall(fakeCallElement, expectedTypeRef = null).result.argument
-        return ((argument as? FirVarargArgumentsExpression)?.arguments?.get(0) ?: argument) as FirCallableReferenceAccess?
+        return argument as FirCallableReferenceAccess?
     }
 
     private fun generateCalleeReferenceWithCandidate(
@@ -191,9 +193,8 @@ class FirSyntheticCallGenerator(
         name: Name,
         callKind: CallKind = CallKind.SyntheticSelect,
         context: ResolutionContext,
-        typeArguments: List<FirTypeProjection> = emptyList()
     ): FirNamedReferenceWithCandidate {
-        val callInfo = generateCallInfo(callSite, name, argumentList, callKind, typeArguments)
+        val callInfo = generateCallInfo(callSite, name, argumentList, callKind)
         val candidate = generateCandidate(callInfo, function, context)
         val applicability = components.resolutionStageRunner.processCandidate(candidate, context)
         if (applicability <= CandidateApplicability.INAPPLICABLE) {
@@ -224,7 +225,6 @@ class FirSyntheticCallGenerator(
         name: Name,
         argumentList: FirArgumentList,
         callKind: CallKind,
-        typeArguments: List<FirTypeProjection> = emptyList()
     ) = CallInfo(
         callSite = callSite,
         callKind = callKind,
@@ -232,7 +232,7 @@ class FirSyntheticCallGenerator(
         explicitReceiver = null,
         argumentList = argumentList,
         isImplicitInvoke = false,
-        typeArguments = typeArguments,
+        typeArguments = emptyList(),
         session = session,
         containingFile = components.file,
         containingDeclarations = components.containingDeclarations

compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.fir.kt

@@ -0,0 +1,10 @@
+// SKIP_TXT
+fun baz(options: String = ""): String = ""
+
+fun runForString(x: () -> String) {}
+
+fun foo(dumpStrategy: String) {
+    val dump0: () -> String = ::baz
+
+    runForString(::baz)
+}

compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt

@@ -0,0 +1,10 @@
+// SKIP_TXT
+fun baz(options: String = ""): String = ""
+
+fun runForString(x: () -> String) {}
+
+fun foo(dumpStrategy: String) {
+    val dump0: () -> String = <!TYPE_MISMATCH!>::<!TYPE_MISMATCH!>baz<!><!>
+
+    runForString(::baz)
+}

compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.fir.kt

@@ -5,5 +5,5 @@ fun foo(x: Any, y: Int) = y
 fun main() {
     ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>
 
-    val fooRef: (Int, Any) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>
+    val fooRef: (Int, Any) -> Unit = ::foo
 }

compiler/testData/diagnostics/tests/callableReference/resolve/withVararg.fir.kt

@@ -6,5 +6,5 @@ fun foo(i: Int) {}
 
 val fn1: (Int) -> Unit = ::foo
 val fn2: (IntArray) -> Unit = ::foo
-val fn3: (Int, Int) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>
+val fn3: (Int, Int) -> Unit = ::foo
 val fn4: (Array<String>) -> Unit = ::foo

compiler/testData/diagnostics/tests/inference/callableReferences/conversionLastStatementInLambda.fir.kt

@@ -4,8 +4,7 @@
 fun main(b: Boolean) {
     callWithLambda {
         // The only relevant case for KT-55729, Unit conversion should work, but doesn't in K1 1.8.0
-        // For K2, it still doesn't work (see KT-55936)
+        ::test1
-        ::<!UNRESOLVED_REFERENCE!>test1<!>
     }
 
     callWithLambda {
@@ -23,8 +22,8 @@ fun main(b: Boolean) {
     }
 
     callWithLambda {
-        // That hasn't been working ever in K1 nor K2
+        // Doesn't work in K1, but does in K2
-        (::<!UNRESOLVED_REFERENCE!>test1<!>)
+        (::test1)
     }
 }
 

compiler/testData/diagnostics/tests/inference/callableReferences/conversionLastStatementInLambda.kt

@@ -4,7 +4,6 @@
 fun main(b: Boolean) {
     callWithLambda {
         // The only relevant case for KT-55729, Unit conversion should work, but doesn't in K1 1.8.0
-        // For K2, it still doesn't work (see KT-55936)
         ::test1
     }
 
@@ -23,7 +22,7 @@ fun main(b: Boolean) {
     }
 
     callWithLambda {
-        // That hasn't been working ever in K1 nor K2
+        // Doesn't work in K1, but does in K2
         (<!TYPE_MISMATCH, TYPE_MISMATCH!>::<!TYPE_MISMATCH!>test1<!><!>)
     }
 }

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -3108,6 +3108,22 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                 runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt");
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/diagnostics/tests/callableReference/adapted")
+            @TestDataPath("$PROJECT_ROOT")
+            public class Adapted {
+                @Test
+                public void testAllFilesPresentInAdapted() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/adapted"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @Test
+                @TestMetadata("simpleAdaptationOutsideOfCall.kt")
+                public void testSimpleAdaptationOutsideOfCall() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound")
             @TestDataPath("$PROJECT_ROOT")

compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.1.fir.kt

@@ -16,11 +16,11 @@ class Case1() {
 
 }
 fun case1() {
-    val y0: (String)-> Case1 = ::<!UNRESOLVED_REFERENCE!>foo<!>
+    val y0: (String)-> Case1 = ::foo
-    val y1: (String)-> Case1 = Case1.Companion::<!UNRESOLVED_REFERENCE!>foo<!>
+    val y1: (String)-> Case1 = Case1.Companion::foo
-    val y2: (String)-> Case1 = (Case1)::<!UNRESOLVED_REFERENCE!>foo<!>
+    val y2: (String)-> Case1 = (Case1)::foo
 }
 
-fun case1_0() : (String)-> Case1 = ::<!UNRESOLVED_REFERENCE!>foo<!>
+fun case1_0() : (String)-> Case1 = ::foo
-fun case1_1() : (String)-> Case1 = (Case1)::<!UNRESOLVED_REFERENCE!>foo<!>
+fun case1_1() : (String)-> Case1 = (Case1)::foo
-fun case1_2(): (String)-> Case1 = Case1.Companion::<!UNRESOLVED_REFERENCE!>foo<!>
+fun case1_2(): (String)-> Case1 = Case1.Companion::foo