Drop ArrayValue redundant constructor parameter

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java

@@ -249,7 +249,7 @@ public class AnnotationResolver {
 
             if (parameterDescriptor.declaresDefaultValue() && constants.isEmpty()) return null;
 
-            return new ArrayValue(constants, parameterDescriptor.getType(), true, usesVariableAsConstant);
+            return new ArrayValue(constants, parameterDescriptor.getType(), usesVariableAsConstant);
         }
         else {
             // we should actually get only one element, but just in case of getting many, we take the last one

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -387,7 +387,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             val varargType = resultingDescriptor.getValueParameters().first().getVarargElementType()!!
 
             val arguments = call.getValueArguments().values().flatMap { resolveArguments(it.getArguments(), varargType) }
-            return ArrayValue(arguments, resultingDescriptor.getReturnType()!!, true, arguments.any() { it.usesVariableAsConstant() })
+            return ArrayValue(arguments, resultingDescriptor.getReturnType()!!, arguments.any() { it.usesVariableAsConstant() })
         }
 
         // Ann()

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

@@ -125,7 +125,7 @@ class LazyJavaAnnotationDescriptor(
         val values = elements.map {
             argument -> resolveAnnotationArgument(argument) ?: NullValue
         }
-        return ArrayValue(values, valueParameter.getType(), true, values.any { it.usesVariableAsConstant() })
+        return ArrayValue(values, valueParameter.getType(), values.any { it.usesVariableAsConstant() })
     }
 
     private fun resolveFromEnumValue(element: JavaField?): CompileTimeConstant<*>? {

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt

@@ -107,7 +107,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
                         val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass)
                         if (parameter != null) {
                             elements.trimToSize()
-                            arguments[parameter] = ArrayValue(elements, parameter.getType(), true, false)
+                            arguments[parameter] = ArrayValue(elements, parameter.getType(), false)
                         }
                     }
                 }

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

@@ -24,8 +24,8 @@ import java.util.*
 public class ArrayValue(
         value: List<CompileTimeConstant<*>>,
         private val type: JetType,
-        canBeUsedInAnnotations: Boolean, usesVariableAsConstant: Boolean
+        usesVariableAsConstant: Boolean
-) : CompileTimeConstant<List<CompileTimeConstant<*>>>(value, canBeUsedInAnnotations, false, usesVariableAsConstant) {
+) : CompileTimeConstant<List<CompileTimeConstant<*>>>(value, true, false, usesVariableAsConstant) {
 
     init {
         assert(KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type)) { "Type should be an array, but was " + type + ": " + value }

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt

@@ -110,9 +110,11 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
                 val expectedElementType = builtIns.getArrayElementType(if (expectedIsArray) expectedType else actualArrayType)
 
                 ArrayValue(
-                        arrayElements.map { resolveValue(expectedElementType, it, nameResolver) },
+                        arrayElements.map {
+                            resolveValue(expectedElementType, it, nameResolver)
+                        },
                         actualArrayType,
-                        true, true
+                        true
                 )
             }
             else -> error("Unsupported annotation argument type: ${value.getType()} (expected $expectedType)")