Refactoring: rename parameter to argument for annotation diagnostics

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -218,9 +218,9 @@ public interface Errors {
     DiagnosticFactory0<PsiElement> ANNOTATION_CLASS_MEMBER = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtTypeReference> INVALID_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtTypeReference> NULLABLE_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtAnnotatedExpression> ANNOTATIONS_ON_BLOCK_LEVEL_EXPRESSION_ON_THE_SAME_LINE = DiagnosticFactory0.create(WARNING);
     DiagnosticFactory0<KtAnnotationEntry> ANNOTATION_USED_AS_ANNOTATION_ARGUMENT = DiagnosticFactory0.create(ERROR);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -818,9 +818,9 @@ public class DefaultErrorMessages {
         MAP.put(ANNOTATION_CLASS_MEMBER, "Members are not allowed in annotation class");
         MAP.put(INVALID_TYPE_OF_ANNOTATION_MEMBER, "Invalid type of annotation member");
         MAP.put(NULLABLE_TYPE_OF_ANNOTATION_MEMBER, "An annotation parameter cannot be nullable");
-        MAP.put(ANNOTATION_PARAMETER_MUST_BE_CONST, "An annotation parameter must be a compile-time constant");
+        MAP.put(ANNOTATION_ARGUMENT_MUST_BE_CONST, "An annotation argument must be a compile-time constant");
-        MAP.put(ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST, "An enum annotation parameter must be a enum constant");
+        MAP.put(ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST, "An enum annotation argument must be a enum constant");
-        MAP.put(ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL, "An annotation parameter must be a class literal (T::class)");
+        MAP.put(ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL, "An annotation argument must be a class literal (T::class)");
         MAP.put(ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, "Default value of annotation parameter must be a compile-time constant");
 
         MAP.put(ANNOTATIONS_ON_BLOCK_LEVEL_EXPRESSION_ON_THE_SAME_LINE,

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

@@ -120,9 +120,9 @@ class ConstantExpressionEvaluator(
 
         val descriptor = expressionType.constructor.declarationDescriptor
         val diagnosticFactory = when {
-            DescriptorUtils.isEnumClass(descriptor) -> Errors.ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST
+            DescriptorUtils.isEnumClass(descriptor) -> Errors.ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST
-            descriptor is ClassDescriptor && KotlinBuiltIns.isKClass(descriptor) -> Errors.ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL
+            descriptor is ClassDescriptor && KotlinBuiltIns.isKClass(descriptor) -> Errors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL
-            else -> Errors.ANNOTATION_PARAMETER_MUST_BE_CONST
+            else -> Errors.ANNOTATION_ARGUMENT_MUST_BE_CONST
         }
 
         trace.report(diagnosticFactory.on(argumentExpression))
@@ -156,7 +156,7 @@ class ConstantExpressionEvaluator(
             if (lhsExpression != null) {
                 val doubleColonLhs = trace.bindingContext.get(BindingContext.DOUBLE_COLON_LHS, lhsExpression)
                 if (doubleColonLhs is DoubleColonLHS.Expression && !doubleColonLhs.isObjectQualifier) {
-                    trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL.on(argumentExpression))
+                    trace.report(Errors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL.on(argumentExpression))
                 }
             }
         }

compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt

@@ -1,4 +1,4 @@
 // Functions can be recursively annotated
 annotation class ann(val x: Int)
-@ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>bar()<!>) fun foo() = 1
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>bar()<!>) fun foo() = 1
-@ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>foo()<!>) fun bar() = 2
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun bar() = 2

compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.kt

@@ -1,3 +1,3 @@
 // Function parameter CAN be recursively annotated
 annotation class ann(val x: Int)
-fun foo(@ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>foo(1)<!>) x: Int): Int = x
+fun foo(@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo(1)<!>) x: Int): Int = x

compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.kt

@@ -1,3 +1,3 @@
 // Functions can be recursively annotated
 annotation class ann(val x: Int)
-@ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>foo()<!>) fun foo() = 1
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun foo() = 1

compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.kt

