Wire KotlinTypeRefiner in areCallableDescriptorsEquivalent

See the issue for details

^KT-41218 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignatureForResolvedCall.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCallImpl
 import org.jetbrains.kotlin.resolve.calls.results.FlatSignature.Companion.argumentValueType
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.util.CancellationChecker
 import java.util.*
 
@@ -58,6 +59,7 @@ fun createOverloadingConflictResolver(
     specificityComparator: TypeSpecificityComparator,
     platformOverloadsSpecificityComparator: PlatformOverloadsSpecificityComparator,
     cancellationChecker: CancellationChecker,
+    kotlinTypeRefiner: KotlinTypeRefiner,
 ) = OverloadingConflictResolver(
     builtIns,
     module,
@@ -69,5 +71,6 @@ fun createOverloadingConflictResolver(
     MutableResolvedCall<*>::createFlatSignature,
     { (it as? VariableAsFunctionResolvedCallImpl)?.variableCall },
     { DescriptorToSourceUtils.descriptorToDeclaration(it) != null },
-    null
+    null,
+    kotlinTypeRefiner
 )

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.calls.tower.TowerUtilsKt;
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner;
 import org.jetbrains.kotlin.util.CancellationChecker;
 
 import java.util.*;
@@ -46,10 +47,11 @@ public class ResolutionResultsHandler {
             @NotNull ModuleDescriptor module,
             @NotNull TypeSpecificityComparator specificityComparator,
             @NotNull PlatformOverloadsSpecificityComparator platformOverloadsSpecificityComparator,
-            @NotNull CancellationChecker cancellationChecker
+            @NotNull CancellationChecker cancellationChecker,
+            @NotNull KotlinTypeRefiner kotlinTypeRefiner
     ) {
         overloadingConflictResolver = FlatSignatureForResolvedCallKt.createOverloadingConflictResolver(
-                builtIns, module, specificityComparator, platformOverloadsSpecificityComparator, cancellationChecker
+                builtIns, module, specificityComparator, platformOverloadsSpecificityComparator, cancellationChecker, kotlinTypeRefiner
         );
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/IdentifierInfo.kt

@@ -33,6 +33,8 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.KotlinTypeRefinerImpl
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 
 interface IdentifierInfo {
 
@@ -63,7 +65,7 @@ interface IdentifierInfo {
         override fun equals(other: Any?) =
             other is Variable &&
                     DescriptorEquivalenceForOverrides.areCallableDescriptorsEquivalent(
-                        variable, other.variable, allowCopiesFromTheSameDeclaration = true
+                        variable, other.variable, allowCopiesFromTheSameDeclaration = true, kotlinTypeRefiner = KotlinTypeRefiner.Default
                     )
 
         override fun hashCode() = variable.name.hashCode() * 31 + variable.containingDeclaration.original.hashCode()

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

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.tower.ImplicitScopeTower
 import org.jetbrains.kotlin.resolve.calls.tower.TowerResolver
 import org.jetbrains.kotlin.resolve.calls.tower.isInapplicable
 import org.jetbrains.kotlin.types.UnwrappedType
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.util.CancellationChecker
 
 
@@ -42,7 +43,8 @@ class CallableReferenceOverloadConflictResolver(
     platformOverloadsSpecificityComparator: PlatformOverloadsSpecificityComparator,
     cancellationChecker: CancellationChecker,
     statelessCallbacks: KotlinResolutionStatelessCallbacks,
-    constraintInjector: ConstraintInjector
+    constraintInjector: ConstraintInjector,
+    kotlinTypeRefiner: KotlinTypeRefiner,
 ) : OverloadingConflictResolver<CallableReferenceCandidate>(
     builtIns,
     module,
@@ -54,7 +56,8 @@ class CallableReferenceOverloadConflictResolver(
     Companion::createFlatSignature,
     { null },
     { statelessCallbacks.isDescriptorFromSource(it) },
-    null
+    null,
+    kotlinTypeRefiner,
 ) {
     companion object {
         private fun createFlatSignature(candidate: CallableReferenceCandidate) =

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

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadingConflictResolver
 import org.jetbrains.kotlin.resolve.calls.results.PlatformOverloadsSpecificityComparator
 import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.util.CancellationChecker
 import java.util.*
 
@@ -37,7 +38,8 @@ class NewOverloadingConflictResolver(
     platformOverloadsSpecificityComparator: PlatformOverloadsSpecificityComparator,
     cancellationChecker: CancellationChecker,
     statelessCallbacks: KotlinResolutionStatelessCallbacks,
-    constraintInjector: ConstraintInjector
+    constraintInjector: ConstraintInjector,
+    kotlinTypeRefiner: KotlinTypeRefiner,
 ) : OverloadingConflictResolver<KotlinResolutionCandidate>(
     builtIns,
     module,
@@ -52,7 +54,8 @@ class NewOverloadingConflictResolver(
     Companion::createFlatSignature,
     { it.variableCandidateIfInvoke },
     { statelessCallbacks.isDescriptorFromSource(it) },
-    { it.resolvedCall.hasSamConversion }
+    { it.resolvedCall.hasSamConversion },
+    kotlinTypeRefiner,
 ) {
 
     companion object {

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isTypeRefinementEnabled
 import org.jetbrains.kotlin.resolve.descriptorUtil.varargParameterPosition
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.types.checker.requireOrDescribe
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.util.CancellationChecker
@@ -46,7 +47,8 @@ open class OverloadingConflictResolver<C : Any>(
     private val createFlatSignature: (C) -> FlatSignature<C>,
     private val getVariableCandidates: (C) -> C?, // for variable WithInvoke
     private val isFromSources: (CallableDescriptor) -> Boolean,
-    private val hasSAMConversion: ((C) -> Boolean)?
+    private val hasSAMConversion: ((C) -> Boolean)?,
+    private val kotlinTypeRefiner: KotlinTypeRefiner,
 ) {
 
     private val isTypeRefinementEnabled by lazy { module.isTypeRefinementEnabled() }
@@ -137,7 +139,8 @@ open class OverloadingConflictResolver<C : Any>(
                         me,
                         other,
                         allowCopiesFromTheSameDeclaration = isTypeRefinementEnabled,
-                        ignoreReturnType = ignoreReturnType
+                        ignoreReturnType = ignoreReturnType,
+                        kotlinTypeRefiner = kotlinTypeRefiner
                     )
                 ) {
                     continue@outerLoop

core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 
 object DescriptorEquivalenceForOverrides {
 
@@ -40,7 +41,8 @@ object DescriptorEquivalenceForOverrides {
                 a,
                 b,
                 allowCopiesFromTheSameDeclaration = allowCopiesFromTheSameDeclaration,
-                distinguishExpectsAndNonExpects = distinguishExpectsAndNonExpects
+                distinguishExpectsAndNonExpects = distinguishExpectsAndNonExpects,
+                kotlinTypeRefiner = KotlinTypeRefiner.Default
             )
 
             a is PackageFragmentDescriptor && b is PackageFragmentDescriptor -> (a).fqName == (b).fqName
@@ -79,7 +81,8 @@ object DescriptorEquivalenceForOverrides {
         b: CallableDescriptor,
         allowCopiesFromTheSameDeclaration: Boolean,
         distinguishExpectsAndNonExpects: Boolean = true,
-        ignoreReturnType: Boolean = false
+        ignoreReturnType: Boolean = false,
+        kotlinTypeRefiner: KotlinTypeRefiner
     ): Boolean {
         if (a == b) return true
         if (a.name != b.name) return false
@@ -94,7 +97,7 @@ object DescriptorEquivalenceForOverrides {
 
         if (!ownersEquivalent(a, b, { _, _ -> false }, allowCopiesFromTheSameDeclaration)) return false
 
-        val overridingUtil = OverridingUtil.createWithEqualityAxioms eq@{ c1, c2 ->
+        val overridingUtil = OverridingUtil.create(kotlinTypeRefiner) eq@{ c1, c2 ->
             if (c1 == c2) return@eq true
 
             val d1 = c1.declarationDescriptor

core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java

@@ -77,6 +77,14 @@ public class OverridingUtil {
         return new OverridingUtil(DEFAULT_TYPE_CONSTRUCTOR_EQUALITY, kotlinTypeRefiner);
     }
 
+    @NotNull
+    public static OverridingUtil create(
+            @NotNull KotlinTypeRefiner kotlinTypeRefiner,
+            @NotNull KotlinTypeChecker.TypeConstructorEquality equalityAxioms
+    ) {
+            return new OverridingUtil(equalityAxioms, kotlinTypeRefiner);
+    }
+
     private final KotlinTypeRefiner kotlinTypeRefiner;
     private final KotlinTypeChecker.TypeConstructorEquality equalityAxioms;
 

idea/testData/multiplatform/kt41218/dependencies.txt

@@ -1,4 +1,5 @@
 MODULE jvm { platform=[JVM] }
 
 jvm -> STDLIB_JVM { kind=DEPENDENCY }
-jvm -> STDLIB_COMMON { kind=DEPENDENCY }
+jvm -> STDLIB_COMMON { kind=DEPENDENCY }
+jvm -> MOCK_JDK { kind=DEPENDENCY }

idea/testData/multiplatform/kt41218/jvm/jvm.kt

@@ -1,5 +1,7 @@
+// !RENDER_DIAGNOSTICS_MESSAGES
+
 package sample
 
 fun test() {
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>arrayListOf<!>(1, 2, 3)
+    arrayListOf(1, 2, 3)
 }

idea/tests/org/jetbrains/kotlin/idea/multiplatform/multiPlatformSetup.kt

@@ -99,6 +99,10 @@ fun AbstractMultiModuleTest.doSetup(projectModel: ProjectResolveModel) {
                     PluginTestCaseBase.jdk(TestJdkKind.FULL_JDK)
                 })
 
+                MockJdk -> ConfigLibraryUtil.configureSdk(ideaModule, PluginTestCaseBase.addJdk(testRootDisposable) {
+                    PluginTestCaseBase.jdk(TestJdkKind.MOCK_JDK)
+                })
+
                 is ResolveLibrary -> ideaModule.addLibrary(to.root, to.name, to.kind)
 
                 else -> ideaModule.addDependency(resolveModulesToIdeaModules[to]!!)

idea/tests/org/jetbrains/kotlin/projectModel/Model.kt

@@ -164,6 +164,13 @@ object FullJdk : ResolveLibrary(
     null
 )
 
+object MockJdk : ResolveLibrary(
+    "mock-jdk",
+    File("fake file for mock jdk"),
+    JvmPlatforms.defaultJvmPlatform,
+    null
+)
+
 open class ResolveDependency(val to: ResolveModule, val kind: Kind) {
     open class Builder {
         var to: ResolveModule.Builder = ResolveModule.Builder()

idea/tests/org/jetbrains/kotlin/projectModel/Parser.kt

@@ -21,6 +21,7 @@ open class ProjectStructureParser(private val projectRoot: File) {
         "STDLIB_JVM" to ResolveLibrary.Builder(Stdlib.JvmStdlib),
         "STDLIB_COMMON" to ResolveLibrary.Builder(Stdlib.CommonStdlib),
         "FULL_JDK" to ResolveLibrary.Builder(FullJdk),
+        "MOCK_JDK" to ResolveLibrary.Builder(MockJdk),
         "KOTLIN_TEST_JS" to ResolveLibrary.Builder(KotlinTest.JsKotlinTest),
         "KOTLIN_TEST_JVM" to ResolveLibrary.Builder(KotlinTest.JvmKotlinTest)
     )

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNameClashChecker.kt

@@ -33,10 +33,12 @@ import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtensionProperty
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 
 class JsNameClashChecker(
     private val nameSuggestion: NameSuggestion,
-    private val languageVersionSettings: LanguageVersionSettings
+    private val languageVersionSettings: LanguageVersionSettings,
+    private val kotlinTypeRefiner: KotlinTypeRefiner,
 ) : DeclarationChecker {
     companion object {
         private val COMMON_DIAGNOSTICS = setOf(
@@ -124,7 +126,7 @@ class JsNameClashChecker(
             // If refinement is enabled, we can get duplicate descriptors for one and the same members (as refinement re-creates
             // descriptors), so, in this case, we have to compare descriptors structurally
             DescriptorEquivalenceForOverrides.areCallableDescriptorsEquivalent(
-                existing, overrideDescriptor, allowCopiesFromTheSameDeclaration = true
+                existing, overrideDescriptor, allowCopiesFromTheSameDeclaration = true, kotlinTypeRefiner = kotlinTypeRefiner
             )
         }
     }