azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring: rename parameter to argument for annotation diagnostics

Browse Source
This commit is contained in:
Mikhail Zarechenskiy
2018-03-07 14:38:01 +03:00
parent baf16895f2
commit 4ebd11a7ae
34 changed files with 91 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+3 -3
View File
@@ -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_PARAMETER_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL = 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
+3 -3
View File
@@ -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_PARAMETER_MUST_BE_ENUM_CONST, "An enum annotation parameter 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_CONST, "An annotation argument must be a compile-time constant");
MAP.put(ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST, "An enum annotation argument must be a enum constant");
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
+4 -4
View File
@@ -120,9 +120,9 @@ class ConstantExpressionEvaluator(
val descriptor = expressionType.constructor.declarationDescriptor
val diagnosticFactory = when {
DescriptorUtils.isEnumClass(descriptor) -> Errors.ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST
descriptor is ClassDescriptor && KotlinBuiltIns.isKClass(descriptor) -> Errors.ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL
else -> Errors.ANNOTATION_PARAMETER_MUST_BE_CONST
DescriptorUtils.isEnumClass(descriptor) -> Errors.ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST
descriptor is ClassDescriptor && KotlinBuiltIns.isKClass(descriptor) -> Errors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL
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
Vendored
+2 -2
View File
@@ -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_PARAMETER_MUST_BE_CONST!>foo()<!>) fun bar() = 2
@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>bar()<!>) fun foo() = 1
@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun bar() = 2
compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.kt
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+5 -5
View File
@@ -7,10 +7,10 @@ fun foo() {
val a4 = a1 > a2
@Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 > a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 == a2<!>
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a3<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 > a2<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 == a2<!>
) val b = 1
}
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.kt
Vendored
+1 -1
View File
@@ -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
Vendored
+5 -5
View File
@@ -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_PARAMETER_MUST_BE_CONST!>Test.i6<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test().i7<!>
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i5<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test.i6<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test().i7<!>
)
class A
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt
Vendored
+4 -4
View File
@@ -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_PARAMETER_MUST_BE_CONST!>i6<!>
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i5<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i6<!>
)
class Test
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt
Vendored
+4 -4
View File
@@ -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
Vendored
+10 -10
View File
@@ -12,17 +12,17 @@ fun foo() {
val a5 = 1.0
@Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a3<!>,
"$topLevel",
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1 $topLevel"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a4"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a5"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 + a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"a" + a2<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a1"<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a1 $topLevel"<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a4"<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"$a5"<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>a1 + 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
Vendored
+3 -3
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+2 -2
View File
@@ -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
Vendored
+6 -6
View File
@@ -15,13 +15,13 @@ annotation class Ann(
)
@Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>::class<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Inner<!>::class<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Interface<!>::class<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>::class<!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Inner<!>::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_PARAMETER_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!>Companion<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>CONST<!><!>,
<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>Nested<!>.<!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
Vendored
+5 -5
View File
@@ -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_PARAMETER_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_PARAMETER_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(<!ANNOTATION_ARGUMENT_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, 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
Vendored
+6 -6
View File
@@ -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_PARAMETER_MUST_BE_CONST!>i<!>)
@Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i2<!>)
@AnnIA(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>ia<!>)
@AnnSA(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>sa<!>)
@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>MyClass().i<!>)
@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>)
@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i2<!>)
@AnnIA(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>ia<!>)
@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
Vendored
+7 -7
View File
@@ -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_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<!>)<!>)
@Ann(<!ANNOTATION_ARGUMENT_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_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_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!>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
Vendored
+2 -2
View File
@@ -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
+3
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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
Vendored
+1 -1
View File
@@ -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 {
}