Fix compatibility resolve for references with multiple outer candidates

#KT-39533 Fixed

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

@@ -1794,6 +1794,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt");
         }
 
+        @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt")
+        public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt");
+        }
+
         @TestMetadata("constraintFromLHSWithCorrectDirection.kt")
         public void testConstraintFromLHSWithCorrectDirection() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt");
@@ -1804,6 +1809,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt");
         }
 
+        @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt")
+        public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt");
+        }
+
         @TestMetadata("correctInfoAfterArrayLikeCall.kt")
         public void testCorrectInfoAfterArrayLikeCall() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt");
@@ -1974,6 +1984,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt");
         }
 
+        @TestMetadata("unitAdaptationForReferenceCompatibility.kt")
+        public void testUnitAdaptationForReferenceCompatibility() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt");
+        }
+
         @TestMetadata("unused.kt")
         public void testUnused() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt");

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt

@@ -287,9 +287,12 @@ class KotlinToResolvedCallTransformer(
                 is ArgumentMatch -> {
                     parameter = argumentMapping.valueParameter
 
+                    // We should take expected type from the last used conversion
+                    // TODO: move this logic into ParameterTypeConversion
                     val expectedType =
-                        resolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument)
+                        resolvedCall.getExpectedTypeForUnitConvertedArgument(valueArgument)
                             ?: resolvedCall.getExpectedTypeForSuspendConvertedArgument(valueArgument)
+                            ?: resolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument)
                             ?: getEffectiveExpectedType(argumentMapping.valueParameter, valueArgument, context)
                     Pair(
                         expectedType,
@@ -667,6 +670,7 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
     private var smartCastDispatchReceiverType: KotlinType? = null
     private var expectedTypeForSamConvertedArgumentMap: MutableMap<ValueArgument, UnwrappedType>? = null
     private var expectedTypeForSuspendConvertedArgumentMap: MutableMap<ValueArgument, UnwrappedType>? = null
+    private var expectedTypeForUnitConvertedArgumentMap: MutableMap<ValueArgument, UnwrappedType>? = null
     private var argumentTypeForConstantConvertedMap: MutableMap<KtExpression, IntegerValueTypeConstant>? = null
 
 
@@ -749,6 +753,7 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
 
         calculateExpectedTypeForSamConvertedArgumentMap(substitutor)
         calculateExpectedTypeForSuspendConvertedArgumentMap(substitutor)
+        calculateExpectedTypeForUnitConvertedArgumentMap(substitutor)
         calculateExpectedTypeForConstantConvertedArgumentMap()
     }
 
@@ -820,6 +825,9 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
     fun getExpectedTypeForSuspendConvertedArgument(valueArgument: ValueArgument): UnwrappedType? =
         expectedTypeForSuspendConvertedArgumentMap?.get(valueArgument)
 
+    fun getExpectedTypeForUnitConvertedArgument(valueArgument: ValueArgument): UnwrappedType? =
+        expectedTypeForUnitConvertedArgumentMap?.get(valueArgument)
+
     private fun calculateExpectedTypeForConstantConvertedArgumentMap() {
         if (resolvedCallAtom.argumentsWithConstantConversion.isEmpty()) return
 
@@ -853,6 +861,18 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
         }
     }
 