@@ -1,5 +1,5 @@
 // Properties can be recursively annotated
 annotation class ann(val x: Int)
 class My {
-    @ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>x<!>) val x: Int = 1
+    @ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>x<!>) val x: Int = 1
 }

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt

@@ -2,5 +2,5 @@ annotation class Ann(vararg val i: Boolean)
 fun foo() {
     val bool1 = true
 
-    @Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>bool1<!>) val <!UNUSED_VARIABLE!>a<!> = bool1
+    @Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>bool1<!>) val <!UNUSED_VARIABLE!>a<!> = bool1
 }

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt

@@ -7,10 +7,10 @@ fun foo() {
     val a4 = a1 > a2
 
     @Ann(
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a2<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a3<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 > a2<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 > a2<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 == a2<!>
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 == a2<!>
     ) val b = 1
 }

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.kt

@@ -1,6 +1,6 @@
 annotation class AnnE(val i: MyEnum)
 
-@AnnE(<!ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST!>e<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST!>e<!>)
 class Test
 
 val e: MyEnum = MyEnum.A

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt

@@ -14,12 +14,12 @@ public class Test {
 annotation class Ann(vararg val i: Int)
 
 @Ann(
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i1<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i1<!>,
         Test.i2,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i3<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i3<!>,
         Test.i4,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i5<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i5<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i6<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i6<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test().i7<!>
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test().i7<!>
 )
 class A

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt

@@ -1,12 +1,12 @@
 annotation class Ann(vararg val i: Int)
 
 @Ann(
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i1<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i1<!>,
         i2,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>,
         i4,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i5<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i5<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i6<!>
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i6<!>
 )
 class Test
 

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt

@@ -4,15 +4,15 @@ enum class MyEnum {
     A
 }
 
-@AnnE(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"1" + MyEnum.A<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + MyEnum.A<!>)
 class Test
 
-@AnnE(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"1" + MyEnum::class<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + MyEnum::class<!>)
 class Test2
 
-@AnnE(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"1" + AnnE("23")<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + AnnE("23")<!>)
 class Test3
 
-@AnnE(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"1" + arrayOf("23", "34")<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + arrayOf("23", "34")<!>)
 class Test4
 

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt

@@ -12,17 +12,17 @@ fun foo() {
     val a5 = 1.0
 
     @Ann(
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a2<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a3<!>,
             "$topLevel",
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1"<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a1"<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1 $topLevel"<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a1 $topLevel"<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a4"<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a4"<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a5"<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a5"<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 + a2<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 + a2<!>,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"a" + a2<!>,
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"a" + a2<!>,
             "a" + topLevel,
-            <!ANNOTATION_PARAMETER_MUST_BE_CONST!>"a" + a4<!>
+            <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"a" + a4<!>
     ) val b = 1
 }

compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt

@@ -13,7 +13,7 @@ class C {
 
 fun foo() = "foo"
 
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL!>"foo"::class<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>"foo"::class<!>)
 fun test1() {}
 
 @Ann(String::class)
@@ -28,8 +28,8 @@ fun test5() {}
 @Ann(C.Companion::class)
 fun test6() {}
 
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL!>foo()::class<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>foo()::class<!>)
 fun test7() {}
 
-@AnnArray(arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL!>""::class<!>, String::class, AnObject::class))
+@AnnArray(arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>""::class<!>, String::class, AnObject::class))
 fun test8() {}

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

@@ -17,7 +17,7 @@ fun test1_0() {}
 @Ann1(*["a", "b"])
 fun test1_1() {}
 
-@Ann1(*<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["a", 1, <!OI;ANNOTATION_PARAMETER_MUST_BE_CONST!>null<!>]<!>)
+@Ann1(*<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["a", 1, <!OI;ANNOTATION_ARGUMENT_MUST_BE_CONST!>null<!>]<!>)
 fun test1_2() {}
 
 @Ann2(*[])

compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt

@@ -13,6 +13,6 @@ val a8 = 1.div(a2)
 val a9 = 2 * (<!DIVISION_BY_ZERO!>1.div(0)<!>)
 
 val b1: Byte = <!NI;TYPE_MISMATCH, DIVISION_BY_ZERO, TYPE_MISMATCH!>1 / 0<!>
-@Ann(<!DIVISION_BY_ZERO, ANNOTATION_PARAMETER_MUST_BE_CONST!>1 / 0<!>) val b2 = 1
+@Ann(<!DIVISION_BY_ZERO, ANNOTATION_ARGUMENT_MUST_BE_CONST!>1 / 0<!>) val b2 = 1
 
 annotation class Ann(val i : Int)

compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt

@@ -18,9 +18,9 @@ annotation class Ann(val x: Int)
 @Ann(A.X)
 fun main1() {}
 
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>A.Y<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>A.Y<!>)
 fun main2() {}
 
 val q = A()
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>q.z<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>q.z<!>)
 fun main3() {}

compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnClass.kt

@@ -15,13 +15,13 @@ annotation class Ann(
 )
 
 @Ann(
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>::class<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>::class<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Inner<!>::class<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Inner<!>::class<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Interface<!>::class<!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Interface<!>::class<!>,
         <!UNRESOLVED_REFERENCE!>CONST<!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Companion<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Companion<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
-        <!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Interface<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
+        <!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Interface<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
         <!UNRESOLVED_REFERENCE!>a<!>,
         <!UNRESOLVED_REFERENCE!>b<!>()
 )

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

@@ -2,11 +2,11 @@
 @Repeatable
 annotation class Ann(val i: IntArray)
 
-@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)<!>)
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>)<!>)
 @Ann(intArrayOf(i2))
-@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_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(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!TYPE_MISMATCH!>intArrayOf(i, i2, i3)<!>)<!>)
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>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(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>)<!>)
+@AnnAnn(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>iAnn<!>)<!>)
 class TestAnn
 val iAnn = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann(intArrayOf(1))<!>

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

@@ -4,14 +4,14 @@ annotation class Ann(val i: Int)
 annotation class AnnIA(val ia: IntArray)
 annotation class AnnSA(val sa: Array<String>)
 
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>MyClass().i<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>MyClass().i<!>)
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>)
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i2<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i2<!>)
-@AnnIA(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>ia<!>)
+@AnnIA(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>ia<!>)
-@AnnSA(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>sa<!>)
+@AnnSA(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>sa<!>)
 class Test {
     val i = 1
-    @Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>) val i2 = 1
+    @Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>) val i2 = 1
 }
 
 var i = 1

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

@@ -2,14 +2,14 @@
 @Repeatable
 annotation class Ann(vararg val i: Int)
 
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>)
 @Ann(i2)
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)
-@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)
-@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i<!>)<!>)
+@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>)<!>)
 @Ann(*intArrayOf(i2))
-@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>)<!>)
+@Ann(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_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(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_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(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>iAnn<!>)<!>)
+@AnnAnn(*<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>iAnn<!>)<!>)
 class TestAnn
 val iAnn = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann(1)<!>

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.kt

@@ -12,9 +12,9 @@ class A2
 @Ann3(arrayOf(A1::class, A2::class))
 class MyClass1
 
-@Ann1(<!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>A3<!>::class<!>)
+@Ann1(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>A3<!>::class<!>)
 class MyClass2
 
 val x = A1::class
-@Ann1(<!ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL!>x<!>)
+@Ann1(<!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>x<!>)
 class MyClass3

idea/src/org/jetbrains/kotlin/idea/quickfix/AddAnnotationTargetFix.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.search.restrictToKotlinSources
@@ -65,6 +66,8 @@ class AddAnnotationTargetFix(annotationEntry: KtAnnotationEntry) : KotlinQuickFi
         }
 
         override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtAnnotationEntry>? {
+            if (diagnostic.factory != Errors.WRONG_ANNOTATION_TARGET) return null
+
             val entry = diagnostic.psiElement as? KtAnnotationEntry ?: return null
             val annotationClass = entry.toAnnotationClass() ?: return null
             if (entry.useSiteTarget != null && entry.getRequiredAnnotationTargets(annotationClass, entry.project).isEmpty()) return null

idea/testData/quickfix/moveReceiverAnnotation/notExtensionFun.kt

@@ -1,5 +1,5 @@
 // "Move annotation to receiver type" "false"
-// ERROR: This annotation is not applicable to target 'top level function' and use site target '@receiver'
+// ERROR: This annotation is not applicable to target 'declaration' and use site target '@receiver'
 // ACTION: Make internal
 // ACTION: Make private
 

idea/testData/quickfix/moveReceiverAnnotation/notExtensionVal.kt

@@ -1,5 +1,5 @@
 // "Move annotation to receiver type" "false"
-// ERROR: This annotation is not applicable to target 'top level property without backing field or delegate' and use site target '@receiver'
+// ERROR: This annotation is not applicable to target 'declaration' and use site target '@receiver'
 // ACTION: Make internal
 // ACTION: Make private
 // ACTION: Specify type explicitly

idea/testData/quickfix/removeAtFromAnnotationArgument/namedParam.kt

@@ -1,5 +1,5 @@
 // "Remove @ from annotation argument" "true"
-// ERROR: An annotation parameter must be a compile-time constant
+// ERROR: An annotation argument must be a compile-time constant
 
 annotation class Y()
 annotation class X(val value: Y, val y: Y)

idea/testData/quickfix/removeAtFromAnnotationArgument/namedParam.kt.after

@@ -1,5 +1,5 @@
 // "Remove @ from annotation argument" "true"
-// ERROR: An annotation parameter must be a compile-time constant
+// ERROR: An annotation argument must be a compile-time constant
 
 annotation class Y()
 annotation class X(val value: Y, val y: Y)

idea/testData/quickfix/removeAtFromAnnotationArgument/simple.kt

@@ -1,5 +1,5 @@
 // "Remove @ from annotation argument" "true"
-// ERROR: An annotation parameter must be a compile-time constant
+// ERROR: An annotation argument must be a compile-time constant
 
 annotation class Y()
 annotation class X(val value: Y)

idea/testData/quickfix/removeAtFromAnnotationArgument/simple.kt.after

@@ -1,5 +1,5 @@
 // "Remove @ from annotation argument" "true"
-// ERROR: An annotation parameter must be a compile-time constant
+// ERROR: An annotation argument must be a compile-time constant
 
 annotation class Y()
 annotation class X(val value: Y)

jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/build.log

@@ -21,4 +21,4 @@ Exit code: ABORT
 ------------------------------------------
 COMPILATION FAILED
 Unresolved reference: test
-An annotation parameter must be a compile-time constant
+An annotation argument must be a compile-time constant

plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.kt

@@ -10,7 +10,7 @@
 // EXPECTED_ERROR(kotlin:32:5) cannot find symbol
 // EXPECTED_ERROR(kotlin:35:5) cannot find symbol
 
-@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_PARAMETER_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION")
+@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_ARGUMENT_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION")
 import kotlin.reflect.KClass
 
 @Anno(ABC::class)

plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.kt

@@ -3,7 +3,7 @@
 // NO_VALIDATION
 // WITH_RUNTIME
 
-@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_PARAMETER_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION", "UNSUPPORTED_FEATURE")
+@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_ARGUMENT_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION", "UNSUPPORTED_FEATURE")
 import java.util.Calendar
 import kotlin.reflect.KClass
 

plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.txt

@@ -34,7 +34,7 @@ public final class MyType<T extends java.lang.Object> {
 import java.util.Calendar;
 import kotlin.reflect.KClass;
 
-@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE", "ANNOTATION_PARAMETER_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION", "UNSUPPORTED_FEATURE"})
+@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE", "ANNOTATION_ARGUMENT_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION", "UNSUPPORTED_FEATURE"})
 @kotlin.Metadata()
 public final class NonExistentClassTypesConversionKt {
 }