[Commonizer] Rename CirCommonClassifierId to AssociatedClassifierIds

^KT-48288

native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt

@@ -198,11 +198,11 @@ internal class ClassOrTypeAliasTypeCommonizer(
             return null
         }
 
-        val commonId = types.singleDistinctValueOrNull {
+        val associatedIds = types.singleDistinctValueOrNull {
-            classifiers.commonClassifierIdResolver.resolveId(it.classifierId)
+            classifiers.associatedIdsResolver.resolveAssociatedIds(it.classifierId)
         } ?: return null
 
-        val typeSubstitutionCandidates = resolveTypeSubstitutionCandidates(classifiers, commonId, types)
+        val typeSubstitutionCandidates = resolveTypeSubstitutionCandidates(classifiers, associatedIds, types)
             .filter { typeSubstitutionCandidate ->
                 assert(typeSubstitutionCandidate.typeDistance.isZero.not()) { "Expected no zero typeDistance" }
                 if (typeSubstitutionCandidate.typeDistance.isNotReachable) return@filter false
@@ -221,9 +221,9 @@ private class TypeSubstitutionCandidate(
 )
 
 private fun resolveTypeSubstitutionCandidates(
-    classifiers: CirKnownClassifiers, commonId: CirCommonClassifierId, types: List<CirClassOrTypeAliasType>
+    classifiers: CirKnownClassifiers, associatedIds: AssociatedClassifierIds, types: List<CirClassOrTypeAliasType>
 ): List<TypeSubstitutionCandidate> {
-    return commonId.aliases.mapNotNull mapCandidateId@{ candidateId ->
+    return associatedIds.ids.mapNotNull mapCandidateId@{ candidateId ->
         val typeDistances = types.mapIndexed { targetIndex, type -> typeDistance(classifiers, targetIndex, type, candidateId) }
         if (typeDistances.any { it.isNotReachable }) return@mapCandidateId null
         TypeSubstitutionCandidate(

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIds.kt

@@ -7,25 +7,25 @@ package org.jetbrains.kotlin.commonizer.mergedtree
 
 import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 
-class CirCommonClassifierId(val aliases: List<CirEntityId>) {
+class AssociatedClassifierIds(val ids: Set<CirEntityId>) {
 
-    private val _hashCode = aliases.hashCode()
+    private val _hashCode = ids.hashCode()
 
     override fun hashCode(): Int = _hashCode
 
     override fun equals(other: Any?): Boolean {
         if (other === this) return true
-        if (other !is CirCommonClassifierId) return false
+        if (other !is AssociatedClassifierIds) return false
         if (other._hashCode != this._hashCode) return false
-        if (other.aliases != this.aliases) return false
+        if (other.ids != this.ids) return false
         return true
     }
 
     override fun toString(): String {
-        return aliases.joinToString(prefix = "(", postfix = ")")
+        return ids.joinToString(prefix = "(", postfix = ")")
     }
 
     init {
-        require(aliases.isNotEmpty())
+        require(ids.isNotEmpty())
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIdsResolver.kt

@@ -13,60 +13,60 @@ import org.jetbrains.kotlin.commonizer.TargetDependent
 import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 import org.jetbrains.kotlin.commonizer.cir.CirTypeAlias
 
-internal fun CirCommonClassifierIdResolver(
+internal fun AssociatedClassifierIdsResolver(
     classifierIndices: TargetDependent<CirClassifierIndex>,
     targetDependencies: TargetDependent<CirProvidedClassifiers>,
     commonDependencies: CirProvidedClassifiers = CirProvidedClassifiers.EMPTY,
-    cache: CirCommonClassifierIdResolverCache = CirCommonClassifierIdResolverCache.create()
+    cache: AssociatedClassifierIdsResolverCache = AssociatedClassifierIdsResolverCache.create()
-): CirCommonClassifierIdResolver {
+): AssociatedClassifierIdsResolver {
-    return CirCommonClassifierIdResolverImpl(classifierIndices, targetDependencies, commonDependencies, cache)
+    return AssociatedClassifierIdsResolverImpl(classifierIndices, targetDependencies, commonDependencies, cache)
 }
 
-interface CirCommonClassifierIdResolver {
+interface AssociatedClassifierIdsResolver {
-    fun resolveId(id: CirEntityId): CirCommonClassifierId?
+    fun resolveAssociatedIds(id: CirEntityId): AssociatedClassifierIds?
 }
 
-internal interface CirCommonClassifierIdResolverCache {
+internal interface AssociatedClassifierIdsResolverCache {
 
-    operator fun set(id: CirEntityId, result: CirCommonClassifierId?)
+    operator fun set(id: CirEntityId, result: AssociatedClassifierIds?)
-    operator fun get(id: CirEntityId): CirCommonClassifierId?
+    operator fun get(id: CirEntityId): AssociatedClassifierIds?
 
-    object None : CirCommonClassifierIdResolverCache {
+    object None : AssociatedClassifierIdsResolverCache {
-        override fun set(id: CirEntityId, result: CirCommonClassifierId?) = Unit
+        override fun set(id: CirEntityId, result: AssociatedClassifierIds?) = Unit
-        override fun get(id: CirEntityId): CirCommonClassifierId? = null
+        override fun get(id: CirEntityId): AssociatedClassifierIds? = null
     }
 
-    private class Default : CirCommonClassifierIdResolverCache {
+    private class Default : AssociatedClassifierIdsResolverCache {
-        private val cachedResults = THashMap<CirEntityId, CirCommonClassifierId>()
+        private val cachedResults = THashMap<CirEntityId, AssociatedClassifierIds>()
         private val cachedNullResults = THashSet<CirEntityId>()
 
-        override fun set(id: CirEntityId, result: CirCommonClassifierId?) {
+        override fun set(id: CirEntityId, result: AssociatedClassifierIds?) {
             if (result == null) cachedNullResults.add(id)
             else cachedResults[id] = result
         }
 
-        override fun get(id: CirEntityId): CirCommonClassifierId? {
+        override fun get(id: CirEntityId): AssociatedClassifierIds? {
             if (id in cachedNullResults) return null
             return cachedResults[id]
         }
     }
 
     companion object {
-        fun create(): CirCommonClassifierIdResolverCache = Default()
+        fun create(): AssociatedClassifierIdsResolverCache = Default()
     }
 }
 
-private class CirCommonClassifierIdResolverImpl(
+private class AssociatedClassifierIdsResolverImpl(
     private val classifierIndices: TargetDependent<CirClassifierIndex>,
     private val targetDependencies: TargetDependent<CirProvidedClassifiers>,
     private val commonDependencies: CirProvidedClassifiers,
-    private val cache: CirCommonClassifierIdResolverCache
+    private val cache: AssociatedClassifierIdsResolverCache
-) : CirCommonClassifierIdResolver {
+) : AssociatedClassifierIdsResolver {
 
-    override fun resolveId(id: CirEntityId): CirCommonClassifierId? {
+    override fun resolveAssociatedIds(id: CirEntityId): AssociatedClassifierIds? {
         cache[id]?.let { return it }
 
-        val results = ArrayList<CirEntityId>()
+        val results = THashSet<CirEntityId>()
 
         /* Set of every classifier id that once was enqueued already */
         val visited = THashSet<CirEntityId>()
@@ -129,7 +129,7 @@ private class CirCommonClassifierIdResolverImpl(
             }
         }
 
-        val result = if (results.isNotEmpty()) CirCommonClassifierId(results) else null
+        val result = if (results.isNotEmpty()) AssociatedClassifierIds(results) else null
         visited.forEach { visitedId -> cache[visitedId] = result }
         return result
     }

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirKnownClassifiers.kt

@@ -14,8 +14,8 @@ class CirKnownClassifiers(
     val targetDependencies: TargetDependent<CirProvidedClassifiers>,
     val commonizedNodes: CirCommonizedClassifierNodes,
     val commonDependencies: CirProvidedClassifiers,
-    val commonClassifierIdResolver: CirCommonClassifierIdResolver =
+    val associatedIdsResolver: AssociatedClassifierIdsResolver =
-        CirCommonClassifierIdResolver(classifierIndices, targetDependencies, commonDependencies),
+        AssociatedClassifierIdsResolver(classifierIndices, targetDependencies, commonDependencies),
 )
 
 /** A set of all CIR nodes built for commonized classes and type aliases. */

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirTypeSignature.kt

@@ -62,9 +62,9 @@ internal sealed interface ClassifierSignatureBuildingContext {
         override fun appendSignature(signature: CirTypeSignature, classifierId: CirEntityId) = signature.add(classifierId)
     }
 
-    class TypeAliasInvariant(private val commonClassifierIdResolver: CirCommonClassifierIdResolver) : ClassifierSignatureBuildingContext {
+    class TypeAliasInvariant(private val associatedIdsResolver: AssociatedClassifierIdsResolver) : ClassifierSignatureBuildingContext {
         override fun appendSignature(signature: CirTypeSignature, classifierId: CirEntityId) {
-            return signature.add(commonClassifierIdResolver.resolveId(classifierId) ?: classifierId)
+            return signature.add(associatedIdsResolver.resolveAssociatedIds(classifierId) ?: classifierId)
         }
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/transformer/ReApproximationCirNodeTransformer.kt

@@ -26,7 +26,7 @@ internal class ReApproximationCirNodeTransformer(
         operator fun invoke(member: CirMemberContext, functionOrPropertyOrConstructor: CirHasTypeParameters): SignatureBuildingContext {
             return SignatureBuildingContext(
                 memberContext = member, functionOrPropertyOrConstructor = functionOrPropertyOrConstructor,
-                classifierSignatureBuildingContext = if (typeAliasInvariant) TypeAliasInvariant(classifiers.commonClassifierIdResolver)
+                classifierSignatureBuildingContext = if (typeAliasInvariant) TypeAliasInvariant(classifiers.associatedIdsResolver)
                 else ClassifierSignatureBuildingContext.Default,
                 argumentsSignatureBuildingContext = if (skipArguments) ArgumentsSignatureBuildingContext.SkipArguments
                 else ArgumentsSignatureBuildingContext.Default

native/commonizer/tests/org/jetbrains/kotlin/commonizer/AssociatedClassifierIdsResolverTest.kt

@@ -7,15 +7,15 @@ package org.jetbrains.kotlin.commonizer
 
 import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 import org.jetbrains.kotlin.commonizer.mergedtree.CirClassifierIndex
-import org.jetbrains.kotlin.commonizer.mergedtree.CirCommonClassifierIdResolver
+import org.jetbrains.kotlin.commonizer.mergedtree.AssociatedClassifierIdsResolver
-import org.jetbrains.kotlin.commonizer.mergedtree.CirCommonClassifierIdResolverCache
+import org.jetbrains.kotlin.commonizer.mergedtree.AssociatedClassifierIdsResolverCache
 import org.jetbrains.kotlin.commonizer.mergedtree.CirProvidedClassifiers
 import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
 import org.jetbrains.kotlin.commonizer.utils.createCirProvidedClassifiers
 import org.jetbrains.kotlin.commonizer.utils.createCirTreeRoot
 import org.jetbrains.kotlin.commonizer.utils.createCirTreeRootFromSourceCode
 
-class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest() {
+class AssociatedClassifierIdsResolverTest : AbstractInlineSourcesCommonizationTest() {
 
     /*
     Platform A:    X -> A
@@ -39,9 +39,9 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("X"), resolver.findCommonId("A"))
+        assertEquals(setOf("X"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("X"), resolver.findCommonId("B"))
+        assertEquals(setOf("X"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("X"), resolver.findCommonId("X"))
+        assertEquals(setOf("X"), resolver.resolveAssociatedIds("X"))
     }
 
     /*
@@ -68,11 +68,11 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("C"), resolver.findCommonId("A"))
+        assertEquals(setOf("C"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("C"), resolver.findCommonId("B"))
+        assertEquals(setOf("C"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("C"), resolver.findCommonId("C"))
+        assertEquals(setOf("C"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("C"), resolver.findCommonId("D"))
+        assertEquals(setOf("C"), resolver.resolveAssociatedIds("D"))
-        assertEquals(setOf("C"), resolver.findCommonId("E"))
+        assertEquals(setOf("C"), resolver.resolveAssociatedIds("E"))
     }
 
     /*
@@ -100,10 +100,10 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("A", "B", "C"), resolver.findCommonId("A"))
+        assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("A", "B", "C"), resolver.findCommonId("B"))
+        assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("A", "B", "C"), resolver.findCommonId("C"))
+        assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("A", "B", "C"), resolver.findCommonId("X"))
+        assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("X"))
     }
 
     fun `test sample 3`() {
@@ -112,8 +112,8 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             createCirTreeRootFromSourceCode("class B")
         )
 
-        assertEquals(emptySet<String>(), resolver.findCommonId("A"))
+        assertEquals(emptySet<String>(), resolver.resolveAssociatedIds("A"))
-        assertEquals(emptySet<String>(), resolver.findCommonId("B"))
+        assertEquals(emptySet<String>(), resolver.resolveAssociatedIds("B"))
     }
 
 
@@ -148,9 +148,9 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("A", "B"), resolver.findCommonId("A"))
+        assertEquals(setOf("A", "B"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("A", "B"), resolver.findCommonId("B"))
+        assertEquals(setOf("A", "B"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("A", "B"), resolver.findCommonId("C"))
+        assertEquals(setOf("A", "B"), resolver.resolveAssociatedIds("C"))
     }
 
     /*
@@ -182,11 +182,11 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
         )
 
         val resolver = createCommonClassifierIdResolver(rootB, rootA)
-        assertEquals(setOf("B", "C", "D"), resolver.findCommonId("A"))
+        assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("B", "C", "D"), resolver.findCommonId("B"))
+        assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("B", "C", "D"), resolver.findCommonId("C"))
+        assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("B", "C", "D"), resolver.findCommonId("D"))
+        assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("D"))
-        assertEquals(setOf("B", "C", "D"), resolver.findCommonId("E"))
+        assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("E"))
     }
 
     /*
@@ -221,12 +221,12 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("A"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("B"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("C"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("X"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("X"))
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("Y"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("Y"))
-        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("Z"))
+        assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("Z"))
     }
 
     fun `test sample 7 - with dependencies`() {
@@ -264,11 +264,11 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             rootA, rootB, dependencies = createCirProvidedClassifiers(dependenciesModule)
         )
 
-        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("D_X"))
+        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("D_X"))
-        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("D_TA"))
+        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("D_TA"))
-        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("A"))
+        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("B"))
+        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("C"))
+        assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("C"))
     }
 
     /*
@@ -297,13 +297,13 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("A"), resolver.findCommonId("A"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("A"), resolver.findCommonId("A1"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("A1"))
-        assertEquals(setOf("A"), resolver.findCommonId("A2"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("A2"))
-        assertEquals(setOf("A"), resolver.findCommonId("B"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("A"), resolver.findCommonId("C"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("A"), resolver.findCommonId("E"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("E"))
-        assertEquals(setOf("A"), resolver.findCommonId("D"))
+        assertEquals(setOf("A"), resolver.resolveAssociatedIds("D"))
     }
 
     /*
@@ -335,30 +335,30 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest
             )
         )
 
-        assertEquals(setOf("A", "C"), resolver.findCommonId("A"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("A"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("B"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("B"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("C"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("C"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("D"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("D"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("E"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("E"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("F"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("F"))
-        assertEquals(setOf("A", "C"), resolver.findCommonId("G"))
+        assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("G"))
     }
 }
 
 private fun createCommonClassifierIdResolver(
     vararg root: CirTreeRoot,
     dependencies: CirProvidedClassifiers = CirProvidedClassifiers.EMPTY
-): CirCommonClassifierIdResolver {
+): AssociatedClassifierIdsResolver {
-    return CirCommonClassifierIdResolver(
+    return AssociatedClassifierIdsResolver(
         TargetDependent(root.withIndex().associate { (index, root) -> LeafCommonizerTarget(index.toString()) to root })
             .mapValue(::CirClassifierIndex),
         targetDependencies = root.withIndex()
             .associate { (index, _) -> LeafCommonizerTarget(index.toString()) to CirProvidedClassifiers.EMPTY }.toTargetDependent(),
         commonDependencies = dependencies,
-        cache = CirCommonClassifierIdResolverCache.None
+        cache = AssociatedClassifierIdsResolverCache.None
     )
 }
 
-private fun CirCommonClassifierIdResolver.findCommonId(id: String): Set<String> =
+private fun AssociatedClassifierIdsResolver.resolveAssociatedIds(id: String): Set<String> =
-    resolveId(CirEntityId.create(id))?.aliases.orEmpty().map { it.toQualifiedNameString() }.toSet()
+    resolveAssociatedIds(CirEntityId.create(id))?.ids.orEmpty().map { it.toQualifiedNameString() }.toSet()