From 68f8e88d8b5aaff233d9b7c5562e0b8697874944 Mon Sep 17 00:00:00 2001 From: Dmitriy Dolovov Date: Mon, 30 Nov 2020 23:48:15 +0300 Subject: [PATCH] [Commonizer] Introduce various types of classifier caches - New CirCommonizedClassifiers and CirForwardDeclarations caches - New CirProvidedClassifiers cache with classifier names loaded from arbitrary modules - CirClassifiersCache is replaced by CirKnownClassifiers umbrella - Replace the remaining usages of 'isUnderStandardKotlinPackages' by delegation to CirKnownClassifiers.commonDependeeLibraries --- .../descriptors/commonizer/Parameters.kt | 1 + .../AbstractFunctionOrPropertyCommonizer.kt | 10 +- .../core/CallableValueParametersCommonizer.kt | 6 +- .../commonizer/core/ClassCommonizer.kt | 6 +- .../core/ClassConstructorCommonizer.kt | 10 +- .../commonizer/core/CommonizationVisitor.kt | 13 +- .../core/ExtensionReceiverCommonizer.kt | 6 +- .../commonizer/core/FunctionCommonizer.kt | 6 +- .../commonizer/core/PropertyCommonizer.kt | 4 +- .../commonizer/core/TypeAliasCommonizer.kt | 25 ++-- .../commonizer/core/TypeCommonizer.kt | 67 +++++---- .../core/TypeParameterCommonizer.kt | 10 +- .../core/TypeParameterListCommonizer.kt | 6 +- .../core/ValueParameterCommonizer.kt | 6 +- .../core/ValueParameterListCommonizer.kt | 6 +- .../kotlin/descriptors/commonizer/facade.kt | 35 +++-- .../mergedtree/CirClassifiersCache.kt | 128 ++++++++++++++---- .../commonizer/mergedtree/CirTreeMerger.kt | 14 +- .../commonizer/mergedtree/collectors.kt | 14 +- .../commonizer/mergedtree/nodeBuilders.kt | 24 ++-- .../descriptors/commonizer/utils/constants.kt | 2 - .../descriptors/commonizer/utils/misc.kt | 6 - .../commonizer/utils/moduleDescriptor.kt | 47 ++++--- .../AbstractCommonizationFromSourcesTest.kt | 45 +++--- .../commonizer/CommonizerFacadeTest.kt | 2 +- .../core/ExtensionReceiverCommonizerTest.kt | 4 +- .../commonizer/core/TypeCommonizerTest.kt | 42 ++++-- .../core/TypeParameterCommonizerTest.kt | 4 +- .../core/TypeParameterListCommonizerTest.kt | 4 +- .../core/ValueParameterCommonizerTest.kt | 14 +- .../core/ValueParameterListCommonizerTest.kt | 6 +- .../descriptors/commonizer/utils/mocks.kt | 100 ++++++++------ 32 files changed, 407 insertions(+), 266 deletions(-) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/Parameters.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/Parameters.kt index 34fa2041177..c31c8fc5ef4 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/Parameters.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/Parameters.kt @@ -15,6 +15,7 @@ class Parameters( private val _targetProviders = LinkedHashMap() val targetProviders: List get() = _targetProviders.values.toList() + val sharedTarget: SharedTarget get() = SharedTarget(_targetProviders.keys) // common module dependencies (ex: Kotlin stdlib) var dependeeModulesProvider: ModulesProvider? = null diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AbstractFunctionOrPropertyCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AbstractFunctionOrPropertyCommonizer.kt index 818b66989a3..659ddb0d7f6 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AbstractFunctionOrPropertyCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AbstractFunctionOrPropertyCommonizer.kt @@ -9,19 +9,19 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED import org.jetbrains.kotlin.descriptors.commonizer.cir.CirFunctionOrProperty -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.name.Name abstract class AbstractFunctionOrPropertyCommonizer( - cache: CirClassifiersCache + classifiers: CirKnownClassifiers ) : AbstractStandardCommonizer() { protected lateinit var name: Name protected val modality = ModalityCommonizer() protected val visibility = VisibilityCommonizer.lowering() - protected val extensionReceiver = ExtensionReceiverCommonizer(cache) - protected val returnType = TypeCommonizer(cache) + protected val extensionReceiver = ExtensionReceiverCommonizer(classifiers) + protected val returnType = TypeCommonizer(classifiers) protected lateinit var kind: CallableMemberDescriptor.Kind - protected val typeParameters = TypeParameterListCommonizer(cache) + protected val typeParameters = TypeParameterListCommonizer(classifiers) override fun initialize(first: T) { name = first.name diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt index f172172befe..a33598b081d 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt @@ -12,14 +12,14 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirValueParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirValueParameterFactory import org.jetbrains.kotlin.descriptors.commonizer.core.CallableValueParametersCommonizer.CallableToPatch.Companion.doNothing import org.jetbrains.kotlin.descriptors.commonizer.core.CallableValueParametersCommonizer.CallableToPatch.Companion.patchCallables -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapIndexed import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.descriptors.commonizer.utils.isObjCInteropCallableAnnotation import org.jetbrains.kotlin.name.Name class CallableValueParametersCommonizer( - cache: CirClassifiersCache + classifiers: CirKnownClassifiers ) : Commonizer { class Result( val hasStableParameterNames: Boolean, @@ -118,7 +118,7 @@ class CallableValueParametersCommonizer( } } - private val valueParameters = ValueParameterListCommonizer(cache) + private val valueParameters = ValueParameterListCommonizer(classifiers) private val callables: MutableList = mutableListOf() private var hasStableParameterNames = true private var valueParameterNames: ValueParameterNames? = null diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt index 2030d50752f..577e4a8e8b8 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt @@ -8,13 +8,13 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.name.Name -class ClassCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +class ClassCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var name: Name private lateinit var kind: ClassKind - private val typeParameters = TypeParameterListCommonizer(cache) + private val typeParameters = TypeParameterListCommonizer(classifiers) private val modality = ModalityCommonizer() private val visibility = VisibilityCommonizer.equalizing() private var isInner = false diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassConstructorCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassConstructorCommonizer.kt index 7b1f595e4c0..b1b42efa23c 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassConstructorCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassConstructorCommonizer.kt @@ -9,13 +9,15 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassConstructor import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassConstructorFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirContainingClassDetailsFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers -class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +class ClassConstructorCommonizer( + classifiers: CirKnownClassifiers +) : AbstractStandardCommonizer() { private var isPrimary = false private val visibility = VisibilityCommonizer.equalizing() - private val typeParameters = TypeParameterListCommonizer(cache) - private val valueParameters = CallableValueParametersCommonizer(cache) + private val typeParameters = TypeParameterListCommonizer(classifiers) + private val valueParameters = CallableValueParametersCommonizer(classifiers) override fun commonizationResult(): CirClassConstructor { val valueParameters = valueParameters.result diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CommonizationVisitor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CommonizationVisitor.kt index ba95c068dd1..69fac2e3e63 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CommonizationVisitor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CommonizationVisitor.kt @@ -11,10 +11,9 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.* import org.jetbrains.kotlin.descriptors.commonizer.utils.CommonizedGroup import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapNotNull import org.jetbrains.kotlin.descriptors.commonizer.utils.internedClassId -import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderStandardKotlinPackages internal class CommonizationVisitor( - private val cache: CirClassifiersCache, + private val classifiers: CirKnownClassifiers, private val root: CirRootNode ) : CirNodeVisitor { override fun visitRootNode(node: CirRootNode, data: Unit) { @@ -88,7 +87,7 @@ internal class CommonizationVisitor( val companionObjectName = node.targetDeclarations.mapTo(HashSet()) { it!!.companion }.singleOrNull() if (companionObjectName != null) { val companionObjectClassId = internedClassId(node.classId, companionObjectName) - val companionObjectNode = cache.classNode(companionObjectClassId) + val companionObjectNode = classifiers.commonized.classNode(companionObjectClassId) ?: error("Can't find companion object with class ID $companionObjectClassId") if (companionObjectNode.commonDeclaration() != null) { @@ -129,10 +128,10 @@ internal class CommonizationVisitor( val supertypesMap: MutableMap> = linkedMapOf() // preserve supertype order for ((index, typeAlias) in targetDeclarations.withIndex()) { val expandedClassId = typeAlias!!.expandedType.classifierId - if (expandedClassId.packageFqName.isUnderStandardKotlinPackages) - return null // this case is not supported + if (classifiers.commonDependeeLibraries?.hasClassifier(expandedClassId) == true) + return null // this case is not supported yet - val expandedClassNode = cache.classNode(expandedClassId) ?: return null + val expandedClassNode = classifiers.commonized.classNode(expandedClassId) ?: return null val expandedClass = expandedClassNode.targetDeclarations[index] ?: error("Can't find expanded class with class ID $expandedClassId and index $index for type alias $classId") @@ -148,7 +147,7 @@ internal class CommonizationVisitor( if (supertypesMap.isNullOrEmpty()) emptyList() else - supertypesMap.values.compactMapNotNull { supertypesGroup -> commonize(supertypesGroup, TypeCommonizer(cache)) } + supertypesMap.values.compactMapNotNull { supertypesGroup -> commonize(supertypesGroup, TypeCommonizer(classifiers)) } ) } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizer.kt index ba96bda8776..231e080b2ae 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizer.kt @@ -8,11 +8,11 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirExtensionReceiver import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirExtensionReceiverFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers -class ExtensionReceiverCommonizer(cache: CirClassifiersCache) : +class ExtensionReceiverCommonizer(classifiers: CirKnownClassifiers) : AbstractNullableCommonizer( - wrappedCommonizerFactory = { TypeCommonizer(cache) }, + wrappedCommonizerFactory = { TypeCommonizer(classifiers) }, extractor = { it.type }, builder = { receiverType -> CirExtensionReceiverFactory.create( diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/FunctionCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/FunctionCommonizer.kt index d58532ba8b6..3c301a3fcaa 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/FunctionCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/FunctionCommonizer.kt @@ -7,12 +7,12 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirFunction import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirFunctionFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers -class FunctionCommonizer(cache: CirClassifiersCache) : AbstractFunctionOrPropertyCommonizer(cache) { +class FunctionCommonizer(classifiers: CirKnownClassifiers) : AbstractFunctionOrPropertyCommonizer(classifiers) { private val annotations = AnnotationsCommonizer() private val modifiers = FunctionModifiersCommonizer() - private val valueParameters = CallableValueParametersCommonizer(cache) + private val valueParameters = CallableValueParametersCommonizer(classifiers) override fun commonizationResult(): CirFunction { val valueParameters = valueParameters.result diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/PropertyCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/PropertyCommonizer.kt index 4712d2e2095..74e25eea2d4 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/PropertyCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/PropertyCommonizer.kt @@ -9,10 +9,10 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirProperty import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirPropertyFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirPropertyGetterFactory import org.jetbrains.kotlin.descriptors.commonizer.core.PropertyCommonizer.ConstCommonizationState.* -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.resolve.constants.ConstantValue -class PropertyCommonizer(cache: CirClassifiersCache) : AbstractFunctionOrPropertyCommonizer(cache) { +class PropertyCommonizer(classifiers: CirKnownClassifiers) : AbstractFunctionOrPropertyCommonizer(classifiers) { private val setter = PropertySetterCommonizer() private var isExternal = true private lateinit var constCommonizationState: ConstCommonizationState diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt index dcbe9bd1c50..00d9beee173 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt @@ -10,8 +10,7 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeAliasFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache -import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderStandardKotlinPackages +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.name.Name /** @@ -24,9 +23,9 @@ import org.jetbrains.kotlin.name.Name * Tertiary (backup) branch: * - Produce an "expect class" for "common" fragment and the corresponding "actual typealias" declarations for each platform fragment. */ -class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { - private val primary = TypeAliasShortCircuitingCommonizer(cache) - private val secondary = TypeAliasLiftingUpCommonizer(cache) +class TypeAliasCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { + private val primary = TypeAliasShortCircuitingCommonizer(classifiers) + private val secondary = TypeAliasLiftingUpCommonizer(classifiers) private val tertiary = TypeAliasExpectClassCommonizer() override fun commonizationResult(): CirClassifier = primary.resultOrNull ?: secondary.resultOrNull ?: tertiary.result @@ -43,11 +42,13 @@ class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommoniz } } -private class TypeAliasShortCircuitingCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +private class TypeAliasShortCircuitingCommonizer( + private val classifiers: CirKnownClassifiers +) : AbstractStandardCommonizer() { private lateinit var name: Name - private val typeParameters = TypeParameterListCommonizer(cache) + private val typeParameters = TypeParameterListCommonizer(classifiers) private lateinit var underlyingType: CirClassOrTypeAliasType - private val expandedType = TypeCommonizer(cache) + private val expandedType = TypeCommonizer(classifiers) private val visibility = VisibilityCommonizer.lowering() override fun commonizationResult() = CirTypeAliasFactory.create( @@ -75,7 +76,7 @@ private class TypeAliasShortCircuitingCommonizer(cache: CirClassifiersCache) : A private tailrec fun computeCommonizedUnderlyingType(underlyingType: CirClassOrTypeAliasType): CirClassOrTypeAliasType { return when (underlyingType) { is CirClassType -> underlyingType - is CirTypeAliasType -> if (underlyingType.classifierId.packageFqName.isUnderStandardKotlinPackages) + is CirTypeAliasType -> if (classifiers.commonDependeeLibraries?.hasClassifier(underlyingType.classifierId) == true) underlyingType else computeCommonizedUnderlyingType(underlyingType.underlyingType) @@ -83,10 +84,10 @@ private class TypeAliasShortCircuitingCommonizer(cache: CirClassifiersCache) : A } } -private class TypeAliasLiftingUpCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +private class TypeAliasLiftingUpCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var name: Name - private val typeParameters = TypeParameterListCommonizer(cache) - private val underlyingType = TypeCommonizer(cache) + private val typeParameters = TypeParameterListCommonizer(classifiers) + private val underlyingType = TypeCommonizer(classifiers) private val visibility = VisibilityCommonizer.lowering() override fun commonizationResult(): CirTypeAlias { diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt index 003a5b38663..b0e0d909ed4 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt @@ -10,13 +10,12 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.FAILURE_MISSING_IN_SOME_TARGET import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.SUCCESS_FROM_DEPENDEE_LIBRARY -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderKotlinNativeSyntheticPackages -import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderStandardKotlinPackages import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.types.Variance -class TypeCommonizer(private val cache: CirClassifiersCache) : AbstractStandardCommonizer() { +class TypeCommonizer(private val classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var wrapped: Commonizer<*, CirType> override fun commonizationResult() = wrapped.result @@ -24,10 +23,10 @@ class TypeCommonizer(private val cache: CirClassifiersCache) : AbstractStandardC override fun initialize(first: CirType) { @Suppress("UNCHECKED_CAST") wrapped = when (first) { - is CirClassType -> ClassTypeCommonizer(cache) - is CirTypeAliasType -> TypeAliasTypeCommonizer(cache) + is CirClassType -> ClassTypeCommonizer(classifiers) + is CirTypeAliasType -> TypeAliasTypeCommonizer(classifiers) is CirTypeParameterType -> TypeParameterTypeCommonizer() - is CirFlexibleType -> FlexibleTypeCommonizer(cache) + is CirFlexibleType -> FlexibleTypeCommonizer(classifiers) } as Commonizer<*, CirType> } @@ -39,11 +38,11 @@ class TypeCommonizer(private val cache: CirClassifiersCache) : AbstractStandardC } } -private class ClassTypeCommonizer(private val cache: CirClassifiersCache) : AbstractStandardCommonizer() { +private class ClassTypeCommonizer(private val classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var classId: ClassId - private val outerType = OuterClassTypeCommonizer(cache) + private val outerType = OuterClassTypeCommonizer(classifiers) private lateinit var anyVisibility: DescriptorVisibility - private val arguments = TypeArgumentListCommonizer(cache) + private val arguments = TypeArgumentListCommonizer(classifiers) private var isMarkedNullable = false override fun commonizationResult() = CirTypeFactory.createClassType( @@ -68,22 +67,22 @@ private class ClassTypeCommonizer(private val cache: CirClassifiersCache) : Abst isMarkedNullable == next.isMarkedNullable && classId == next.classifierId && outerType.commonizeWith(next.outerType) - && commonizeClass(classId, cache) + && commonizeClass(classId, classifiers) && arguments.commonizeWith(next.arguments) } -private class OuterClassTypeCommonizer(cache: CirClassifiersCache) : +private class OuterClassTypeCommonizer(classifiers: CirKnownClassifiers) : AbstractNullableCommonizer( - wrappedCommonizerFactory = { ClassTypeCommonizer(cache) }, + wrappedCommonizerFactory = { ClassTypeCommonizer(classifiers) }, extractor = { it }, builder = { it } ) -private class TypeAliasTypeCommonizer(private val cache: CirClassifiersCache) : +private class TypeAliasTypeCommonizer(private val classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var typeAliasId: ClassId - private val arguments = TypeArgumentListCommonizer(cache) + private val arguments = TypeArgumentListCommonizer(classifiers) private var isMarkedNullable = false private var commonizedTypeBuilder: CommonizedTypeAliasTypeBuilder? = null // null means not selected yet @@ -104,7 +103,7 @@ private class TypeAliasTypeCommonizer(private val cache: CirClassifiersCache) : return false if (commonizedTypeBuilder == null) { - val answer = commonizeTypeAlias(typeAliasId, cache) + val answer = commonizeTypeAlias(typeAliasId, classifiers) if (!answer.commonized) return false @@ -176,9 +175,9 @@ private class TypeParameterTypeCommonizer : AbstractStandardCommonizer() { - private val lowerBound = TypeCommonizer(cache) - private val upperBound = TypeCommonizer(cache) +private class FlexibleTypeCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { + private val lowerBound = TypeCommonizer(classifiers) + private val upperBound = TypeCommonizer(classifiers) override fun commonizationResult() = CirFlexibleType( lowerBound = lowerBound.result as CirSimpleType, @@ -191,10 +190,12 @@ private class FlexibleTypeCommonizer(cache: CirClassifiersCache) : AbstractStand lowerBound.commonizeWith(next.lowerBound) && upperBound.commonizeWith(next.upperBound) } -private class TypeArgumentCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +private class TypeArgumentCommonizer( + classifiers: CirKnownClassifiers +) : AbstractStandardCommonizer() { private var isStar = false private lateinit var projectionKind: Variance - private val type = TypeCommonizer(cache) + private val type = TypeCommonizer(classifiers) override fun commonizationResult() = if (isStar) CirStarTypeProjection else CirTypeProjectionImpl( projectionKind = projectionKind, @@ -214,16 +215,15 @@ private class TypeArgumentCommonizer(cache: CirClassifiersCache) : AbstractStand } } -private class TypeArgumentListCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer( - singleElementCommonizerFactory = { TypeArgumentCommonizer(cache) } +private class TypeArgumentListCommonizer(classifiers: CirKnownClassifiers) : AbstractListCommonizer( + singleElementCommonizerFactory = { TypeArgumentCommonizer(classifiers) } ) -private fun commonizeClass(classId: ClassId, cache: CirClassifiersCache): Boolean { - val packageFqName = classId.packageFqName - if (packageFqName.isUnderStandardKotlinPackages) { - // The class is from Kotlin stdlib. Already commonized. +private fun commonizeClass(classId: ClassId, classifiers: CirKnownClassifiers): Boolean { + if (classifiers.commonDependeeLibraries?.hasClassifier(classId) == true) { + // The class is from common fragment of dependee library (ex: stdlib). Already commonized. return true - } else if (packageFqName.isUnderKotlinNativeSyntheticPackages) { + } else if (classId.packageFqName.isUnderKotlinNativeSyntheticPackages) { // C/Obj-C forward declarations are: // - Either resolved to real classes/interfaces from other interop libraries (which are generated by C-interop tool and // are known to have modality/visibility/other attributes to successfully pass commonization). @@ -232,12 +232,12 @@ private fun commonizeClass(classId: ClassId, cache: CirClassifiersCache): Boolea return true } - return when (val node = cache.classNode(classId)) { + return when (val node = classifiers.commonized.classNode(classId)) { null -> { // No node means that the class was not subject for commonization. // - Either it is missing in certain targets at all => not commonized. // - Or it is a known forward declaration => consider it as commonized. - cache.isExportedForwardDeclaration(classId) + classifiers.forwardDeclarations.isExportedForwardDeclaration(classId) } else -> { // Common declaration in node is not null -> successfully commonized. @@ -246,14 +246,13 @@ private fun commonizeClass(classId: ClassId, cache: CirClassifiersCache): Boolea } } -private fun commonizeTypeAlias(typeAliasId: ClassId, cache: CirClassifiersCache): CommonizedTypeAliasAnswer { - val packageFqName = typeAliasId.packageFqName - if (packageFqName.isUnderStandardKotlinPackages) { - // The type alias is from Kotlin stdlib. Already commonized. +private fun commonizeTypeAlias(typeAliasId: ClassId, classifiers: CirKnownClassifiers): CommonizedTypeAliasAnswer { + if (classifiers.commonDependeeLibraries?.hasClassifier(typeAliasId) == true) { + // The type alias is from common fragment of dependee library (ex: stdlib). Already commonized. return SUCCESS_FROM_DEPENDEE_LIBRARY } - return when (val node = cache.typeAliasNode(typeAliasId)) { + return when (val node = classifiers.commonized.typeAliasNode(typeAliasId)) { null -> { // No node means that the type alias was not subject for commonization. It is missing in some target(s) => not commonized. FAILURE_MISSING_IN_SOME_TARGET diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizer.kt index 545d9f71d58..70aa038131e 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizer.kt @@ -8,15 +8,15 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeParameterFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance -class TypeParameterCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +class TypeParameterCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var name: Name private var isReified = false private lateinit var variance: Variance - private val upperBounds = TypeParameterUpperBoundsCommonizer(cache) + private val upperBounds = TypeParameterUpperBoundsCommonizer(classifiers) override fun commonizationResult() = CirTypeParameterFactory.create( annotations = emptyList(), @@ -39,6 +39,6 @@ class TypeParameterCommonizer(cache: CirClassifiersCache) : AbstractStandardComm && upperBounds.commonizeWith(next.upperBounds) } -private class TypeParameterUpperBoundsCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer( - singleElementCommonizerFactory = { TypeCommonizer(cache) } +private class TypeParameterUpperBoundsCommonizer(classifiers: CirKnownClassifiers) : AbstractListCommonizer( + singleElementCommonizerFactory = { TypeCommonizer(classifiers) } ) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizer.kt index b4807a76611..6c84320e519 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizer.kt @@ -6,8 +6,8 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers -class TypeParameterListCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer( - singleElementCommonizerFactory = { TypeParameterCommonizer(cache) } +class TypeParameterListCommonizer(classifiers: CirKnownClassifiers) : AbstractListCommonizer( + singleElementCommonizerFactory = { TypeParameterCommonizer(classifiers) } ) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizer.kt index 4306b80f27c..1df5409fee9 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizer.kt @@ -8,13 +8,13 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.CirValueParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirValueParameterFactory -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.descriptors.commonizer.utils.isNull import org.jetbrains.kotlin.name.Name -class ValueParameterCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer() { +class ValueParameterCommonizer(classifiers: CirKnownClassifiers) : AbstractStandardCommonizer() { private lateinit var name: Name - private val returnType = TypeCommonizer(cache) + private val returnType = TypeCommonizer(classifiers) private var varargElementType: CirType? = null private var isCrossinline = true private var isNoinline = true diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterListCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterListCommonizer.kt index ee093d06750..7293af81380 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterListCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterListCommonizer.kt @@ -6,11 +6,11 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirValueParameter -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers import org.jetbrains.kotlin.name.Name -class ValueParameterListCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer( - singleElementCommonizerFactory = { ValueParameterCommonizer(cache) } +class ValueParameterListCommonizer(classifiers: CirKnownClassifiers) : AbstractListCommonizer( + singleElementCommonizerFactory = { ValueParameterCommonizer(classifiers) } ) { fun overwriteNames(names: List) { forEachSingleElementCommonizer { index, singleElementCommonizer -> diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/facade.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/facade.kt index f65c1876028..d61136450f5 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/facade.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/facade.kt @@ -9,9 +9,10 @@ import org.jetbrains.kotlin.descriptors.commonizer.builder.DeclarationsBuilderVi import org.jetbrains.kotlin.descriptors.commonizer.builder.DeclarationsBuilderVisitor2 import org.jetbrains.kotlin.descriptors.commonizer.builder.createGlobalBuilderComponents import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizationVisitor -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirTreeMerger -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.DefaultCirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.* +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirTreeMerger.CirTreeMergeResult import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.storage.StorageManager fun runCommonization(parameters: Parameters): Result { if (!parameters.hasAnythingToCommonize()) @@ -19,14 +20,8 @@ fun runCommonization(parameters: Parameters): Result { val storageManager = LockBasedStorageManager("Declaration descriptors commonization") - // build merged tree: - val cache = DefaultCirClassifiersCache() - val mergeResult = CirTreeMerger(storageManager, cache, parameters).merge() - - // commonize: + val mergeResult = mergeAndCommonize(storageManager, parameters) val mergedTree = mergeResult.root - mergedTree.accept(CommonizationVisitor(cache, mergedTree), Unit) - parameters.progressLogger?.invoke("Commonized declarations") // build resulting descriptors: val components = mergedTree.createGlobalBuilderComponents(storageManager, parameters) @@ -51,3 +46,25 @@ fun runCommonization(parameters: Parameters): Result { return Result.Commonized(modulesByTargets) } + +private fun mergeAndCommonize(storageManager: StorageManager, parameters: Parameters): CirTreeMergeResult { + // build merged tree: + val classifiers = CirKnownClassifiers( + commonized = CirCommonizedClassifiers.default(), + forwardDeclarations = CirForwardDeclarations.default(), + dependeeLibraries = mapOf( + // for now, supply only common dependee libraries (ex: Kotlin stdlib) + parameters.sharedTarget to CirProvidedClassifiers.fromModules(storageManager) { + parameters.dependeeModulesProvider?.loadModules(emptyList())?.values.orEmpty() + } + ) + ) + val mergeResult = CirTreeMerger(storageManager, classifiers, parameters).merge() + + // commonize: + val mergedTree = mergeResult.root + mergedTree.accept(CommonizationVisitor(classifiers, mergedTree), Unit) + parameters.progressLogger?.invoke("Commonized declarations") + + return mergeResult +} diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirClassifiersCache.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirClassifiersCache.kt index 4b22c5d310c..bc5175d92c0 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirClassifiersCache.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirClassifiersCache.kt @@ -7,42 +7,122 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree import gnu.trove.THashMap import gnu.trove.THashSet +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.commonizer.SharedTarget +import org.jetbrains.kotlin.descriptors.commonizer.Target +import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderKotlinNativeSyntheticPackages +import org.jetbrains.kotlin.descriptors.commonizer.utils.resolveClassOrTypeAlias import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.scopes.MemberScope +import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.storage.getValue -interface CirClassifiersCache { - fun isExportedForwardDeclaration(classId: ClassId): Boolean +class CirKnownClassifiers( + val commonized: CirCommonizedClassifiers, + val forwardDeclarations: CirForwardDeclarations, + val dependeeLibraries: Map +) { + // a shortcut for fast access + val commonDependeeLibraries: CirProvidedClassifiers? = dependeeLibraries.filterKeys { it is SharedTarget }.values.singleOrNull() +} +interface CirCommonizedClassifiers { + /* Accessors */ fun classNode(classId: ClassId): CirClassNode? fun typeAliasNode(typeAliasId: ClassId): CirTypeAliasNode? - fun addExportedForwardDeclaration(classId: ClassId) - + /* Mutators */ fun addClassNode(classId: ClassId, node: CirClassNode) fun addTypeAliasNode(typeAliasId: ClassId, node: CirTypeAliasNode) -} -class DefaultCirClassifiersCache : CirClassifiersCache { - private val exportedForwardDeclarations = THashSet() - private val classNodes = THashMap() - private val typeAliases = THashMap() + companion object { + fun default() = object : CirCommonizedClassifiers { + private val classNodes = THashMap() + private val typeAliases = THashMap() - override fun isExportedForwardDeclaration(classId: ClassId) = classId in exportedForwardDeclarations - override fun classNode(classId: ClassId) = classNodes[classId] - override fun typeAliasNode(typeAliasId: ClassId) = typeAliases[typeAliasId] + override fun classNode(classId: ClassId) = classNodes[classId] + override fun typeAliasNode(typeAliasId: ClassId) = typeAliases[typeAliasId] - override fun addExportedForwardDeclaration(classId: ClassId) { - check(!classId.packageFqName.isUnderKotlinNativeSyntheticPackages) - exportedForwardDeclarations += classId - } + override fun addClassNode(classId: ClassId, node: CirClassNode) { + val oldNode = classNodes.put(classId, node) + check(oldNode == null) { "Rewriting class node $classId" } + } - override fun addClassNode(classId: ClassId, node: CirClassNode) { - val oldNode = classNodes.put(classId, node) - check(oldNode == null) { "Rewriting class node $classId" } - } - - override fun addTypeAliasNode(typeAliasId: ClassId, node: CirTypeAliasNode) { - val oldNode = typeAliases.put(typeAliasId, node) - check(oldNode == null) { "Rewriting type alias node $typeAliasId" } + override fun addTypeAliasNode(typeAliasId: ClassId, node: CirTypeAliasNode) { + val oldNode = typeAliases.put(typeAliasId, node) + check(oldNode == null) { "Rewriting type alias node $typeAliasId" } + } + } + } +} + +interface CirForwardDeclarations { + /* Accessors */ + fun isExportedForwardDeclaration(classId: ClassId): Boolean + + /* Mutators */ + fun addExportedForwardDeclaration(classId: ClassId) + + companion object { + fun default() = object : CirForwardDeclarations { + private val exportedForwardDeclarations = THashSet() + + override fun isExportedForwardDeclaration(classId: ClassId) = classId in exportedForwardDeclarations + + override fun addExportedForwardDeclaration(classId: ClassId) { + check(!classId.packageFqName.isUnderKotlinNativeSyntheticPackages) + exportedForwardDeclarations += classId + } + } + } +} + +interface CirProvidedClassifiers { + fun hasClassifier(classifierId: ClassId): Boolean + + // TODO: implement later + //fun classifier(classifierId: ClassId): Any? + + companion object { + // N.B. This is suboptimal implementation. It will be replaced by another implementation that will + // retrieve classifier information directly from the metadata. + fun fromModules(storageManager: StorageManager, modules: () -> Collection) = object : CirProvidedClassifiers { + private val nonEmptyMemberScopes: Map by storageManager.createLazyValue { + THashMap().apply { + for (module in modules()) { + module.collectNonEmptyPackageMemberScopes(probeRootPackageForEmptiness = true) { packageFqName, memberScope -> + this[packageFqName.intern()] = memberScope + } + } + } + } + + private val presentClassifiers = THashSet() + private val missingClassifiers = THashSet() + + override fun hasClassifier(classifierId: ClassId): Boolean { + val relativeClassName: FqName = classifierId.relativeClassName + if (relativeClassName.isRoot) + return false + + val packageFqName = classifierId.packageFqName + val memberScope = nonEmptyMemberScopes[packageFqName] ?: return false + + return when (classifierId) { + in presentClassifiers -> true + in missingClassifiers -> false + else -> { + val found = memberScope.resolveClassOrTypeAlias(relativeClassName) != null + when (found) { + true -> presentClassifiers += classifierId + false -> missingClassifiers += classifierId + } + found + } + } + } + } } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt index fc244b8ec1f..82b43b162e6 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt @@ -48,7 +48,7 @@ import org.jetbrains.kotlin.storage.StorageManager */ class CirTreeMerger( private val storageManager: StorageManager, - private val cache: CirClassifiersCache, + private val classifiers: CirKnownClassifiers, private val parameters: Parameters ) { class CirTreeMergeResult( @@ -183,7 +183,7 @@ class CirTreeMerger( parentCommonDeclaration: NullableLazyValue<*>? ) { val propertyNode: CirPropertyNode = properties.getOrPut(PropertyApproximationKey(propertyDescriptor)) { - buildPropertyNode(storageManager, size, cache, parentCommonDeclaration) + buildPropertyNode(storageManager, size, classifiers, parentCommonDeclaration) } propertyNode.targetDeclarations[targetIndex] = CirPropertyFactory.create(propertyDescriptor) } @@ -195,7 +195,7 @@ class CirTreeMerger( parentCommonDeclaration: NullableLazyValue<*>? ) { val functionNode: CirFunctionNode = functions.getOrPut(FunctionApproximationKey(functionDescriptor)) { - buildFunctionNode(storageManager, size, cache, parentCommonDeclaration) + buildFunctionNode(storageManager, size, classifiers, parentCommonDeclaration) } functionNode.targetDeclarations[targetIndex] = CirFunctionFactory.create(functionDescriptor) } @@ -211,7 +211,7 @@ class CirTreeMerger( val classId = classIdFunction(className) val classNode: CirClassNode = classes.getOrPut(className) { - buildClassNode(storageManager, size, cache, parentCommonDeclaration, classId) + buildClassNode(storageManager, size, classifiers, parentCommonDeclaration, classId) } classNode.targetDeclarations[targetIndex] = CirClassFactory.create(classDescriptor) @@ -246,7 +246,7 @@ class CirTreeMerger( parentCommonDeclaration: NullableLazyValue<*>? ) { val constructorNode: CirClassConstructorNode = constructors.getOrPut(ConstructorApproximationKey(constructorDescriptor)) { - buildClassConstructorNode(storageManager, size, cache, parentCommonDeclaration) + buildClassConstructorNode(storageManager, size, classifiers, parentCommonDeclaration) } constructorNode.targetDeclarations[targetIndex] = CirClassConstructorFactory.create(constructorDescriptor) } @@ -261,7 +261,7 @@ class CirTreeMerger( val typeAliasClassId = internedClassId(packageFqName, typeAliasName) val typeAliasNode: CirTypeAliasNode = typeAliases.getOrPut(typeAliasName) { - buildTypeAliasNode(storageManager, size, cache, typeAliasClassId) + buildTypeAliasNode(storageManager, size, classifiers, typeAliasClassId) } typeAliasNode.targetDeclarations[targetIndex] = CirTypeAliasFactory.create(typeAliasDescriptor) } @@ -274,7 +274,7 @@ class CirTreeMerger( exportForwardDeclarations.forEach { classFqName -> // Class has synthetic package FQ name (cnames/objcnames). Need to transfer it to the main package. val className = Name.identifier(classFqName.substringAfterLast('.')).intern() - cache.addExportedForwardDeclaration(internedClassId(mainPackageFqName, className)) + classifiers.forwardDeclarations.addExportedForwardDeclaration(internedClassId(mainPackageFqName, className)) } } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/collectors.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/collectors.kt index 1d1916a2382..5dd1ca3718e 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/collectors.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/collectors.kt @@ -64,18 +64,24 @@ internal inline fun FunctionCollector( } // collects member scopes for every non-empty package provided by this module -internal fun ModuleDescriptor.collectNonEmptyPackageMemberScopes(collector: (FqName, MemberScope) -> Unit) { +internal fun ModuleDescriptor.collectNonEmptyPackageMemberScopes( + probeRootPackageForEmptiness: Boolean = false, // false is the default as probing might be expensive and is not always necessary + collector: (FqName, MemberScope) -> Unit +) { // we don's need to process fragments from other modules which are the dependencies of this module, so // let's use the appropriate package fragment provider val packageFragmentProvider = this.packageFragmentProvider fun recurse(packageFqName: FqName) { - val ownPackageFragments = packageFragmentProvider.packageFragments(packageFqName) - val ownPackageMemberScopes = ownPackageFragments.asSequence() + val probeForEmptiness = probeRootPackageForEmptiness && packageFqName.isRoot + + val ownPackageMemberScopes = packageFragmentProvider.packageFragments(packageFqName) + .asSequence() .filter { it !is ExportedForwardDeclarationsPackageFragmentDescriptor && it !is ClassifierAliasingPackageFragmentDescriptor } .map { it.getMemberScope() } .filter { it != MemberScope.Empty } - .toList(ownPackageFragments.size) + .filter { !probeForEmptiness || it.getContributedDescriptors().isNotEmpty() } + .toList() if (ownPackageMemberScopes.isNotEmpty()) { // don't include subpackages into chained member scope diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/nodeBuilders.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/nodeBuilders.kt index bf96eba7df6..4407ff92f0b 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/nodeBuilders.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/nodeBuilders.kt @@ -53,44 +53,44 @@ internal fun buildPackageNode( internal fun buildPropertyNode( storageManager: StorageManager, size: Int, - cache: CirClassifiersCache, + classifiers: CirKnownClassifiers, parentCommonDeclaration: NullableLazyValue<*>? ): CirPropertyNode = buildNode( storageManager = storageManager, size = size, parentCommonDeclaration = parentCommonDeclaration, - commonizerProducer = { PropertyCommonizer(cache) }, + commonizerProducer = { PropertyCommonizer(classifiers) }, nodeProducer = ::CirPropertyNode ) internal fun buildFunctionNode( storageManager: StorageManager, size: Int, - cache: CirClassifiersCache, + classifiers: CirKnownClassifiers, parentCommonDeclaration: NullableLazyValue<*>? ): CirFunctionNode = buildNode( storageManager = storageManager, size = size, parentCommonDeclaration = parentCommonDeclaration, - commonizerProducer = { FunctionCommonizer(cache) }, + commonizerProducer = { FunctionCommonizer(classifiers) }, nodeProducer = ::CirFunctionNode ) internal fun buildClassNode( storageManager: StorageManager, size: Int, - cache: CirClassifiersCache, + classifiers: CirKnownClassifiers, parentCommonDeclaration: NullableLazyValue<*>?, classId: ClassId ): CirClassNode = buildNode( storageManager = storageManager, size = size, parentCommonDeclaration = parentCommonDeclaration, - commonizerProducer = { ClassCommonizer(cache) }, + commonizerProducer = { ClassCommonizer(classifiers) }, recursionMarker = CirClassRecursionMarker, nodeProducer = { targetDeclarations, commonDeclaration -> CirClassNode(targetDeclarations, commonDeclaration, classId).also { - cache.addClassNode(classId, it) + classifiers.commonized.addClassNode(classId, it) } } ) @@ -98,29 +98,29 @@ internal fun buildClassNode( internal fun buildClassConstructorNode( storageManager: StorageManager, size: Int, - cache: CirClassifiersCache, + classifiers: CirKnownClassifiers, parentCommonDeclaration: NullableLazyValue<*>? ): CirClassConstructorNode = buildNode( storageManager = storageManager, size = size, parentCommonDeclaration = parentCommonDeclaration, - commonizerProducer = { ClassConstructorCommonizer(cache) }, + commonizerProducer = { ClassConstructorCommonizer(classifiers) }, nodeProducer = ::CirClassConstructorNode ) internal fun buildTypeAliasNode( storageManager: StorageManager, size: Int, - cache: CirClassifiersCache, + classifiers: CirKnownClassifiers, typeAliasId: ClassId ): CirTypeAliasNode = buildNode( storageManager = storageManager, size = size, - commonizerProducer = { TypeAliasCommonizer(cache) }, + commonizerProducer = { TypeAliasCommonizer(classifiers) }, recursionMarker = CirClassifierRecursionMarker, nodeProducer = { targetDeclarations, commonDeclaration -> CirTypeAliasNode(targetDeclarations, commonDeclaration, typeAliasId).also { - cache.addTypeAliasNode(typeAliasId, it) + classifiers.commonized.addTypeAliasNode(typeAliasId, it) } } ) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/constants.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/constants.kt index ef0e920246a..2f5099ac568 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/constants.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/constants.kt @@ -43,8 +43,6 @@ private fun checkConstantSupportedInCommonization( } is AnnotationValue -> { if (allowAnnotationValues) { - if (constantValue.value.fqName?.isUnderStandardKotlinPackages != true) - onError("Only ${constantValue::class.java} const values from Kotlin standard packages are supported, $constantValue at ${location()}") return // OK } // else fail (see below) } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/misc.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/misc.kt index 04e86cd44be..c97431cb6af 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/misc.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/misc.kt @@ -15,12 +15,6 @@ import java.util.Collections.singletonList import java.util.Collections.singletonMap import kotlin.collections.ArrayList -internal fun Sequence.toList(expectedCapacity: Int): List { - val result = ArrayList(expectedCapacity) - toCollection(result) - return result -} - internal infix fun Map.compactConcat(other: Map): Map = when { isEmpty() -> other diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/moduleDescriptor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/moduleDescriptor.kt index 2e1e7715b17..70c754fdc95 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/moduleDescriptor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/moduleDescriptor.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.library.metadata.NativeTypeTransformer import org.jetbrains.kotlin.library.metadata.NullFlexibleTypeDeserializer import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.serialization.konan.impl.KlibResolvedModuleDescriptorsFactoryImpl import org.jetbrains.kotlin.storage.StorageManager @@ -38,29 +39,35 @@ internal fun ModuleDescriptor.resolveClassOrTypeAlias(classId: ClassId): Classif return null return packageFragmentProvider.packageFragments(classId.packageFqName).asSequence().mapNotNull { packageFragment -> - var memberScope = packageFragment.getMemberScope() - - val classifierName = if ('.' in relativeClassName.asString()) { - // resolve member scope of the nested class - relativeClassName.pathSegments().reduce { first, second -> - memberScope = (memberScope.getContributedClassifier( - first, - NoLookupLocation.FOR_ALREADY_TRACKED - ) as? ClassDescriptor)?.unsubstitutedMemberScope ?: return@mapNotNull null - - second - } - } else { - relativeClassName.shortName() - } - - memberScope.getContributedClassifier( - classifierName, - NoLookupLocation.FOR_ALREADY_TRACKED - ) as? ClassifierDescriptorWithTypeParameters + packageFragment.getMemberScope().resolveClassOrTypeAlias(relativeClassName) }.firstOrNull() } +internal fun MemberScope.resolveClassOrTypeAlias(relativeClassName: FqName): ClassifierDescriptorWithTypeParameters? { + var memberScope: MemberScope = this + if (memberScope is MemberScope.Empty) + return null + + val classifierName = if ('.' in relativeClassName.asString()) { + // resolve member scope of the nested class + relativeClassName.pathSegments().reduce { first, second -> + memberScope = (memberScope.getContributedClassifier( + first, + NoLookupLocation.FOR_ALREADY_TRACKED + ) as? ClassDescriptor)?.unsubstitutedMemberScope ?: return null + + second + } + } else { + relativeClassName.shortName() + } + + return memberScope.getContributedClassifier( + classifierName, + NoLookupLocation.FOR_ALREADY_TRACKED + ) as? ClassifierDescriptorWithTypeParameters +} + internal const val MODULE_NAME_PREFIX = "module:" internal val NativeFactories = KlibMetadataFactories(::KonanBuiltIns, NullFlexibleTypeDeserializer, NativeTypeTransformer()) diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt index ed998be02a7..34c052c99dd 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo import org.jetbrains.kotlin.analyzer.common.CommonDependenciesContainer import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory +import org.jetbrains.kotlin.builtins.DefaultBuiltIns import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.CommonConfigurationKeys @@ -174,16 +175,13 @@ private class AnalyzedModuleDependencies( companion object { val EMPTY = AnalyzedModuleDependencies(emptyMap(), emptyList()) - - fun create(regularDependencies: Map, expectByDependencies: List) = - AnalyzedModuleDependencies(regularDependencies.mapValues { listOf(it.value) }, expectByDependencies) } } private class AnalyzedModules( val originalModules: Map, val commonizedModules: Map, - val dependeeModules: Map + val dependeeModules: Map> ) { val leafTargets: Set val sharedTarget: SharedTarget @@ -214,13 +212,13 @@ private class AnalyzedModules( target = leafTarget, builtInsClass = originalModule.builtIns::class.java, builtInsProvider = MockBuiltInsProvider(originalModule.builtIns), - modulesProvider = MockModulesProvider(originalModule), - dependeeModulesProvider = dependeeModules[leafTarget]?.let(::MockModulesProvider) + modulesProvider = MockModulesProvider.create(originalModule), + dependeeModulesProvider = dependeeModules[leafTarget]?.let(MockModulesProvider::create) ) ) } - parameters.dependeeModulesProvider = dependeeModules[sharedTarget]?.let(::MockModulesProvider) + parameters.dependeeModulesProvider = dependeeModules[sharedTarget]?.let(MockModulesProvider::create) return parameters } @@ -230,22 +228,37 @@ private class AnalyzedModules( sourceModuleRoots: SourceModuleRoots, parentDisposable: Disposable ): AnalyzedModules = with(sourceModuleRoots) { - // first, build the modules that are are the dependencies for "original" and "commonized" modules - val dependeeModules = - createModules(sharedTarget, dependeeRoots, AnalyzedModuleDependencies.EMPTY, parentDisposable, isDependeeModule = true) + // phase 1: provide the modules that are the dependencies for "original" and "commonized" modules + val (dependeeModules, dependencies) = createDependeeModules(sharedTarget, dependeeRoots, parentDisposable) - val dependencies = AnalyzedModuleDependencies.create( - regularDependencies = dependeeModules, - expectByDependencies = listOfNotNull(dependeeModules[sharedTarget]) - ) - - // then, build "original" and "commonized" modules + // phase 2: build "original" and "commonized" modules val originalModules = createModules(sharedTarget, originalRoots, dependencies, parentDisposable) val commonizedModules = createModules(sharedTarget, commonizedRoots, dependencies, parentDisposable) return AnalyzedModules(originalModules, commonizedModules, dependeeModules) } + private fun createDependeeModules( + sharedTarget: SharedTarget, + dependeeRoots: Map, + parentDisposable: Disposable + ): Pair>, AnalyzedModuleDependencies> { + val customDependeeModules = + createModules(sharedTarget, dependeeRoots, AnalyzedModuleDependencies.EMPTY, parentDisposable, isDependeeModule = true) + + val stdlibModule = DefaultBuiltIns.Instance.builtInsModule + + val dependeeModules = (sharedTarget.targets + sharedTarget).associateWith { target -> + // prepend stdlib for each target explicitly, so that the commonizer can see symbols from the stdlib + listOfNotNull(stdlibModule, customDependeeModules[target]) + } + + return dependeeModules to AnalyzedModuleDependencies( + regularDependencies = dependeeModules, + expectByDependencies = dependeeModules.getValue(sharedTarget).filter { module -> module !== stdlibModule } + ) + } + private fun createModules( sharedTarget: SharedTarget, moduleRoots: Map, diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/CommonizerFacadeTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/CommonizerFacadeTest.kt index b8471e92d08..a5cfecb9193 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/CommonizerFacadeTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/CommonizerFacadeTest.kt @@ -67,7 +67,7 @@ class CommonizerFacadeTest { target = LeafTarget(targetName), builtInsClass = DefaultBuiltIns::class.java, builtInsProvider = BuiltInsProvider.defaultBuiltInsProvider, - modulesProvider = MockModulesProvider(moduleNames), + modulesProvider = MockModulesProvider.create(moduleNames), dependeeModulesProvider = null ) ) diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizerTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizerTest.kt index 430383627cf..80b518f0c26 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizerTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ExtensionReceiverCommonizerTest.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirExtensionReceiver import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirExtensionReceiverFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory -import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS_CACHE +import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType import org.junit.Test @@ -49,7 +49,7 @@ class ExtensionReceiverCommonizerTest : AbstractCommonizerTest() { - private lateinit var cache: CirClassifiersCache + private lateinit var classifiers: CirKnownClassifiers @Before fun initialize() { - cache = DefaultCirClassifiersCache() // reset cache + // reset cache + classifiers = CirKnownClassifiers( + commonized = CirCommonizedClassifiers.default(), + forwardDeclarations = CirForwardDeclarations.default(), + dependeeLibraries = mapOf( + FAKE_SHARED_TARGET to object : CirProvidedClassifiers { + override fun hasClassifier(classifierId: ClassId): Boolean = classifierId.packageFqName.isUnderStandardKotlinPackages + } + ) + ) } @Test @@ -465,11 +477,11 @@ class TypeCommonizerTest : AbstractCommonizerTest() { when (descriptor) { is ClassDescriptor -> { val classId = descriptor.classId ?: error("No class ID for ${descriptor::class.java}, $descriptor") - val node = cache.classNode(classId) { + val node = classifiers.classNode(classId) { buildClassNode( storageManager = LockBasedStorageManager.NO_LOCKS, size = variants.size, - cache = cache, + classifiers = classifiers, parentCommonDeclaration = null, classId = classId ) @@ -478,11 +490,11 @@ class TypeCommonizerTest : AbstractCommonizerTest() { } is TypeAliasDescriptor -> { val typeAliasId = descriptor.classId ?: error("No class ID for ${descriptor::class.java}, $descriptor") - val node = cache.typeAliasNode(typeAliasId) { + val node = classifiers.typeAliasNode(typeAliasId) { buildTypeAliasNode( storageManager = LockBasedStorageManager.NO_LOCKS, size = variants.size, - cache = cache, + classifiers = classifiers, typeAliasId = typeAliasId ) } @@ -517,18 +529,20 @@ class TypeCommonizerTest : AbstractCommonizerTest() { ) } - override fun createCommonizer() = TypeCommonizer(cache) + override fun createCommonizer() = TypeCommonizer(classifiers) - override fun isEqual(a: CirType?, b: CirType?) = (a === b) || (a != null && b != null && areEqual(cache, a, b)) + override fun isEqual(a: CirType?, b: CirType?) = (a === b) || (a != null && b != null && areEqual(classifiers, a, b)) companion object { - fun areEqual(cache: CirClassifiersCache, a: CirType, b: CirType): Boolean = - TypeCommonizer(cache).run { commonizeWith(a) && commonizeWith(b) } + fun areEqual(classifiers: CirKnownClassifiers, a: CirType, b: CirType): Boolean = + TypeCommonizer(classifiers).run { commonizeWith(a) && commonizeWith(b) } - private fun CirClassifiersCache.classNode(classId: ClassId, computation: () -> CirClassNode) = - classNode(classId) ?: computation() + private val FAKE_SHARED_TARGET = SharedTarget(setOf(LeafTarget("a"), LeafTarget("b"))) - private fun CirClassifiersCache.typeAliasNode(typeAliasId: ClassId, computation: () -> CirTypeAliasNode) = - typeAliasNode(typeAliasId) ?: computation() + private fun CirKnownClassifiers.classNode(classId: ClassId, computation: () -> CirClassNode) = + commonized.classNode(classId) ?: computation() + + private fun CirKnownClassifiers.typeAliasNode(typeAliasId: ClassId, computation: () -> CirTypeAliasNode) = + commonized.typeAliasNode(typeAliasId) ?: computation() } } diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizerTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizerTest.kt index a570d4d56bc..3057e51eb13 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizerTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterCommonizerTest.kt @@ -8,14 +8,14 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeParameterFactory -import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS_CACHE +import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance import org.junit.Test class TypeParameterCommonizerTest : AbstractCommonizerTest() { - override fun createCommonizer() = TypeParameterCommonizer(MOCK_CLASSIFIERS_CACHE) + override fun createCommonizer() = TypeParameterCommonizer(MOCK_CLASSIFIERS) @Test fun allAreReified() = doTestSuccess( diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizerTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizerTest.kt index 6e6bf48f5b4..5082a42f7ab 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizerTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeParameterListCommonizerTest.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter -import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS_CACHE +import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS import org.junit.Test class TypeParameterListCommonizerTest : AbstractCommonizerTest, List>() { @@ -108,7 +108,7 @@ class TypeParameterListCommonizerTest : AbstractCommonizerTest): List { diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizerTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizerTest.kt index 18cebf335d0..59d129249de 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizerTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/ValueParameterCommonizerTest.kt @@ -11,8 +11,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirValueParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.core.CirTestValueParameter.Companion.areEqual import org.jetbrains.kotlin.descriptors.commonizer.core.TypeCommonizerTest.Companion.areEqual -import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache -import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS_CACHE +import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers +import org.jetbrains.kotlin.descriptors.commonizer.utils.MOCK_CLASSIFIERS import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType import org.jetbrains.kotlin.name.Name import org.junit.Test @@ -141,10 +141,10 @@ class ValueParameterCommonizerTest : AbstractCommonizerTest, List>() { @@ -150,7 +150,7 @@ class ValueParameterListCommonizerTest : AbstractCommonizerTest?, b: List?): Boolean { if (a === b) @@ -159,7 +159,7 @@ class ValueParameterListCommonizerTest : AbstractCommonizerTest - private val modules: Map - - constructor(moduleNames: Collection) { - moduleInfos = moduleNames.associateWith { name -> fakeModuleInfo(name) } - modules = moduleNames.associateWith { name -> mockEmptyModule("<$name>") } - } - - constructor(module: ModuleDescriptor) { - val name = module.name.asString().removeSurrounding("<", ">") - moduleInfos = mapOf(name to fakeModuleInfo(name)) - modules = mapOf(name to module) - } +internal class MockModulesProvider private constructor( + private val modules: Map, +) : ModulesProvider { + private val moduleInfos: Map = modules.mapValues { (name, _) -> fakeModuleInfo(name) } override fun loadModuleInfos() = moduleInfos override fun loadModules(dependencies: Collection): Map = modules private fun fakeModuleInfo(name: String) = ModuleInfo(name, File("/tmp/commonizer/mocks/$name"), null) + + companion object { + @JvmName("createByModuleNames") + fun create(moduleNames: List) = MockModulesProvider( + moduleNames.associateWith { name -> mockEmptyModule("<$name>") } + ) + + @JvmName("createByModules") + fun create(modules: List) = MockModulesProvider( + modules.associateBy { module -> module.name.strip() } + ) + + @JvmName("createBySingleModule") + fun create(module: ModuleDescriptor) = MockModulesProvider( + mapOf(module.name.strip() to module) + ) + } }