+    private fun calculateExpectedTypeForUnitConvertedArgumentMap(substitutor: NewTypeSubstitutor?) {
+        if (resolvedCallAtom.argumentsWithUnitConversion.isEmpty()) return
+
+        expectedTypeForUnitConvertedArgumentMap = hashMapOf()
+        for ((argument, convertedType) in resolvedCallAtom.argumentsWithUnitConversion) {
+            val typeWithFreshVariables = resolvedCallAtom.freshVariablesSubstitutor.safeSubstitute(convertedType)
+            val expectedType = substitutor?.safeSubstitute(typeWithFreshVariables) ?: typeWithFreshVariables
+            expectedTypeForUnitConvertedArgumentMap!![argument.psiCallArgument.valueArgument] = expectedType
+        }
+    }
+
+
     override fun argumentToParameterMap(
         resultingDescriptor: CallableDescriptor,
         valueArguments: Map<ValueParameterDescriptor, ResolvedValueArgument>,
@@ -905,7 +925,8 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
 fun ResolutionCandidateApplicability.toResolutionStatus(): ResolutionStatus = when (this) {
     ResolutionCandidateApplicability.RESOLVED,
     ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY,
-    ResolutionCandidateApplicability.RESOLVED_WITH_ERROR -> ResolutionStatus.SUCCESS
+    ResolutionCandidateApplicability.RESOLVED_WITH_ERROR,
+    ResolutionCandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY -> ResolutionStatus.SUCCESS
     ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER -> ResolutionStatus.RECEIVER_TYPE_ERROR
     else -> ResolutionStatus.OTHER_ERROR
 }

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolver.kt

@@ -110,7 +110,6 @@ class CallableReferenceResolver(
             chosenCandidate.diagnostics.forEach {
                 val transformedDiagnostic = when (it) {
                     is CompatibilityWarning -> CompatibilityWarningOnArgument(argument, it.candidate)
-                    is LowerPriorityToPreserveCompatibility -> return@forEach
                     else -> it
                 }
                 diagnosticsHolder.addDiagnostic(transformedDiagnostic)

compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt

@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun interface IFoo {
+    fun foo(i: Int)
+}
+
+fun interface IFoo2 : IFoo
+
+object A
+
+operator fun A.get(i: IFoo) = 1
+operator fun A.set(i: IFoo, newValue: Int) {}
+
+fun withVararg(vararg xs: Int) = 42
+
+fun test1() {
+    <!UNRESOLVED_REFERENCE!><!INAPPLICABLE_CANDIDATE!>A[::withVararg]<!> += 1<!>
+}

compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt

@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun interface IFoo {
+    fun foo(i: Int)
+}
+
+fun interface IFoo2 : IFoo
+
+object A
+
+operator fun A.get(i: IFoo) = 1
+operator fun A.set(i: IFoo, newValue: Int) {}
+
+fun withVararg(vararg xs: Int) = 42
+
+fun test1() {
+    A[::withVararg] += 1
+}

compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.txt

@@ -0,0 +1,27 @@
+package
+
+public fun test1(): kotlin.Unit
+public fun withVararg(/*0*/ vararg xs: kotlin.Int /*kotlin.IntArray*/): kotlin.Int
+public operator fun A.get(/*0*/ i: IFoo): kotlin.Int
+public operator fun A.set(/*0*/ i: IFoo, /*1*/ newValue: kotlin.Int): kotlin.Unit
+
+public object A {
+    private constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public fun interface IFoo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ i: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public fun interface IFoo2 : IFoo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ i: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.fir.kt

@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
+
+fun <T> foo(f: () -> T): T = f()
+
+fun bar(): Unit {}
+
+object Scope {
+    fun bar(s: String = ""): Double = 0.0
+
+    fun <T> foo(f: () -> T): T = f()
+
+    object NestedScope {
+        fun bar(a: Int = 0): String = ""
+
+        fun test() {
+            // Despite the fact ::bar is resolved with compatibility warning, it's important not to propagate it to the outer call
+            val result = <!DEBUG_INFO_CALL("fqName: Scope.foo; typeCall: function")!>foo(::bar)<!>
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>result<!>
+        }
+    }
+}

compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt

@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
+
+fun <T> foo(f: () -> T): T = f()
+
+fun bar(): Unit {}
+
+object Scope {
+    fun bar(s: String = ""): Double = 0.0
+
+    fun <T> foo(f: () -> T): T = f()
+
+    object NestedScope {
+        fun bar(a: Int = 0): String = ""
+
+        fun test() {
+            // Despite the fact ::bar is resolved with compatibility warning, it's important not to propagate it to the outer call
+            val result = <!DEBUG_INFO_CALL("fqName: Scope.foo; typeCall: function")!>foo(<!COMPATIBILITY_WARNING!>::bar<!>)<!>
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>result<!>
+        }
+    }
+}

compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.txt

@@ -0,0 +1,22 @@
+package
+
+public fun bar(): kotlin.Unit
+public fun </*0*/ T> foo(/*0*/ f: () -> T): T
+
+public object Scope {
+    private constructor Scope()
+    public final fun bar(/*0*/ s: kotlin.String = ...): kotlin.Double
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ T> foo(/*0*/ f: () -> T): T
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public object NestedScope {
+        private constructor NestedScope()
+        public final fun bar(/*0*/ a: kotlin.Int = ...): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final fun test(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.fir.kt

@@ -0,0 +1,25 @@
+// FILE: Callable.java
+
+public interface Callable<V> {
+    V call() throws Exception;
+}
+
+// FILE: Future.java
+
+public class Future<T> {}
+
+// FILE: Executor.java
+
+public interface Executor {
+    <T> Future<T> submit(Callable<T> task);
+    Future<?> submit(Runnable task);
+}
+
+// FILE: test.kt
+
+fun f(): String = "test"
+
+class A {
+    fun schedule1(e: Executor): Future<String> = e.submit(::f)
+    fun schedule2(e: Executor): Future<String> = e.submit { f() }
+}

compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt

@@ -0,0 +1,25 @@
+// FILE: Callable.java
+
+public interface Callable<V> {
+    V call() throws Exception;
+}
+
+// FILE: Future.java
+
+public class Future<T> {}
+
+// FILE: Executor.java
+
+public interface Executor {
+    <T> Future<T> submit(Callable<T> task);
+    Future<?> submit(Runnable task);
+}
+
+// FILE: test.kt
+
+fun f(): String = "test"
+
+class A {
+    fun schedule1(e: Executor): Future<String> = e.submit(::f)
+    fun schedule2(e: Executor): Future<String> = <!TYPE_MISMATCH!>e.submit { f() }<!>
+}

compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.txt

@@ -0,0 +1,34 @@
+package
+
+public fun f(): kotlin.String
+
+public final class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun schedule1(/*0*/ e: Executor): Future<kotlin.String>
+    public final fun schedule2(/*0*/ e: Executor): Future<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Callable</*0*/ V : kotlin.Any!> {
+    public abstract fun call(): V!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Executor {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun </*0*/ T : kotlin.Any!> submit(/*0*/ task: Callable<T!>!): Future<T!>!
+    public abstract fun submit(/*0*/ task: java.lang.Runnable!): Future<*>!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Future</*0*/ T : kotlin.Any!> {
+    public constructor Future</*0*/ T : kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.kt

@@ -14,7 +14,7 @@ fun test1(s: SubInt, sWrong: SubIntWrong) {
     foo(<!TYPE_MISMATCH!>a<!>)
 
     a <!CAST_NEVER_SUCCEEDS!>as<!> (Int, String) -> String
-    foo(a)
+    foo(<!DEBUG_INFO_SMARTCAST!>a<!>)
 }
 
 fun <T> test2(x: T) where T : (Int, String) -> Int, T : (Double) -> Int {

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

@@ -1801,6 +1801,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali
                 runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt");
             }
 
+            @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt")
+            public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt");
+            }
+
             @TestMetadata("constraintFromLHSWithCorrectDirection.kt")
             public void testConstraintFromLHSWithCorrectDirection() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt");
@@ -1811,6 +1816,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali
                 runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt");
             }
 
+            @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt")
+            public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt");
+            }
+
             @TestMetadata("correctInfoAfterArrayLikeCall.kt")
             public void testCorrectInfoAfterArrayLikeCall() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt");
@@ -1981,6 +1991,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali
                 runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt");
             }
 
+            @TestMetadata("unitAdaptationForReferenceCompatibility.kt")
+            public void testUnitAdaptationForReferenceCompatibility() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt");
+            }
+
             @TestMetadata("unused.kt")
             public void testUnused() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt");

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -1796,6 +1796,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt");
             }
 
+            @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt")
+            public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt");
+            }
+
             @TestMetadata("constraintFromLHSWithCorrectDirection.kt")
             public void testConstraintFromLHSWithCorrectDirection() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt");
@@ -1806,6 +1811,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt");
             }
 
+            @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt")
+            public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt");
+            }
+
             @TestMetadata("correctInfoAfterArrayLikeCall.kt")
             public void testCorrectInfoAfterArrayLikeCall() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt");
@@ -1976,6 +1986,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt");
             }
 
+            @TestMetadata("unitAdaptationForReferenceCompatibility.kt")
+            public void testUnitAdaptationForReferenceCompatibility() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt");
+            }
+
             @TestMetadata("unused.kt")
             public void testUnused() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt");