Check that arguments of array function call in annotation are constants

#KT-16956 Fixed

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

@@ -722,10 +722,13 @@ private class ConstantExpressionEvaluatorVisitor(
 
         val arguments = call.valueArguments.values.flatMap { resolveArguments(it.arguments, componentType) }
 
-        return factory.createArrayValue(arguments.map { it.toConstantValue(componentType) }, returnType)
+        // not evaluated arguments are not constants: function-calls, properties with custom getter...
+        val evaluatedArguments = arguments.filterNotNull()
+
+        return factory.createArrayValue(evaluatedArguments.map { it.toConstantValue(componentType) }, returnType)
                 .wrap(
-                        usesVariableAsConstant = arguments.any { it.usesVariableAsConstant },
+                        usesVariableAsConstant = evaluatedArguments.any { it.usesVariableAsConstant },
-                        usesNonConstValAsConstant = arguments.any { it.usesNonConstValAsConstant }
+                        usesNonConstValAsConstant = arguments.any { it == null || it.usesNonConstValAsConstant }
                 )
     }
 
@@ -735,15 +738,12 @@ private class ConstantExpressionEvaluatorVisitor(
         return KClassValue(jetType).wrap()
     }
 
-    private fun resolveArguments(valueArguments: List<ValueArgument>, expectedType: KotlinType): List<CompileTimeConstant<*>> {
+    private fun resolveArguments(valueArguments: List<ValueArgument>, expectedType: KotlinType): List<CompileTimeConstant<*>?> {
-        val constants = arrayListOf<CompileTimeConstant<*>>()
+        val constants = arrayListOf<CompileTimeConstant<*>?>()
         for (argument in valueArguments) {
             val argumentExpression = argument.getArgumentExpression()
             if (argumentExpression != null) {
-                val compileTimeConstant = evaluate(argumentExpression, expectedType)
+                constants.add(evaluate(argumentExpression, expectedType))
-                if (compileTimeConstant != null) {
-                    constants.add(compileTimeConstant)
-                }
             }
         }
         return constants

compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt

@@ -8,7 +8,7 @@ annotation class Foo(
 
 annotation class Bar(
         val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
-        val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
+        val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
         val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
 )
 

compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesWithConstantsInAnnotation.kt

@@ -15,11 +15,11 @@ fun getTwo() = TWO
 annotation class Bar(
         val a: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>[TWO]<!>,
         val b: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>[1, TWO]<!>,
-        val c: IntArray = [getOne(), getTwo()]
+        val c: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>[getOne(), getTwo()]<!>
 )
 
 annotation class Baz(
         val a: IntArray = [<!NULL_FOR_NONNULL_TYPE!>null<!>],
         val b: IntArray = [1, <!NULL_FOR_NONNULL_TYPE!>null<!>, 2],
-        val c: IntArray = [<!NO_THIS!>this<!>]
+        val c: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>[<!NO_THIS!>this<!>]<!>
 )

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt

@@ -2,11 +2,11 @@
 @Repeatable
 annotation class Ann(val i: IntArray)
 
-@Ann(intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>))
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)<!>)
 @Ann(intArrayOf(i2))
-@Ann(intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>))
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>))
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(intArrayOf(<!TYPE_MISMATCH!>intArrayOf(i, i2, i3)<!>))
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!TYPE_MISMATCH!>intArrayOf(i, i2, i3)<!>)<!>)
 class Test
 
 var i = 1
@@ -19,6 +19,6 @@ fun foo(): Int = 1
 @Repeatable
 annotation class AnnAnn(val i: Array<Ann>)
 @AnnAnn(arrayOf(Ann(intArrayOf(1))))
-@AnnAnn(arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>))
+@AnnAnn(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>)<!>)
 class TestAnn
 val iAnn = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann(intArrayOf(1))<!>

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.kt

@@ -6,10 +6,10 @@ annotation class Ann(vararg val i: Int)
 @Ann(i2)
 @Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)
 @Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)
-@Ann(*intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>))
+@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)<!>)
 @Ann(*intArrayOf(i2))
-@Ann(*intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>))
+@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(*intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>))
+@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
 class Test
 
 var i = 1
@@ -22,6 +22,6 @@ fun foo(): Int = 1
 @Repeatable
 annotation class AnnAnn(vararg val i: Ann)
 @AnnAnn(*arrayOf(Ann(1)))
-@AnnAnn(*arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>))
+@AnnAnn(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>)<!>)
 class TestAnn
 val iAnn = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann(1)<!>

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.kt

@@ -0,0 +1,34 @@
+import kotlin.reflect.KClass
+
+annotation class Ann(
+        val a: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(readOnly)<!>,
+        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(withGetter)<!>,
+        val c: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(func())<!>,
+        val d: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>intArrayOf(ONE, twoWithGetter)<!>,
+        val e: IntArray = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>intArrayOf(ONE + twoWithGetter)<!>,
+        val f: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(mutable)<!>,
+        val g: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(mutableWithGetter)<!>,
+        val h: Array<KClass<*>> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>arrayOf(WithLateinit.kClass)<!>
+)
+
+const val ONE = 1
+
+val twoWithGetter
+    get() = 2
+
+val readOnly = ""
+
+val withGetter
+    get() = ""
+
+fun func() = ""
+
+var mutable = ""
+
+var mutableWithGetter
+    get() = ""
+    set(x) = TODO()
+
+object WithLateinit {
+    lateinit var kClass: KClass<*>
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.txt

@@ -0,0 +1,32 @@
+package
+
+public const val ONE: kotlin.Int = 1
+public var mutable: kotlin.String
+public var mutableWithGetter: kotlin.String
+public val readOnly: kotlin.String = ""
+public val twoWithGetter: kotlin.Int
+public val withGetter: kotlin.String
+public fun func(): kotlin.String
+
+public final annotation class Ann : kotlin.Annotation {
+    public constructor Ann(/*0*/ a: kotlin.Array<kotlin.String> = ..., /*1*/ b: kotlin.Array<kotlin.String> = ..., /*2*/ c: kotlin.Array<kotlin.String> = ..., /*3*/ d: kotlin.IntArray = ..., /*4*/ e: kotlin.IntArray = ..., /*5*/ f: kotlin.Array<kotlin.String> = ..., /*6*/ g: kotlin.Array<kotlin.String> = ..., /*7*/ h: kotlin.Array<kotlin.reflect.KClass<*>> = ...)
+    public final val a: kotlin.Array<kotlin.String>
+    public final val b: kotlin.Array<kotlin.String>
+    public final val c: kotlin.Array<kotlin.String>
+    public final val d: kotlin.IntArray
+    public final val e: kotlin.IntArray
+    public final val f: kotlin.Array<kotlin.String>
+    public final val g: kotlin.Array<kotlin.String>
+    public final val h: kotlin.Array<kotlin.reflect.KClass<*>>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object WithLateinit {
+    private constructor WithLateinit()
+    public final lateinit var kClass: kotlin.reflect.KClass<*>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestWithStdLibGenerated.java

@@ -328,6 +328,12 @@ public class DiagnosticsTestWithStdLibGenerated extends AbstractDiagnosticsTestW
                 doTest(fileName);
             }
 
+            @TestMetadata("nonConstValAsArgument.kt")
+            public void testNonConstValAsArgument() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("orderWithValue.kt")
             public void testOrderWithValue() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.kt");