Refactor ConstantValue implementations

Remove KotlinBuiltIns and take a ModuleDescriptor instance in getType
instead. This will allow to create constant values in contexts where
there's no module or built-ins accessible (such as, deserialization of
module annotations during indexing of .kotlin_module files in IDE).

Note that some values (KClassValue, EnumValue, AnnotationValue) still
take module-dependent objects (KotlinType, ClassDescriptor and
AnnotationDescriptor respectively). This is to be refactored later

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt

@@ -114,8 +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(c.module.builtIns).createStringValue("Deprecated in Java"))
+        mapOf(JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE to ConstantValueFactory.createStringValue("Deprecated in Java"))
     }
 }
 
@@ -170,7 +169,7 @@ object JavaAnnotationTargetMapper {
                 JavaAnnotationMapper.TARGET_ANNOTATION_ALLOWED_TARGETS,
                 builtIns.getBuiltInClassByFqName(KotlinBuiltIns.FQ_NAMES.target)
         )
-        return ArrayValue(kotlinTargets, parameterDescriptor?.type ?: ErrorUtils.createErrorType("Error: AnnotationTarget[]"), builtIns)
+        return ArrayValue(kotlinTargets) { parameterDescriptor?.type ?: ErrorUtils.createErrorType("Error: AnnotationTarget[]") }
     }
 
     private val retentionNameList = mapOf(

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt

@@ -57,8 +57,6 @@ class LazyJavaAnnotationDescriptor(
 
     override val source = c.components.sourceElementFactory.source(javaAnnotation)
 
-    private val factory = ConstantValueFactory(c.module.builtIns)
-
     override val allValueArguments by c.storageManager.createLazyValue {
         javaAnnotation.arguments.mapNotNull { arg ->
             val name = arg.name ?: DEFAULT_ANNOTATION_MEMBER_NAME
@@ -68,7 +66,7 @@ class LazyJavaAnnotationDescriptor(
 
     private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): ConstantValue<*>? {
         return when (argument) {
-            is JavaLiteralAnnotationArgument -> factory.createConstantValue(argument.value)
+            is JavaLiteralAnnotationArgument -> ConstantValueFactory.createConstantValue(argument.value)
             is JavaEnumValueAnnotationArgument -> resolveFromEnumValue(argument.resolve(), argument.entryName)
             is JavaArrayAnnotationArgument -> resolveFromArray(argument.name ?: DEFAULT_ANNOTATION_MEMBER_NAME, argument.getElements())
             is JavaAnnotationAsAnnotationArgument -> resolveFromAnnotation(argument.getAnnotation())
@@ -78,7 +76,7 @@ class LazyJavaAnnotationDescriptor(
     }
 
     private fun resolveFromAnnotation(javaAnnotation: JavaAnnotation): ConstantValue<*> {
-        return factory.createAnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation))
+        return ConstantValueFactory.createAnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation))
     }
 
     private fun resolveFromArray(argumentName: Name, elements: List<JavaAnnotationArgument>): ConstantValue<*>? {
@@ -93,16 +91,16 @@ class LazyJavaAnnotationDescriptor(
                     )
 
         val values = elements.map {
-            argument -> resolveAnnotationArgument(argument) ?: factory.createNullValue()
+            argument -> resolveAnnotationArgument(argument) ?: ConstantValueFactory.createNullValue()
         }
 
-        return factory.createArrayValue(values, arrayType)
+        return ConstantValueFactory.createArrayValue(values, arrayType)
     }
 
     private fun resolveFromEnumValue(element: JavaField?, entryName: Name?): ConstantValue<*>? {
         if (element == null || !element.isEnumEntry) {
             if (entryName == null) return null
-            return factory.createEnumValue(ErrorUtils.createErrorClassWithExactName(entryName))
+            return ConstantValueFactory.createEnumValue(ErrorUtils.createErrorClassWithExactName(entryName))
         }
 
         val containingJavaClass = element.containingClass
@@ -112,7 +110,7 @@ class LazyJavaAnnotationDescriptor(
         val classifier = enumClass.unsubstitutedInnerClassesScope.getContributedClassifier(element.name, NoLookupLocation.FROM_JAVA_LOADER)
                                  as? ClassDescriptor ?: return null
 
-        return factory.createEnumValue(classifier)
+        return ConstantValueFactory.createEnumValue(classifier)
     }
 
     private fun resolveFromJavaClassObjectType(javaType: JavaType): ConstantValue<*>? {
@@ -128,7 +126,7 @@ class LazyJavaAnnotationDescriptor(
 
         val javaClassObjectType = KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, jlClass, arguments)
 
-        return factory.createKClassValue(javaClassObjectType)
+        return ConstantValueFactory.createKClassValue(javaClassObjectType)
     }
 
     override fun toString(): String {

core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt

@@ -45,7 +45,6 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
         storageManager, kotlinClassFinder
 ) {
     private val annotationDeserializer = AnnotationDeserializer(module, notFoundClasses)
-    private val factory = ConstantValueFactory(module.builtIns)
 
     override fun loadTypeAnnotation(proto: ProtoBuf.Annotation, nameResolver: NameResolver): AnnotationDescriptor =
             annotationDeserializer.deserializeAnnotation(proto, nameResolver)
@@ -65,7 +64,7 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
             initializer
         }
 
-        return factory.createConstantValue(normalizedValue)
+        return ConstantValueFactory.createConstantValue(normalizedValue)
     }
 
     override fun loadPropertyAnnotations(
@@ -116,7 +115,7 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
                     override fun visitEnd() {
                         val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass)
                         if (parameter != null) {
-                            arguments[name] = factory.createArrayValue(elements.compact(), parameter.type)
+                            arguments[name] = ConstantValueFactory.createArrayValue(elements.compact(), parameter.type)
                         }
                     }
                 }
@@ -139,10 +138,10 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
                 if (enumClass.kind == ClassKind.ENUM_CLASS) {
                     val classifier = enumClass.unsubstitutedInnerClassesScope.getContributedClassifier(name, NoLookupLocation.FROM_JAVA_LOADER)
                     if (classifier is ClassDescriptor) {
-                        return factory.createEnumValue(classifier)
+                        return ConstantValueFactory.createEnumValue(classifier)
                     }
                 }
-                return factory.createErrorValue("Unresolved enum entry: $enumClassId.$name")
+                return ConstantValueFactory.createErrorValue("Unresolved enum entry: $enumClassId.$name")
             }
 
             override fun visitEnd() {
@@ -150,8 +149,8 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
             }
 
             private fun createConstant(name: Name?, value: Any?): ConstantValue<*> {
-                return factory.createConstantValue(value) ?:
-                       factory.createErrorValue("Unsupported annotation argument: $name")
+                return ConstantValueFactory.createConstantValue(value) ?:
+                       ConstantValueFactory.createErrorValue("Unsupported annotation argument: $name")
             }
         }
     }