diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirConversions.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirConversions.kt index fee77c15594..99b5e818de8 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirConversions.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirConversions.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities internal fun CirProvidedClassifiers.toCirClassOrTypeAliasTypeOrNull(type: CirProvided.ClassOrTypeAliasType): CirClassOrTypeAliasType? { return when (type) { - is CirProvided.ClassType -> type.toCirClassTypeOrNull() + is CirProvided.ClassType -> toCirClassTypeOrNull(type) is CirProvided.TypeAliasType -> toCirTypeAliasTypeOrNull(type) } } @@ -21,27 +21,36 @@ internal fun CirProvidedClassifiers.toCirTypeAliasTypeOrNull(type: CirProvided.T return CirTypeAliasType.createInterned( typeAliasId = type.classifierId, isMarkedNullable = type.isMarkedNullable, - arguments = type.arguments.map { it.toCirTypeProjection() ?: return null }, + arguments = type.arguments.map { toCirTypeProjection(it) ?: return null }, underlyingType = toCirClassOrTypeAliasTypeOrNull(typeAlias.underlyingType) ?: return null ) } -internal fun CirProvided.ClassType.toCirClassTypeOrNull(): CirClassType? { +internal fun CirProvidedClassifiers.toCirClassTypeOrNull(type: CirProvided.ClassType): CirClassType? { return CirClassType.createInterned( - classId = this.classifierId, - outerType = this.outerType?.let { it.toCirClassTypeOrNull() ?: return null }, - isMarkedNullable = this.isMarkedNullable, - arguments = this.arguments.map { it.toCirTypeProjection() ?: return null }, + classId = type.classifierId, + outerType = type.outerType?.let { toCirClassTypeOrNull(it) ?: return null }, + isMarkedNullable = type.isMarkedNullable, + arguments = type.arguments.map { toCirTypeProjection(it) ?: return null }, visibility = Visibilities.Public, ) } -internal fun CirProvided.TypeProjection.toCirTypeProjection(): CirTypeProjection? { - return when (this) { +internal fun CirProvidedClassifiers.toCirTypeProjection(type: CirProvided.TypeProjection): CirTypeProjection? { + return when (type) { is CirProvided.StarTypeProjection -> CirStarTypeProjection - is CirProvided.RegularTypeProjection -> CirRegularTypeProjection( - projectionKind = variance, - type = (type as? CirProvided.ClassType)?.toCirClassTypeOrNull() ?: return null - ) + is CirProvided.RegularTypeProjection -> toCirRegularTypeProjectionOrNull(type) } +} + +internal fun CirProvidedClassifiers.toCirRegularTypeProjectionOrNull( + projection: CirProvided.RegularTypeProjection +): CirRegularTypeProjection? { + return CirRegularTypeProjection( + projectionKind = projection.variance, + type = when (val type = projection.type) { + is CirProvided.ClassOrTypeAliasType -> toCirClassOrTypeAliasTypeOrNull(type) ?: return null + is CirProvided.TypeParameterType -> CirTypeParameterType.createInterned(type.index, type.isMarkedNullable) + } + ) } \ No newline at end of file diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt index 3bf1c332fd2..7bdcc5b3db7 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt @@ -35,7 +35,7 @@ internal class SimpleCirSupertypesResolver( dependencies.classifier(type.classifierId)?.let { classifier -> if (classifier is CirProvided.Class) { - return supertypesFromProvidedClass(type, classifier) + return dependencies.supertypesFromProvidedClass(type, classifier) } } return emptySet() @@ -47,9 +47,9 @@ internal class SimpleCirSupertypesResolver( .toSet() } - private fun supertypesFromProvidedClass(type: CirClassType, classifier: CirProvided.Class): Set { + private fun CirProvidedClassifiers.supertypesFromProvidedClass(type: CirClassType, classifier: CirProvided.Class): Set { return classifier.supertypes.filterIsInstance() - .mapNotNull { superType -> superType.toCirClassTypeOrNull() } + .mapNotNull { superType -> toCirClassTypeOrNull(superType) } .mapNotNull { superType -> buildSupertypeFromClassifierSupertype(type, superType) } .toSet() } 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 aab575064ab..3c4ea773613 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/ClassOrTypeAliasTypeCommonizer.kt @@ -23,6 +23,7 @@ internal class ClassOrTypeAliasTypeCommonizer( override fun invoke(values: List): CirClassOrTypeAliasType? { if (values.isEmpty()) return null + val expansions = values.map { it.expandedType() } val isMarkedNullable = isMarkedNullableCommonizer.commonize(expansions.map { it.isMarkedNullable }) ?: return null val arguments = TypeArgumentListCommonizer(typeCommonizer).commonize(values.map { it.arguments }) ?: return null @@ -63,7 +64,8 @@ internal class ClassOrTypeAliasTypeCommonizer( arguments = arguments, isMarkedNullable = isMarkedNullable, underlyingType = classifiers.commonDependencies - .toCirClassOrTypeAliasTypeOrNull(dependencyClassifier.underlyingType) ?: return null + .toCirClassOrTypeAliasTypeOrNull(dependencyClassifier.underlyingType) + ?.withParentArguments(arguments, isMarkedNullable) ?: return null ) else -> Unit diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/TypeAliasCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/TypeAliasCommonizer.kt index ca88fe68d5b..d668994c6e7 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/TypeAliasCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/core/TypeAliasCommonizer.kt @@ -28,7 +28,7 @@ class TypeAliasCommonizer( val typeParameters = TypeParameterListCommonizer(typeCommonizer).commonize(values.map { it.typeParameters }) ?: return null - val underlyingType = typeCommonizer(values.map { it.underlyingType }) as? CirClassOrTypeAliasType ?: return null + val underlyingType = typeCommonizer.invoke(values.map { it.underlyingType }) as? CirClassOrTypeAliasType ?: return null val visibility = VisibilityCommonizer.lowering().commonize(values) ?: return null diff --git a/native/commonizer/testData/classifierCommonization/typeAliases/commonized/common/package_root.kt b/native/commonizer/testData/classifierCommonization/typeAliases/commonized/common/package_root.kt index 5675a4c4c9a..bdb51b73b7a 100644 --- a/native/commonizer/testData/classifierCommonization/typeAliases/commonized/common/package_root.kt +++ b/native/commonizer/testData/classifierCommonization/typeAliases/commonized/common/package_root.kt @@ -7,8 +7,8 @@ typealias C3 = C2 // TA lifted up as is typealias D = A // class/TA expanded to the same class at the RHS typealias D2 = A // class/TA expanded to the same class at the RHS -typealias E = A // different TAs use common type from TA-chain -typealias E2 = A // different TAs use common type from TA-chain +typealias E = B // different TAs use common type from TA-chain +typealias E2 = B // different TAs use common type from TA-chain typealias F = List // parameterized type at the RHS typealias H = List // TA with own parameters diff --git a/native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/ParameterizedTypesCommonizationTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/ParameterizedTypesCommonizationTest.kt new file mode 100644 index 00000000000..3f2a2b9f1df --- /dev/null +++ b/native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/ParameterizedTypesCommonizationTest.kt @@ -0,0 +1,10 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.commonizer.hierarchical + + +class ParameterizedTypesCommonizationTest { +} \ No newline at end of file