diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirAnnotation.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirAnnotation.kt index e8a042ff233..ac3b40d5a7d 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirAnnotation.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirAnnotation.kt @@ -6,10 +6,9 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ConstantValue interface CirAnnotation { val type: CirClassType - val constantValueArguments: Map> + val constantValueArguments: Map> val annotationValueArguments: Map } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirConstantValue.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirConstantValue.kt new file mode 100644 index 00000000000..1644e8c3598 --- /dev/null +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirConstantValue.kt @@ -0,0 +1,41 @@ +/* + * 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.descriptors.commonizer.cir + +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.Name + +sealed class CirConstantValue { + abstract val value: T + + data class StringValue(override val value: String) : CirConstantValue() + data class CharValue(override val value: Char) : CirConstantValue() + + data class ByteValue(override val value: Byte) : CirConstantValue() + data class ShortValue(override val value: Short) : CirConstantValue() + data class IntValue(override val value: Int) : CirConstantValue() + data class LongValue(override val value: Long) : CirConstantValue() + + data class UByteValue(override val value: Byte) : CirConstantValue() + data class UShortValue(override val value: Short) : CirConstantValue() + data class UIntValue(override val value: Int) : CirConstantValue() + data class ULongValue(override val value: Long) : CirConstantValue() + + data class FloatValue(override val value: Float) : CirConstantValue() + data class DoubleValue(override val value: Double) : CirConstantValue() + data class BooleanValue(override val value: Boolean) : CirConstantValue() + + data class EnumValue(val enumClassId: ClassId, val enumEntryName: Name) : CirConstantValue() { + override val value: String = "${enumClassId.asString()}.${enumEntryName.asString()}" + } + + data class ArrayValue(override val value: List>) : CirConstantValue>>() + + object NullValue : CirConstantValue() { + override val value: Void? get() = null + override fun toString() = "NullValue(value=null)" + } +} diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirProperty.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirProperty.kt index 9ffd3065b12..81099e96b84 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirProperty.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirProperty.kt @@ -5,8 +5,6 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir -import org.jetbrains.kotlin.resolve.constants.ConstantValue - interface CirProperty : CirFunctionOrProperty, CirLiftedUpDeclaration { val isExternal: Boolean val isVar: Boolean @@ -17,5 +15,5 @@ interface CirProperty : CirFunctionOrProperty, CirLiftedUpDeclaration { val setter: CirPropertySetter? val backingFieldAnnotations: List? // null assumes no backing field val delegateFieldAnnotations: List? // null assumes no backing field - val compileTimeInitializer: ConstantValue<*>? + val compileTimeInitializer: CirConstantValue<*>? } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt index 4bf9a745fb9..e7e65eba15f 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt @@ -9,9 +9,9 @@ import gnu.trove.THashMap import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassType +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirAnnotationImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.* -import org.jetbrains.kotlin.descriptors.commonizer.utils.checkConstantSupportedInCommonization import org.jetbrains.kotlin.descriptors.commonizer.utils.compact import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name @@ -28,21 +28,18 @@ object CirAnnotationFactory { if (allValueArguments.isEmpty()) return create(type = type, constantValueArguments = emptyMap(), annotationValueArguments = emptyMap()) - val constantValueArguments: MutableMap> = THashMap(allValueArguments.size) + val constantValueArguments: MutableMap> = THashMap(allValueArguments.size) val annotationValueArguments: MutableMap = THashMap(allValueArguments.size) allValueArguments.forEach { (name, constantValue) -> - checkConstantSupportedInCommonization( - constantValue = constantValue, - constantName = name, - owner = source, - allowAnnotationValues = true - ) - if (constantValue is AnnotationValue) annotationValueArguments[name.intern()] = create(source = constantValue.value) else - constantValueArguments[name.intern()] = constantValue + constantValueArguments[name.intern()] = CirConstantValueFactory.createSafely( + constantValue = constantValue, + constantName = name, + owner = source, + ) } return create( @@ -54,7 +51,7 @@ object CirAnnotationFactory { fun create( type: CirClassType, - constantValueArguments: Map>, + constantValueArguments: Map>, annotationValueArguments: Map ): CirAnnotation { return interner.intern( diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirConstantValueFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirConstantValueFactory.kt new file mode 100644 index 00000000000..2c5075e4424 --- /dev/null +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirConstantValueFactory.kt @@ -0,0 +1,58 @@ +/* + * 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.descriptors.commonizer.cir.factory + +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapIndexed +import org.jetbrains.kotlin.descriptors.commonizer.utils.intern +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.constants.* + +object CirConstantValueFactory { + fun createSafely( + constantValue: ConstantValue<*>, + constantName: Name? = null, + owner: Any, + ): CirConstantValue<*> = createSafely( + constantValue = constantValue, + location = { "${owner::class.java}, $owner" + constantName?.asString()?.let { "[$it]" } } + ) + + private fun createSafely( + constantValue: ConstantValue<*>, + location: () -> String + ): CirConstantValue<*> = when (constantValue) { + is StringValue -> CirConstantValue.StringValue(constantValue.value) + is CharValue -> CirConstantValue.CharValue(constantValue.value) + + is ByteValue -> CirConstantValue.ByteValue(constantValue.value) + is ShortValue -> CirConstantValue.ShortValue(constantValue.value) + is IntValue -> CirConstantValue.IntValue(constantValue.value) + is LongValue -> CirConstantValue.LongValue(constantValue.value) + + is UByteValue -> CirConstantValue.UByteValue(constantValue.value) + is UShortValue -> CirConstantValue.UShortValue(constantValue.value) + is UIntValue -> CirConstantValue.UIntValue(constantValue.value) + is ULongValue -> CirConstantValue.ULongValue(constantValue.value) + + is FloatValue -> CirConstantValue.FloatValue(constantValue.value) + is DoubleValue -> CirConstantValue.DoubleValue(constantValue.value) + is BooleanValue -> CirConstantValue.BooleanValue(constantValue.value) + + is EnumValue -> CirConstantValue.EnumValue(constantValue.enumClassId.intern(), constantValue.enumEntryName.intern()) + is NullValue -> CirConstantValue.NullValue + + is ArrayValue -> CirConstantValue.ArrayValue( + constantValue.value.compactMapIndexed { index, innerConstantValue -> + createSafely( + constantValue = innerConstantValue, + location = { "${location()}[$index]" } + ) + }) + + else -> error("Unsupported const value type: ${constantValue::class.java}, $constantValue at ${location()}") + } +} diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt index 58dc8f0842a..263ff5e9a1a 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt @@ -11,20 +11,16 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirPropertyImpl -import org.jetbrains.kotlin.descriptors.commonizer.utils.checkConstantSupportedInCommonization import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ConstantValue object CirPropertyFactory { fun create(source: PropertyDescriptor, containingClass: CirContainingClass?): CirProperty { - val compileTimeInitializer: ConstantValue<*>? = source.compileTimeInitializer - if (compileTimeInitializer != null) { - checkConstantSupportedInCommonization( - constantValue = compileTimeInitializer, + val compileTimeInitializer = source.compileTimeInitializer?.let { constantValue -> + CirConstantValueFactory.createSafely( + constantValue = constantValue, owner = source, - allowAnnotationValues = false ) } @@ -47,7 +43,7 @@ object CirPropertyFactory { setter = source.setter?.let(CirPropertySetterFactory::create), backingFieldAnnotations = source.backingField?.annotations?.compactMap(CirAnnotationFactory::create), delegateFieldAnnotations = source.delegateField?.annotations?.compactMap(CirAnnotationFactory::create), - compileTimeInitializer = source.compileTimeInitializer + compileTimeInitializer = compileTimeInitializer ) } @@ -71,7 +67,7 @@ object CirPropertyFactory { setter: CirPropertySetter?, backingFieldAnnotations: List?, delegateFieldAnnotations: List?, - compileTimeInitializer: ConstantValue<*>? + compileTimeInitializer: CirConstantValue<*>? ): CirProperty { return CirPropertyImpl( annotations = annotations, diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirAnnotationImpl.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirAnnotationImpl.kt index 01c4ea35f9d..02f39825a87 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirAnnotationImpl.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirAnnotationImpl.kt @@ -7,14 +7,14 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.impl import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassType +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue import org.jetbrains.kotlin.descriptors.commonizer.utils.appendHashCode import org.jetbrains.kotlin.descriptors.commonizer.utils.hashCode import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ConstantValue data class CirAnnotationImpl( override val type: CirClassType, - override val constantValueArguments: Map>, + override val constantValueArguments: Map>, override val annotationValueArguments: Map ) : CirAnnotation { // See also org.jetbrains.kotlin.types.KotlinType.cachedHashCode diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirPropertyImpl.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirPropertyImpl.kt index 4178bb61045..d70b6865cbf 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirPropertyImpl.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirPropertyImpl.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ConstantValue data class CirPropertyImpl( override val annotations: List, @@ -31,7 +30,7 @@ data class CirPropertyImpl( override val setter: CirPropertySetter?, override val backingFieldAnnotations: List?, override val delegateFieldAnnotations: List?, - override val compileTimeInitializer: ConstantValue<*>? + override val compileTimeInitializer: CirConstantValue<*>? ) : CirProperty { // const property in "common" fragment is already lifted up override val isLiftedUp get() = isConst diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt index 9d2be91f9d1..eef8bbd1738 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt @@ -7,21 +7,15 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue.* import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirAnnotationFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.core.AnnotationsCommonizer.Companion.FALLBACK_MESSAGE -import org.jetbrains.kotlin.descriptors.commonizer.utils.DEPRECATED_ANNOTATION_CLASS_ID -import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap -import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapOf -import org.jetbrains.kotlin.descriptors.commonizer.utils.intern -import org.jetbrains.kotlin.descriptors.commonizer.utils.internedClassId +import org.jetbrains.kotlin.descriptors.commonizer.utils.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ArrayValue -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.EnumValue -import org.jetbrains.kotlin.resolve.constants.StringValue import kotlin.DeprecationLevel.WARNING /** @@ -62,7 +56,7 @@ private class DeprecatedAnnotationCommonizer : Commonizer> = if (level == WARNING) { + val constantValueArguments: Map> = if (level == WARNING) { // don't populate with the default level value compactMapOf(PROPERTY_NAME_MESSAGE, messageValue) } else @@ -194,17 +188,17 @@ private class DeprecatedAnnotationCommonizer : Commonizer): CirAnnotation = createReplaceWithAnnotation(this, imports) - private inline fun Map>.getString(name: Name): String? = + private inline fun Map>.getString(name: Name): String? = (this[name] as? StringValue)?.value - private inline fun Map>.getEnumEntryName(name: Name): String? = + private inline fun Map>.getEnumEntryName(name: Name): String? = (this[name] as? EnumValue)?.enumEntryName?.asString() private inline fun Map.getAnnotation(name: Name): CirAnnotation? = this[name] - private inline fun Map>.getStringArray(name: Name): List? { - val elements: List> = (this[name] as? ArrayValue)?.value ?: return null + private inline fun Map>.getStringArray(name: Name): List? { + val elements: List> = (this[name] as? ArrayValue)?.value ?: return null if (elements.isEmpty()) return emptyList() val result = ArrayList(elements.size) @@ -223,10 +217,7 @@ private class DeprecatedAnnotationCommonizer : Commonizer(classifiers) { private val setter = PropertySetterCommonizer() @@ -109,7 +109,7 @@ class PropertyCommonizer(classifiers: CirKnownClassifiers) : AbstractFunctionOrP val properties: MutableList = mutableListOf() } - class ConstSameValue(val compileTimeInitializer: ConstantValue<*>) : Const() + class ConstSameValue(val compileTimeInitializer: CirConstantValue<*>) : Const() class ConstMultipleValues(previous: ConstSameValue) : Const() { init { properties += previous.properties diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/entityBuilders.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/entityBuilders.kt index bf0f33c0724..8d5a8f4ccb5 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/entityBuilders.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/entityBuilders.kt @@ -15,10 +15,10 @@ import org.jetbrains.kotlin.descriptors.commonizer.core.computeExpandedType import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.* import org.jetbrains.kotlin.descriptors.commonizer.metadata.TypeAliasExpansion.* import org.jetbrains.kotlin.descriptors.commonizer.utils.DEFAULT_SETTER_VALUE_NAME +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.strip import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.* import org.jetbrains.kotlin.types.Variance internal fun CirModule.buildModule( @@ -156,7 +156,7 @@ internal fun CirProperty.buildProperty( annotations.mapTo(property.annotations) { it.buildAnnotation() } getter?.annotations?.mapTo(property.getterAnnotations) { it.buildAnnotation() } setter?.annotations?.mapTo(property.setterAnnotations) { it.buildAnnotation() } - property.compileTimeValue = compileTimeInitializer?.takeIf { it !is NullValue }?.buildAnnotationArgument() + property.compileTimeValue = compileTimeInitializer?.takeIf { it !is CirConstantValue.NullValue }?.buildAnnotationArgument() typeParameters.buildTypeParameters(context, output = property.typeParameters) extensionReceiver?.let { receiver -> // TODO nowhere to write receiver annotations, see KT-42490 @@ -195,8 +195,9 @@ internal fun CirFunction.buildFunction( private fun CirAnnotation.buildAnnotation(): KmAnnotation { val arguments = LinkedHashMap>(constantValueArguments.size + annotationValueArguments.size, 1F) - constantValueArguments.forEach { (name: Name, value: ConstantValue<*>) -> + constantValueArguments.forEach { (name: Name, value: CirConstantValue<*>) -> arguments[name.asString()] = value.buildAnnotationArgument() + ?: error("Unexpected constant value inside of $this") } annotationValueArguments.forEach { (name: Name, nested: CirAnnotation) -> @@ -209,28 +210,30 @@ private fun CirAnnotation.buildAnnotation(): KmAnnotation { ) } -private fun ConstantValue<*>.buildAnnotationArgument(): KmAnnotationArgument<*> = when (this) { - is StringValue -> KmAnnotationArgument.StringValue(value) - is CharValue -> KmAnnotationArgument.CharValue(value) +private fun CirConstantValue<*>.buildAnnotationArgument(): KmAnnotationArgument<*>? = when (this) { + is CirConstantValue.StringValue -> KmAnnotationArgument.StringValue(value) + is CirConstantValue.CharValue -> KmAnnotationArgument.CharValue(value) - is ByteValue -> KmAnnotationArgument.ByteValue(value) - is ShortValue -> KmAnnotationArgument.ShortValue(value) - is IntValue -> KmAnnotationArgument.IntValue(value) - is LongValue -> KmAnnotationArgument.LongValue(value) + is CirConstantValue.ByteValue -> KmAnnotationArgument.ByteValue(value) + is CirConstantValue.ShortValue -> KmAnnotationArgument.ShortValue(value) + is CirConstantValue.IntValue -> KmAnnotationArgument.IntValue(value) + is CirConstantValue.LongValue -> KmAnnotationArgument.LongValue(value) - is UByteValue -> KmAnnotationArgument.UByteValue(value) - is UShortValue -> KmAnnotationArgument.UShortValue(value) - is UIntValue -> KmAnnotationArgument.UIntValue(value) - is ULongValue -> KmAnnotationArgument.ULongValue(value) + is CirConstantValue.UByteValue -> KmAnnotationArgument.UByteValue(value) + is CirConstantValue.UShortValue -> KmAnnotationArgument.UShortValue(value) + is CirConstantValue.UIntValue -> KmAnnotationArgument.UIntValue(value) + is CirConstantValue.ULongValue -> KmAnnotationArgument.ULongValue(value) - is FloatValue -> KmAnnotationArgument.FloatValue(value) - is DoubleValue -> KmAnnotationArgument.DoubleValue(value) - is BooleanValue -> KmAnnotationArgument.BooleanValue(value) + is CirConstantValue.FloatValue -> KmAnnotationArgument.FloatValue(value) + is CirConstantValue.DoubleValue -> KmAnnotationArgument.DoubleValue(value) + is CirConstantValue.BooleanValue -> KmAnnotationArgument.BooleanValue(value) - is EnumValue -> KmAnnotationArgument.EnumValue(enumClassId.asString(), enumEntryName.asString()) - is ArrayValue -> KmAnnotationArgument.ArrayValue(value.map { it.buildAnnotationArgument() }) + is CirConstantValue.EnumValue -> KmAnnotationArgument.EnumValue(enumClassId.asString(), enumEntryName.asString()) + is CirConstantValue.NullValue -> null - else -> error("Unsupported annotation argument type: ${this::class.java}, $this") + is CirConstantValue.ArrayValue -> KmAnnotationArgument.ArrayValue(value.compactMap { element -> + element.buildAnnotationArgument() ?: error("Unexpected constant value inside of $this") + }) } private fun CirValueParameter.buildValueParameter( diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/flags.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/flags.kt index ea8a338be6f..2b97f1b2d6a 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/flags.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/flags.kt @@ -13,7 +13,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.commonizer.cir.* -import org.jetbrains.kotlin.resolve.constants.NullValue internal const val NO_FLAGS: Flags = 0 @@ -172,7 +171,7 @@ private inline val CirProperty.modifiersFlags: Flags get() = flagsOfNotNull( Flag.Property.IS_VAR.takeIf { isVar }, Flag.Property.IS_CONST.takeIf { isConst }, - Flag.Property.HAS_CONSTANT.takeIf { compileTimeInitializer.takeIf { it !is NullValue } != null }, + Flag.Property.HAS_CONSTANT.takeIf { compileTimeInitializer.takeIf { it !is CirConstantValue.NullValue } != null }, Flag.Property.IS_LATEINIT.takeIf { isLateInit }, Flag.Property.IS_EXTERNAL.takeIf { isExternal } ) 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 deleted file mode 100644 index 2f5099ac568..00000000000 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/constants.kt +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright 2010-2020 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.descriptors.commonizer.utils - -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.* - -internal fun checkConstantSupportedInCommonization( - constantValue: ConstantValue<*>, - constantName: Name? = null, - owner: Any, - allowAnnotationValues: Boolean, - onError: (String) -> Nothing = ::error -) { - checkConstantSupportedInCommonization( - constantValue = constantValue, - location = { "${owner::class.java}, $owner" + constantName?.asString()?.let { "[$it]" } }, - allowAnnotationValues = allowAnnotationValues, - onError = onError - ) -} - -private fun checkConstantSupportedInCommonization( - constantValue: ConstantValue<*>, - location: () -> String, - allowAnnotationValues: Boolean, - onError: (String) -> Nothing -) { - @Suppress("TrailingComma") - when (constantValue) { - is StringValue, - is IntegerValueConstant<*>, - is UnsignedValueConstant<*>, - is BooleanValue, - is NullValue, - is DoubleValue, - is FloatValue, - is EnumValue -> { - return // OK - } - is AnnotationValue -> { - if (allowAnnotationValues) { - return // OK - } // else fail (see below) - } - is ArrayValue -> { - constantValue.value.forEachIndexed { index, innerConstantValue -> - checkConstantSupportedInCommonization( - constantValue = innerConstantValue, - location = { "${location()}[$index]" }, - allowAnnotationValues = allowAnnotationValues, - onError = onError - ) - } - return // OK - } - } - - onError("Unsupported const value type: ${constantValue::class.java}, $constantValue at ${location()}") -} - diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/interners.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/interners.kt index e72e708c02a..444e9230860 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/interners.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/interners.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.name.Name internal fun FqName.intern(): FqName = fqNameInterner.intern(this) internal fun Name.intern(): Name = nameInterner.intern(this) +internal fun ClassId.intern(): ClassId = classIdInterner.intern(this) @Suppress("NOTHING_TO_INLINE") internal inline fun internedClassId(topLevelFqName: FqName): ClassId { @@ -29,9 +30,6 @@ internal fun internedClassId(ownerClassId: ClassId, nestedClassName: Name): Clas return ClassId(ownerClassId.packageFqName, relativeClassName, ownerClassId.isLocal).intern() } -@Suppress("NOTHING_TO_INLINE") -private inline fun ClassId.intern(): ClassId = classIdInterner.intern(this) - private val fqNameInterner = Interner() private val nameInterner = Interner() private val classIdInterner = Interner() diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizerTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizerTest.kt index 26a7a0e365a..10349f592d6 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizerTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizerTest.kt @@ -7,16 +7,14 @@ package org.jetbrains.kotlin.descriptors.commonizer.core import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassType +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirConstantValue.* import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirAnnotationFactory import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ArrayValue -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.EnumValue -import org.jetbrains.kotlin.resolve.constants.StringValue import org.junit.Test import kotlin.DeprecationLevel.* @@ -287,7 +285,7 @@ class AnnotationsCommonizerTest : AbstractCommonizerTest, Li private fun mockAnnotation( fqName: String, - constantValueArguments: Map> = emptyMap(), + constantValueArguments: Map> = emptyMap(), annotationValueArguments: Map = emptyMap() ): CirAnnotation = CirAnnotationFactory.create( type = CirTypeFactory.create(mockClassType(fqName)) as CirClassType, @@ -306,9 +304,7 @@ private fun mockDeprecated( fqName = "kotlin.ReplaceWith", constantValueArguments = mapOf( Name.identifier("expression") to StringValue(replaceWithExpression), - Name.identifier("imports") to ArrayValue(replaceWithImports.map(::StringValue)) { - it.builtIns.getArrayElementType(it.builtIns.stringType) - } + Name.identifier("imports") to ArrayValue(replaceWithImports.map(::StringValue)) ), annotationValueArguments = emptyMap() ) @@ -316,7 +312,7 @@ private fun mockDeprecated( return mockAnnotation( fqName = "kotlin.Deprecated", - constantValueArguments = HashMap>().apply { + constantValueArguments = HashMap>().apply { this[Name.identifier("message")] = StringValue(message) if (level != WARNING)