From fadb91fa359c868e23687f852f857a0d7f2e2615 Mon Sep 17 00:00:00 2001 From: "sebastian.sellmair" Date: Thu, 16 Sep 2021 15:30:16 +0200 Subject: [PATCH] [Commonizer] Rename CirCommonClassifierId to AssociatedClassifierIds ^KT-48288 --- .../core/ClassOrTypeAliasTypeCommonizer.kt | 10 +- ...sifierId.kt => AssociatedClassifierIds.kt} | 12 +- ....kt => AssociatedClassifierIdsResolver.kt} | 46 ++++---- .../mergedtree/CirKnownClassifiers.kt | 4 +- .../commonizer/mergedtree/CirTypeSignature.kt | 4 +- .../ReApproximationCirNodeTransformer.kt | 2 +- ...=> AssociatedClassifierIdsResolverTest.kt} | 110 +++++++++--------- 7 files changed, 94 insertions(+), 94 deletions(-) rename native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/{CirCommonClassifierId.kt => AssociatedClassifierIds.kt} (64%) rename native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/{CirCommonClassifierIdResolver.kt => AssociatedClassifierIdsResolver.kt} (71%) rename native/commonizer/tests/org/jetbrains/kotlin/commonizer/{CirCommonClassifierIdResolverTest.kt => AssociatedClassifierIdsResolverTest.kt} (68%) diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt index 697e94f5a36..a3b6a7c1363 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt @@ -198,11 +198,11 @@ internal class ClassOrTypeAliasTypeCommonizer( return null } - val commonId = types.singleDistinctValueOrNull { - classifiers.commonClassifierIdResolver.resolveId(it.classifierId) + val associatedIds = types.singleDistinctValueOrNull { + 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 + classifiers: CirKnownClassifiers, associatedIds: AssociatedClassifierIds, types: List ): List { - 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( diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierId.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIds.kt similarity index 64% rename from native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierId.kt rename to native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIds.kt index ca0007fc75b..8aedc830a50 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierId.kt +++ b/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) { +class AssociatedClassifierIds(val ids: Set) { - 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()) } } \ No newline at end of file diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierIdResolver.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIdsResolver.kt similarity index 71% rename from native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierIdResolver.kt rename to native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/AssociatedClassifierIdsResolver.kt index 365ec9a262b..97eceb86cc8 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirCommonClassifierIdResolver.kt +++ b/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, targetDependencies: TargetDependent, commonDependencies: CirProvidedClassifiers = CirProvidedClassifiers.EMPTY, - cache: CirCommonClassifierIdResolverCache = CirCommonClassifierIdResolverCache.create() -): CirCommonClassifierIdResolver { - return CirCommonClassifierIdResolverImpl(classifierIndices, targetDependencies, commonDependencies, cache) + cache: AssociatedClassifierIdsResolverCache = AssociatedClassifierIdsResolverCache.create() +): AssociatedClassifierIdsResolver { + return AssociatedClassifierIdsResolverImpl(classifierIndices, targetDependencies, commonDependencies, cache) } -interface CirCommonClassifierIdResolver { - fun resolveId(id: CirEntityId): CirCommonClassifierId? +interface AssociatedClassifierIdsResolver { + fun resolveAssociatedIds(id: CirEntityId): AssociatedClassifierIds? } -internal interface CirCommonClassifierIdResolverCache { +internal interface AssociatedClassifierIdsResolverCache { - operator fun set(id: CirEntityId, result: CirCommonClassifierId?) - operator fun get(id: CirEntityId): CirCommonClassifierId? + operator fun set(id: CirEntityId, result: AssociatedClassifierIds?) + operator fun get(id: CirEntityId): AssociatedClassifierIds? - object None : CirCommonClassifierIdResolverCache { - override fun set(id: CirEntityId, result: CirCommonClassifierId?) = Unit - override fun get(id: CirEntityId): CirCommonClassifierId? = null + object None : AssociatedClassifierIdsResolverCache { + override fun set(id: CirEntityId, result: AssociatedClassifierIds?) = Unit + override fun get(id: CirEntityId): AssociatedClassifierIds? = null } - private class Default : CirCommonClassifierIdResolverCache { - private val cachedResults = THashMap() + private class Default : AssociatedClassifierIdsResolverCache { + private val cachedResults = THashMap() private val cachedNullResults = THashSet() - 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, private val targetDependencies: TargetDependent, private val commonDependencies: CirProvidedClassifiers, - private val cache: CirCommonClassifierIdResolverCache -) : CirCommonClassifierIdResolver { + private val cache: AssociatedClassifierIdsResolverCache +) : AssociatedClassifierIdsResolver { - override fun resolveId(id: CirEntityId): CirCommonClassifierId? { + override fun resolveAssociatedIds(id: CirEntityId): AssociatedClassifierIds? { cache[id]?.let { return it } - val results = ArrayList() + val results = THashSet() /* Set of every classifier id that once was enqueued already */ val visited = THashSet() @@ -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 } diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirKnownClassifiers.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirKnownClassifiers.kt index a4f695bd80e..4e5d826a9e5 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirKnownClassifiers.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirKnownClassifiers.kt @@ -14,8 +14,8 @@ class CirKnownClassifiers( val targetDependencies: TargetDependent, val commonizedNodes: CirCommonizedClassifierNodes, val commonDependencies: CirProvidedClassifiers, - val commonClassifierIdResolver: CirCommonClassifierIdResolver = - CirCommonClassifierIdResolver(classifierIndices, targetDependencies, commonDependencies), + val associatedIdsResolver: AssociatedClassifierIdsResolver = + AssociatedClassifierIdsResolver(classifierIndices, targetDependencies, commonDependencies), ) /** A set of all CIR nodes built for commonized classes and type aliases. */ diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirTypeSignature.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirTypeSignature.kt index 53cac2b8542..b2af6527d95 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirTypeSignature.kt +++ b/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) } } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/transformer/ReApproximationCirNodeTransformer.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/transformer/ReApproximationCirNodeTransformer.kt index 0021534e4a3..f994a8964f6 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/transformer/ReApproximationCirNodeTransformer.kt +++ b/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 diff --git a/native/commonizer/tests/org/jetbrains/kotlin/commonizer/CirCommonClassifierIdResolverTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/commonizer/AssociatedClassifierIdsResolverTest.kt similarity index 68% rename from native/commonizer/tests/org/jetbrains/kotlin/commonizer/CirCommonClassifierIdResolverTest.kt rename to native/commonizer/tests/org/jetbrains/kotlin/commonizer/AssociatedClassifierIdsResolverTest.kt index 5e24aea70af..3a9c665116f 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/commonizer/CirCommonClassifierIdResolverTest.kt +++ b/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.CirCommonClassifierIdResolverCache +import org.jetbrains.kotlin.commonizer.mergedtree.AssociatedClassifierIdsResolver +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.findCommonId("B")) - assertEquals(setOf("X"), resolver.findCommonId("X")) + assertEquals(setOf("X"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("X"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("X"), resolver.resolveAssociatedIds("X")) } /* @@ -68,11 +68,11 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest ) ) - assertEquals(setOf("C"), resolver.findCommonId("A")) - assertEquals(setOf("C"), resolver.findCommonId("B")) - assertEquals(setOf("C"), resolver.findCommonId("C")) - assertEquals(setOf("C"), resolver.findCommonId("D")) - assertEquals(setOf("C"), resolver.findCommonId("E")) + assertEquals(setOf("C"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("C"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("C"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("C"), resolver.resolveAssociatedIds("D")) + 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.findCommonId("B")) - assertEquals(setOf("A", "B", "C"), resolver.findCommonId("C")) - assertEquals(setOf("A", "B", "C"), resolver.findCommonId("X")) + assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("A", "B", "C"), resolver.resolveAssociatedIds("X")) } fun `test sample 3`() { @@ -112,8 +112,8 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest createCirTreeRootFromSourceCode("class B") ) - assertEquals(emptySet(), resolver.findCommonId("A")) - assertEquals(emptySet(), resolver.findCommonId("B")) + assertEquals(emptySet(), resolver.resolveAssociatedIds("A")) + assertEquals(emptySet(), resolver.resolveAssociatedIds("B")) } @@ -148,9 +148,9 @@ class CirCommonClassifierIdResolverTest : AbstractInlineSourcesCommonizationTest ) ) - assertEquals(setOf("A", "B"), resolver.findCommonId("A")) - assertEquals(setOf("A", "B"), resolver.findCommonId("B")) - assertEquals(setOf("A", "B"), resolver.findCommonId("C")) + assertEquals(setOf("A", "B"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("A", "B"), resolver.resolveAssociatedIds("B")) + 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.findCommonId("B")) - assertEquals(setOf("B", "C", "D"), resolver.findCommonId("C")) - assertEquals(setOf("B", "C", "D"), resolver.findCommonId("D")) - assertEquals(setOf("B", "C", "D"), resolver.findCommonId("E")) + assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("B", "C", "D"), resolver.resolveAssociatedIds("D")) + 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.findCommonId("B")) - assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("C")) - assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("X")) - assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("Y")) - assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.findCommonId("Z")) + assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("X")) + assertEquals(setOf("A", "B", "C", "X", "Y", "Z"), resolver.resolveAssociatedIds("Y")) + 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.findCommonId("D_TA")) - assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("A")) - assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("B")) - assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.findCommonId("C")) + assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("D_X")) + assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("D_TA")) + assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("D_X", "D_TA", "A", "C"), resolver.resolveAssociatedIds("B")) + 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.findCommonId("A1")) - assertEquals(setOf("A"), resolver.findCommonId("A2")) - assertEquals(setOf("A"), resolver.findCommonId("B")) - assertEquals(setOf("A"), resolver.findCommonId("C")) - assertEquals(setOf("A"), resolver.findCommonId("E")) - assertEquals(setOf("A"), resolver.findCommonId("D")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("A1")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("A2")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("A"), resolver.resolveAssociatedIds("E")) + 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.findCommonId("B")) - assertEquals(setOf("A", "C"), resolver.findCommonId("C")) - assertEquals(setOf("A", "C"), resolver.findCommonId("D")) - assertEquals(setOf("A", "C"), resolver.findCommonId("E")) - assertEquals(setOf("A", "C"), resolver.findCommonId("F")) - assertEquals(setOf("A", "C"), resolver.findCommonId("G")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("A")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("B")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("C")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("D")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("E")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("F")) + assertEquals(setOf("A", "C"), resolver.resolveAssociatedIds("G")) } } private fun createCommonClassifierIdResolver( vararg root: CirTreeRoot, dependencies: CirProvidedClassifiers = CirProvidedClassifiers.EMPTY -): CirCommonClassifierIdResolver { - return CirCommonClassifierIdResolver( +): AssociatedClassifierIdsResolver { + 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 = - resolveId(CirEntityId.create(id))?.aliases.orEmpty().map { it.toQualifiedNameString() }.toSet() +private fun AssociatedClassifierIdsResolver.resolveAssociatedIds(id: String): Set = + resolveAssociatedIds(CirEntityId.create(id))?.ids.orEmpty().map { it.toQualifiedNameString() }.toSet()