From b3eeb2f7357a72ed8337283566310f6f9a98ddfc Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 29 Dec 2017 17:03:19 +0100 Subject: [PATCH] Remove unneeded members of ConstantValueFactory --- .../evaluate/ConstantExpressionEvaluator.kt | 30 +++---- .../java/components/JavaAnnotationMapper.kt | 4 +- .../LazyJavaAnnotationDescriptor.kt | 10 +-- ...aryClassAnnotationAndConstantLoaderImpl.kt | 9 +- .../kotlin/builtins/functionTypes.kt | 3 +- .../resolve/constants/CompileTimeConstant.kt | 8 +- .../resolve/constants/ConstantValueFactory.kt | 88 ++++++------------- .../deserialization/AnnotationDeserializer.kt | 27 +++--- 8 files changed, 69 insertions(+), 110 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index 9ded952af40..5a4631536e6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -312,8 +312,8 @@ private class ConstantExpressionEvaluatorVisitor( } return when (constantValue) { is ErrorValue, is EnumValue -> return null - is NullValue -> ConstantValueFactory.createStringValue("null") - else -> ConstantValueFactory.createStringValue(constantValue.value.toString()) + is NullValue -> StringValue("null") + else -> StringValue(constantValue.value.toString()) }.wrap(compileTimeConstant.parameters) } @@ -336,17 +336,17 @@ private class ConstantExpressionEvaluatorVisitor( entry: KtLiteralStringTemplateEntry, data: Nothing? ): TypedCompileTimeConstant = - ConstantValueFactory.createStringValue(entry.text).wrap() + StringValue(entry.text).wrap() override fun visitEscapeStringTemplateEntry(entry: KtEscapeStringTemplateEntry, data: Nothing?): TypedCompileTimeConstant = - ConstantValueFactory.createStringValue(entry.unescapedValue).wrap() + StringValue(entry.unescapedValue).wrap() } override fun visitConstantExpression(expression: KtConstantExpression, expectedType: KotlinType?): CompileTimeConstant<*>? { val text = expression.text ?: return null val nodeElementType = expression.node.elementType - if (nodeElementType == KtNodeTypes.NULL) return ConstantValueFactory.createNullValue().wrap() + if (nodeElementType == KtNodeTypes.NULL) return NullValue().wrap() val result: Any? = when (nodeElementType) { KtNodeTypes.INTEGER_CONSTANT, KtNodeTypes.FLOAT_CONSTANT -> parseNumericLiteral(text, nodeElementType) @@ -546,7 +546,7 @@ private class ConstantExpressionEvaluatorVisitor( if ((isIntegerType(argumentForReceiver.value) && isIntegerType(argumentForParameter.value)) || !constantExpressionEvaluator.languageVersionSettings.supportsFeature(LanguageFeature.DivisionByZeroInConstantExpressions)) { - return ConstantValueFactory.createErrorValue("Division by zero").wrap() + return ErrorValue.create("Division by zero").wrap() } } @@ -781,7 +781,7 @@ private class ConstantExpressionEvaluatorVisitor( override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, expectedType: KotlinType?): CompileTimeConstant<*>? { val type = trace.getType(expression)!! if (type.isError) return null - return ConstantValueFactory.createKClassValue(type).wrap() + return KClassValue(type).wrap() } private fun resolveArguments(valueArguments: List, expectedType: KotlinType): List?> { @@ -885,8 +885,8 @@ private class ConstantExpressionEvaluatorVisitor( return integerValue.wrap(parameters) } return when (value) { - value.toInt().toLong() -> ConstantValueFactory.createIntValue(value.toInt()) - else -> ConstantValueFactory.createLongValue(value) + value.toInt().toLong() -> IntValue(value.toInt()) + else -> LongValue(value) }.wrap(parameters) } @@ -972,7 +972,7 @@ private fun createCompileTimeConstantForEquals(result: Any?, operationReference: } else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.text}") } - return ConstantValueFactory.createBooleanValue(value) + return BooleanValue(value) } return null } @@ -982,13 +982,13 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen assert(operationReference is KtSimpleNameExpression) { "This method should be called only for compareTo operations" } val operationToken = (operationReference as KtSimpleNameExpression).getReferencedNameElementType() return when (operationToken) { - KtTokens.LT -> ConstantValueFactory.createBooleanValue(result < 0) - KtTokens.LTEQ -> ConstantValueFactory.createBooleanValue(result <= 0) - KtTokens.GT -> ConstantValueFactory.createBooleanValue(result > 0) - KtTokens.GTEQ -> ConstantValueFactory.createBooleanValue(result >= 0) + KtTokens.LT -> BooleanValue(result < 0) + KtTokens.LTEQ -> BooleanValue(result <= 0) + KtTokens.GT -> BooleanValue(result > 0) + KtTokens.GTEQ -> BooleanValue(result >= 0) KtTokens.IDENTIFIER -> { assert(operationReference.getReferencedNameAsName() == OperatorNameConventions.COMPARE_TO) { "This method should be called only for compareTo operations" } - return ConstantValueFactory.createIntValue(result) + return IntValue(result) } else -> throw IllegalStateException("Unknown compareTo operation token: $operationToken") } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 4a9d3f8a00d..aa2aa731eea 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -29,8 +29,8 @@ 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.ConstantValueFactory import org.jetbrains.kotlin.resolve.constants.EnumValue +import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.storage.getValue import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.SimpleType @@ -114,7 +114,7 @@ class JavaDeprecatedAnnotationDescriptor( c: LazyJavaResolverContext ): JavaAnnotationDescriptor(c, annotation, KotlinBuiltIns.FQ_NAMES.deprecated) { override val allValueArguments: Map> by c.storageManager.createLazyValue { - mapOf(JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE to ConstantValueFactory.createStringValue("Deprecated in Java")) + mapOf(JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE to StringValue("Deprecated in Java")) } } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 2489461b180..bb637b9784e 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -31,9 +31,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.JavaToKotlinClassMap import org.jetbrains.kotlin.renderer.DescriptorRenderer -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory -import org.jetbrains.kotlin.resolve.constants.EnumValue +import org.jetbrains.kotlin.resolve.constants.* import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass import org.jetbrains.kotlin.storage.getValue @@ -76,7 +74,7 @@ class LazyJavaAnnotationDescriptor( } private fun resolveFromAnnotation(javaAnnotation: JavaAnnotation): ConstantValue<*> { - return ConstantValueFactory.createAnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation)) + return AnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation)) } private fun resolveFromArray(argumentName: Name, elements: List): ConstantValue<*>? { @@ -91,7 +89,7 @@ class LazyJavaAnnotationDescriptor( ) val values = elements.map { - argument -> resolveAnnotationArgument(argument) ?: ConstantValueFactory.createNullValue() + argument -> resolveAnnotationArgument(argument) ?: NullValue() } return ConstantValueFactory.createArrayValue(values, arrayType) @@ -116,7 +114,7 @@ class LazyJavaAnnotationDescriptor( val javaClassObjectType = KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, jlClass, arguments) - return ConstantValueFactory.createKClassValue(javaClassObjectType) + return KClassValue(javaClassObjectType) } override fun toString(): String { diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt index 8f7187cc7d8..3ae14d8f987 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt @@ -25,10 +25,7 @@ import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.AnnotationValue -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory -import org.jetbrains.kotlin.resolve.constants.EnumValue +import org.jetbrains.kotlin.resolve.constants.* import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.AnnotationDeserializer import org.jetbrains.kotlin.serialization.deserialization.NameResolver @@ -137,8 +134,8 @@ class BinaryClassAnnotationAndConstantLoaderImpl( } private fun createConstant(name: Name?, value: Any?): ConstantValue<*> { - return ConstantValueFactory.createConstantValue(value) ?: - ConstantValueFactory.createErrorValue("Unsupported annotation argument: $name") + return ConstantValueFactory.createConstantValue(value) + ?: ErrorValue.create("Unsupported annotation argument: $name") } } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt index 611f003acd2..7d4b08e5b84 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.annotations.BuiltInAnnotationDescriptor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.types.* @@ -169,7 +168,7 @@ fun getFunctionTypeArgumentProjections( val parameterNameAnnotation = BuiltInAnnotationDescriptor( builtIns, KotlinBuiltIns.FQ_NAMES.parameterName, - mapOf(Name.identifier("name") to ConstantValueFactory.createStringValue(name.asString())) + mapOf(Name.identifier("name") to StringValue(name.asString())) ) type.replaceAnnotations(AnnotationsImpl(type.annotations + parameterNameAnnotation)) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt index 5fa82161ca5..3e45bfaa0b6 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt @@ -88,10 +88,10 @@ class IntegerValueTypeConstant( override fun toConstantValue(expectedType: KotlinType): ConstantValue { val type = getType(expectedType) return when { - KotlinBuiltIns.isInt(type) -> ConstantValueFactory.createIntValue(value.toInt()) - KotlinBuiltIns.isByte(type) -> ConstantValueFactory.createByteValue(value.toByte()) - KotlinBuiltIns.isShort(type) -> ConstantValueFactory.createShortValue(value.toShort()) - else -> ConstantValueFactory.createLongValue(value.toLong()) + KotlinBuiltIns.isInt(type) -> IntValue(value.toInt()) + KotlinBuiltIns.isByte(type) -> ByteValue(value.toByte()) + KotlinBuiltIns.isShort(type) -> ShortValue(value.toShort()) + else -> LongValue(value.toLong()) } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt index 5b56ab61213..13030f0e645 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt @@ -18,72 +18,40 @@ package org.jetbrains.kotlin.resolve.constants import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.PrimitiveType -import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils object ConstantValueFactory { - fun createLongValue(value: Long) = LongValue(value) - - fun createIntValue(value: Int) = IntValue(value) - - fun createErrorValue(message: String) = ErrorValue.create(message) - - fun createShortValue(value: Short) = ShortValue(value) - - fun createByteValue(value: Byte) = ByteValue(value) - - fun createDoubleValue(value: Double) = DoubleValue(value) - - fun createFloatValue(value: Float) = FloatValue(value) - - fun createBooleanValue(value: Boolean) = BooleanValue(value) - - fun createCharValue(value: Char) = CharValue(value) - - fun createStringValue(value: String) = StringValue(value) - - fun createNullValue() = NullValue() - - fun createArrayValue(value: List>, type: KotlinType) = createArrayValue(value) { type } - - fun createAnnotationValue(value: AnnotationDescriptor) = AnnotationValue(value) - - fun createKClassValue(type: KotlinType) = KClassValue(type) + fun createArrayValue(value: List>, type: KotlinType) = ArrayValue(value) { type } fun createConstantValue(value: Any?): ConstantValue<*>? { return when (value) { - is Byte -> createByteValue(value) - is Short -> createShortValue(value) - is Int -> createIntValue(value) - is Long -> createLongValue(value) - is Char -> createCharValue(value) - is Float -> createFloatValue(value) - is Double -> createDoubleValue(value) - is Boolean -> createBooleanValue(value) - is String -> createStringValue(value) - is ByteArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.BYTE.arrayType()) - is ShortArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.SHORT.arrayType()) - is IntArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.INT.arrayType()) - is LongArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.LONG.arrayType()) - is CharArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.CHAR.arrayType()) - is FloatArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.FLOAT.arrayType()) - is DoubleArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.DOUBLE.arrayType()) - is BooleanArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.BOOLEAN.arrayType()) - null -> createNullValue() + is Byte -> ByteValue(value) + is Short -> ShortValue(value) + is Int -> IntValue(value) + is Long -> LongValue(value) + is Char -> CharValue(value) + is Float -> FloatValue(value) + is Double -> DoubleValue(value) + is Boolean -> BooleanValue(value) + is String -> StringValue(value) + is ByteArray -> createArrayValue(value.toList(), PrimitiveType.BYTE) + is ShortArray -> createArrayValue(value.toList(), PrimitiveType.SHORT) + is IntArray -> createArrayValue(value.toList(), PrimitiveType.INT) + is LongArray -> createArrayValue(value.toList(), PrimitiveType.LONG) + is CharArray -> createArrayValue(value.toList(), PrimitiveType.CHAR) + is FloatArray -> createArrayValue(value.toList(), PrimitiveType.FLOAT) + is DoubleArray -> createArrayValue(value.toList(), PrimitiveType.DOUBLE) + is BooleanArray -> createArrayValue(value.toList(), PrimitiveType.BOOLEAN) + null -> NullValue() else -> null } } - private fun createArrayValue(value: List>, computeType: (ModuleDescriptor) -> KotlinType): ArrayValue = - ArrayValue(value, computeType) - - private fun List<*>.arrayToList(): List> = - this.toList().mapNotNull { createConstantValue(it) } - - private fun PrimitiveType.arrayType(): (ModuleDescriptor) -> KotlinType = - { module -> module.builtIns.getPrimitiveArrayKotlinType(this) } + private fun createArrayValue(value: List<*>, componentType: PrimitiveType): ArrayValue = + ArrayValue(value.toList().mapNotNull(this::createConstantValue)) { module -> + module.builtIns.getPrimitiveArrayKotlinType(componentType) + } fun createIntegerConstantValue( value: Long, @@ -91,11 +59,11 @@ object ConstantValueFactory { ): ConstantValue<*>? { val notNullExpected = TypeUtils.makeNotNullable(expectedType) return when { - KotlinBuiltIns.isLong(notNullExpected) -> createLongValue(value) - KotlinBuiltIns.isInt(notNullExpected) && value == value.toInt().toLong() -> createIntValue(value.toInt()) - KotlinBuiltIns.isShort(notNullExpected) && value == value.toShort().toLong() -> createShortValue(value.toShort()) - KotlinBuiltIns.isByte(notNullExpected) && value == value.toByte().toLong() -> createByteValue(value.toByte()) - KotlinBuiltIns.isChar(notNullExpected) -> createIntValue(value.toInt()) + KotlinBuiltIns.isLong(notNullExpected) -> LongValue(value) + KotlinBuiltIns.isInt(notNullExpected) && value == value.toInt().toLong() -> IntValue(value.toInt()) + KotlinBuiltIns.isShort(notNullExpected) && value == value.toShort().toLong() -> ShortValue(value.toShort()) + KotlinBuiltIns.isByte(notNullExpected) && value == value.toByte().toLong() -> ByteValue(value.toByte()) + KotlinBuiltIns.isChar(notNullExpected) -> IntValue(value.toInt()) else -> null } } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt index d141f297ecc..dc2397f7b48 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt @@ -24,10 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.constants.AnnotationValue -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory -import org.jetbrains.kotlin.resolve.constants.EnumValue +import org.jetbrains.kotlin.resolve.constants.* import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value @@ -70,16 +67,16 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n nameResolver: NameResolver ): ConstantValue<*> { val result: ConstantValue<*> = when (value.type) { - Type.BYTE -> ConstantValueFactory.createByteValue(value.intValue.toByte()) - Type.CHAR -> ConstantValueFactory.createCharValue(value.intValue.toChar()) - Type.SHORT -> ConstantValueFactory.createShortValue(value.intValue.toShort()) - Type.INT -> ConstantValueFactory.createIntValue(value.intValue.toInt()) - Type.LONG -> ConstantValueFactory.createLongValue(value.intValue) - Type.FLOAT -> ConstantValueFactory.createFloatValue(value.floatValue) - Type.DOUBLE -> ConstantValueFactory.createDoubleValue(value.doubleValue) - Type.BOOLEAN -> ConstantValueFactory.createBooleanValue(value.intValue != 0L) + Type.BYTE -> ByteValue(value.intValue.toByte()) + Type.CHAR -> CharValue(value.intValue.toChar()) + Type.SHORT -> ShortValue(value.intValue.toShort()) + Type.INT -> IntValue(value.intValue.toInt()) + Type.LONG -> LongValue(value.intValue) + Type.FLOAT -> FloatValue(value.floatValue) + Type.DOUBLE -> DoubleValue(value.doubleValue) + Type.BOOLEAN -> BooleanValue(value.intValue != 0L) Type.STRING -> { - ConstantValueFactory.createStringValue(nameResolver.getString(value.stringValue)) + StringValue(nameResolver.getString(value.stringValue)) } Type.CLASS -> { resolveClassLiteralValue(nameResolver.getClassId(value.classId)) @@ -124,7 +121,7 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n } else { // This means that an annotation class has been changed incompatibly without recompiling clients - ConstantValueFactory.createErrorValue("Unexpected argument value") + ErrorValue.create("Unexpected argument value") } } @@ -134,7 +131,7 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n val starProjectedType = resolveClass(classId).defaultType.replaceArgumentsWithStarProjections() val kClass = resolveClass(ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.kClass.toSafe())) val type = KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, kClass, listOf(TypeProjectionImpl(starProjectedType))) - return ConstantValueFactory.createKClassValue(type) + return KClassValue(type) } private fun resolveArrayElementType(value: Value, nameResolver: NameResolver): SimpleType =