Remove unneeded members of ConstantValueFactory

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<String> =
-            ConstantValueFactory.createStringValue(entry.text).wrap()
+            StringValue(entry.text).wrap()
 
         override fun visitEscapeStringTemplateEntry(entry: KtEscapeStringTemplateEntry, data: Nothing?): TypedCompileTimeConstant<String> =
-            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<ValueArgument>, expectedType: KotlinType): List<CompileTimeConstant<*>?> {
@@ -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")
         }

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<Name, ConstantValue<*>> 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"))
     }
 }
 

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<JavaAnnotationArgument>): 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 {

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")
             }
         }
     }

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))
         }

core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt

@@ -88,10 +88,10 @@ class IntegerValueTypeConstant(
     override fun toConstantValue(expectedType: KotlinType): ConstantValue<Number> {
         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())
         }
     }
 

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<ConstantValue<*>>, type: KotlinType) = createArrayValue(value) { type }
-
-    fun createAnnotationValue(value: AnnotationDescriptor) = AnnotationValue(value)
-
-    fun createKClassValue(type: KotlinType) = KClassValue(type)
+    fun createArrayValue(value: List<ConstantValue<*>>, 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<ConstantValue<*>>, computeType: (ModuleDescriptor) -> KotlinType): ArrayValue =
-            ArrayValue(value, computeType)
-
-    private fun List<*>.arrayToList(): List<ConstantValue<*>> =
-            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
         }
     }

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 =