From 6086cd2cf4906ec22eceb635070418e668017d26 Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Mon, 12 Mar 2018 02:10:25 +0300 Subject: [PATCH] Prohibit non-const expressions through varargs in annotations Fixes #KT-23153 for Kotlin 1.3 The problem was in the type check of expression type against expected type. When feature `AssigningArraysToVarargsInNamedFormInAnnotations` (KT-20171) appeared, expected type could be wrong, which led to failed type check --- .../jetbrains/kotlin/diagnostics/Errors.java | 1 + .../rendering/DefaultErrorMessages.java | 1 + .../kotlin/resolve/calls/CallResolverUtil.kt | 82 +++++++++++-------- .../AssigningNamedArgumentToVarargChecker.kt | 17 +--- .../evaluate/ConstantExpressionEvaluator.kt | 53 +++++++++--- ...tSingleArrayElementAsVarargInAnnotation.kt | 26 ++++++ ...SingleArrayElementAsVarargInAnnotation.txt | 19 +++++ ...leArrayElementAsVarargInAnnotationError.kt | 26 ++++++ ...eArrayElementAsVarargInAnnotationError.txt | 19 +++++ .../checkers/DiagnosticsTestGenerated.java | 12 +++ .../DiagnosticsUsingJavacTestGenerated.java | 12 +++ .../kotlin/config/LanguageVersionSettings.kt | 1 + 12 files changed, 209 insertions(+), 60 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt create mode 100644 compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.txt create mode 100644 compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt create mode 100644 compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.txt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 4e223819622..c71a9086ba7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -224,6 +224,7 @@ public interface Errors { DiagnosticFactory0 ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 ANNOTATIONS_ON_BLOCK_LEVEL_EXPRESSION_ON_THE_SAME_LINE = DiagnosticFactory0.create(WARNING); DiagnosticFactory0 ANNOTATION_USED_AS_ANNOTATION_ARGUMENT = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 ANNOTATION_ARGUMENT_IS_NON_CONST = DiagnosticFactory0.create(WARNING); DiagnosticFactory1 ILLEGAL_KOTLIN_VERSION_STRING_VALUE = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 NEWER_VERSION_IN_SINCE_KOTLIN = DiagnosticFactory1.create(WARNING); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index c130542748f..dcde8e2f84e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -828,6 +828,7 @@ public class DefaultErrorMessages { "Use new line if whole block-level expression must be annotated or wrap annotated expression in parentheses"); MAP.put(ANNOTATION_USED_AS_ANNOTATION_ARGUMENT, "An annotation can't be used as the annotations argument"); + MAP.put(ANNOTATION_ARGUMENT_IS_NON_CONST, "An annotation argument must be a compile-time constant"); MAP.put(CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT, "Const 'val' are only allowed on top level or in objects"); MAP.put(CONST_VAL_WITH_DELEGATE, "Const 'val' should not have a delegate"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt index 2895a4c2a63..3597ef09a6d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.resolve.calls.callResolverUtil @@ -22,11 +11,13 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.ReflectionTypes import org.jetbrains.kotlin.builtins.isSuspendFunctionType import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor import org.jetbrains.kotlin.lexer.KtToken import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.calls.CallTransformer import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall import org.jetbrains.kotlin.resolve.calls.callUtil.getValueArgumentForExpression @@ -36,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION import org.jetbrains.kotlin.resolve.calls.inference.getNestedTypeVariables import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch +import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate import org.jetbrains.kotlin.resolve.descriptorUtil.isParameterOfAnnotation @@ -186,41 +178,65 @@ fun getSuperCallExpression(call: Call): KtSuperExpression? { fun getEffectiveExpectedType( parameterDescriptor: ValueParameterDescriptor, - argument: ValueArgument, - context: ResolutionContext<*> + resolvedArgument: ResolvedValueArgument, + languageVersionSettings: LanguageVersionSettings, + trace: BindingTrace ): KotlinType { - if (argument.getSpreadElement() != null || shouldCheckAsArray(parameterDescriptor, argument, context)) { - if (parameterDescriptor.varargElementType == null) { - // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper - return DONT_CARE - } - return parameterDescriptor.type - } - val varargElementType = parameterDescriptor.varargElementType - if (varargElementType != null) { - return varargElementType - } - - return parameterDescriptor.type + val argument = resolvedArgument.arguments.singleOrNull() + return if (argument != null) + getEffectiveExpectedTypeForSingleArgument(parameterDescriptor, argument, languageVersionSettings, trace) + else + getExpectedType(parameterDescriptor) } -private fun shouldCheckAsArray( +fun getEffectiveExpectedType( parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument, context: ResolutionContext<*> +): KotlinType { + return getEffectiveExpectedTypeForSingleArgument(parameterDescriptor, argument, context.languageVersionSettings, context.trace) +} + +fun getEffectiveExpectedTypeForSingleArgument( + parameterDescriptor: ValueParameterDescriptor, + argument: ValueArgument, + languageVersionSettings: LanguageVersionSettings, + trace: BindingTrace +): KotlinType { + if (argument.getSpreadElement() != null) { + // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper + return if (parameterDescriptor.varargElementType == null) DONT_CARE else parameterDescriptor.type + } + + if (arrayAssignmentToVarargInNamedFormInAnnotation(parameterDescriptor, argument, languageVersionSettings, trace)) { + return parameterDescriptor.type + } + + return getExpectedType(parameterDescriptor) +} + +private fun getExpectedType(parameterDescriptor: ValueParameterDescriptor): KotlinType { + return parameterDescriptor.varargElementType ?: parameterDescriptor.type +} + +private fun arrayAssignmentToVarargInNamedFormInAnnotation( + parameterDescriptor: ValueParameterDescriptor, + argument: ValueArgument, + languageVersionSettings: LanguageVersionSettings, + trace: BindingTrace ): Boolean { - if (!context.languageVersionSettings.supportsFeature(LanguageFeature.AssigningArraysToVarargsInNamedFormInAnnotations)) return false + if (!languageVersionSettings.supportsFeature(LanguageFeature.AssigningArraysToVarargsInNamedFormInAnnotations)) return false if (!isParameterOfAnnotation(parameterDescriptor)) return false - return argument.isNamed() && parameterDescriptor.isVararg && isArrayOrArrayLiteral(argument, context) + return argument.isNamed() && parameterDescriptor.isVararg && isArrayOrArrayLiteral(argument, trace) } -fun isArrayOrArrayLiteral(argument: ValueArgument, context: ResolutionContext<*>): Boolean { +fun isArrayOrArrayLiteral(argument: ValueArgument, trace: BindingTrace): Boolean { val argumentExpression = argument.getArgumentExpression() ?: return false if (argumentExpression is KtCollectionLiteralExpression) return true - val type = context.trace.getType(argumentExpression) ?: return false + val type = trace.getType(argumentExpression) ?: return false return KotlinBuiltIns.isArrayOrPrimitiveArray(type) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt index 59f33e821a1..957668cf8fa 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.resolve.calls.checkers @@ -61,7 +50,7 @@ class AssigningNamedArgumentToVarargChecker : CallChecker { argumentExpression: KtExpression, context: ResolutionContext<*> ) { - if (isArrayOrArrayLiteral(argument, context)) { + if (isArrayOrArrayLiteral(argument, context.trace)) { if (argument.hasSpread()) { context.trace.report(Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION.on(argumentExpression)) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index b1ecfd0ce28..0e1ca65722c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.BindingContext.COLLECTION_LITERAL_CALL +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument @@ -86,8 +87,9 @@ class ConstantExpressionEvaluator( val varargElementType = parameterDescriptor.varargElementType val argumentsAsVararg = varargElementType != null && !hasSpread(resolvedArgument) val constantType = if (argumentsAsVararg) varargElementType else parameterDescriptor.type - val compileTimeConstants = resolveAnnotationValueArguments(resolvedArgument, constantType!!, trace) - val constants = compileTimeConstants.map { it.toConstantValue(constantType) } + val expectedType = getEffectiveExpectedType(parameterDescriptor, resolvedArgument, languageVersionSettings, trace) + val compileTimeConstants = resolveAnnotationValueArguments(resolvedArgument, constantType!!, expectedType, trace) + val constants = compileTimeConstants.map { it.toConstantValue(expectedType) } if (argumentsAsVararg) { if (isArrayPassedInNamedForm(constants, resolvedArgument)) return constants.single() @@ -110,11 +112,12 @@ class ConstantExpressionEvaluator( private fun checkCompileTimeConstant( argumentExpression: KtExpression, expressionType: KotlinType, - trace: BindingTrace + trace: BindingTrace, + useDeprecationWarning: Boolean ) { val constant = ConstantExpressionEvaluator.getConstant(argumentExpression, trace.bindingContext) if (constant != null && constant.canBeUsedInAnnotations) { - checkInnerPartsOfCompileTimeConstant(constant, trace, argumentExpression) + checkInnerPartsOfCompileTimeConstant(constant, trace, argumentExpression, useDeprecationWarning) return } @@ -125,13 +128,17 @@ class ConstantExpressionEvaluator( else -> Errors.ANNOTATION_ARGUMENT_MUST_BE_CONST } - trace.report(diagnosticFactory.on(argumentExpression)) + if (useDeprecationWarning) + reportDeprecationWarningOnNonConst(argumentExpression, trace) + else + trace.report(diagnosticFactory.on(argumentExpression)) } private fun checkInnerPartsOfCompileTimeConstant( constant: CompileTimeConstant<*>, trace: BindingTrace, - argumentExpression: KtExpression + argumentExpression: KtExpression, + useDeprecationWarning: Boolean ) { // array(1, null, 3) - error should be reported on inner expression val callArguments = when (argumentExpression) { @@ -143,12 +150,17 @@ class ConstantExpressionEvaluator( if (callArguments != null) { for (argument in callArguments) { val type = trace.getType(argument) ?: continue - checkCompileTimeConstant(argument, type, trace) + checkCompileTimeConstant(argument, type, trace, useDeprecationWarning) } } if (constant.usesNonConstValAsConstant) { - trace.report(Errors.NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION.on(argumentExpression)) + if (useDeprecationWarning) { + reportDeprecationWarningOnNonConst(argumentExpression, trace) + } else { + trace.report(Errors.NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION.on(argumentExpression)) + } + } if (argumentExpression is KtClassLiteralExpression) { @@ -156,12 +168,20 @@ 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_ARGUMENT_MUST_BE_KCLASS_LITERAL.on(argumentExpression)) + if (useDeprecationWarning) { + reportDeprecationWarningOnNonConst(argumentExpression, trace) + } else { + trace.report(Errors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL.on(argumentExpression)) + } } } } } + private fun reportDeprecationWarningOnNonConst(expression: KtExpression, trace: BindingTrace) { + trace.report(Errors.ANNOTATION_ARGUMENT_IS_NON_CONST.on(expression)) + } + private fun getArgumentExpressionsForArrayCall( expression: KtCallExpression, trace: BindingTrace @@ -203,6 +223,7 @@ class ConstantExpressionEvaluator( private fun resolveAnnotationValueArguments( resolvedValueArgument: ResolvedValueArgument, + deprecatedExpectedType: KotlinType, expectedType: KotlinType, trace: BindingTrace ): List> { @@ -220,12 +241,18 @@ class ConstantExpressionEvaluator( val expressionType = trace.getType(argumentExpression) ?: continue - if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) { - // TYPE_MISMATCH should be reported otherwise - continue + // this type check should not used as it can introduce subtle bugs when type checking rules against expected type are changing + if (!languageVersionSettings.supportsFeature(LanguageFeature.ProhibitNonConstValuesAsVarargsInAnnotations) && + !KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, deprecatedExpectedType) + ) { + if (KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) { + checkCompileTimeConstant(argumentExpression, expressionType, trace, useDeprecationWarning = true) + } + + continue // TYPE_MISMATCH should be reported otherwise } - checkCompileTimeConstant(argumentExpression, expressionType, trace) + checkCompileTimeConstant(argumentExpression, expressionType, trace, useDeprecationWarning = false) } return constants } diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt new file mode 100644 index 00000000000..6c91a7167ff --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: -ProhibitNonConstValuesAsVarargsInAnnotations + +val nonConstArray = longArrayOf(0) +fun nonConstFun(): LongArray = TODO() + +fun nonConstLong(): Long = TODO() + +annotation class Anno(vararg val value: Long) + +@Anno(value = nonConstArray) +fun foo1() {} + +@Anno(value = nonConstFun()) +fun foo2() {} + +@Anno(value = longArrayOf(nonConstLong())) +fun foo3() {} + +@Anno(value = [nonConstLong()]) +fun foo4() {} + +@Anno(value = *nonConstArray) +fun bar1() {} + +@Anno(*nonConstArray) +fun bar2() {} diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.txt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.txt new file mode 100644 index 00000000000..e3c19226fb6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.txt @@ -0,0 +1,19 @@ +package + +public val nonConstArray: kotlin.LongArray +@Anno public fun bar1(): kotlin.Unit +@Anno public fun bar2(): kotlin.Unit +@Anno(value = {}) public fun foo1(): kotlin.Unit +@Anno(value = {}) public fun foo2(): kotlin.Unit +@Anno(value = {}) public fun foo3(): kotlin.Unit +@Anno(value = {}) public fun foo4(): kotlin.Unit +public fun nonConstFun(): kotlin.LongArray +public fun nonConstLong(): kotlin.Long + +public final annotation class Anno : kotlin.Annotation { + public constructor Anno(/*0*/ vararg value: kotlin.Long /*kotlin.LongArray*/) + public final val value: kotlin.LongArray + 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 +} diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt new file mode 100644 index 00000000000..42c7d800502 --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: +ProhibitNonConstValuesAsVarargsInAnnotations + +val nonConstArray = longArrayOf(0) +fun nonConstFun(): LongArray = TODO() + +fun nonConstLong(): Long = TODO() + +annotation class Anno(vararg val value: Long) + +@Anno(value = nonConstArray) +fun foo1() {} + +@Anno(value = nonConstFun()) +fun foo2() {} + +@Anno(value = longArrayOf(nonConstLong())) +fun foo3() {} + +@Anno(value = [nonConstLong()]) +fun foo4() {} + +@Anno(value = *nonConstArray) +fun bar1() {} + +@Anno(*nonConstArray) +fun bar2() {} diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.txt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.txt new file mode 100644 index 00000000000..e3c19226fb6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.txt @@ -0,0 +1,19 @@ +package + +public val nonConstArray: kotlin.LongArray +@Anno public fun bar1(): kotlin.Unit +@Anno public fun bar2(): kotlin.Unit +@Anno(value = {}) public fun foo1(): kotlin.Unit +@Anno(value = {}) public fun foo2(): kotlin.Unit +@Anno(value = {}) public fun foo3(): kotlin.Unit +@Anno(value = {}) public fun foo4(): kotlin.Unit +public fun nonConstFun(): kotlin.LongArray +public fun nonConstLong(): kotlin.Long + +public final annotation class Anno : kotlin.Annotation { + public constructor Anno(/*0*/ vararg value: kotlin.Long /*kotlin.LongArray*/) + public final val value: kotlin.LongArray + 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 +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index cb324234de9..5087109700c 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -24536,6 +24536,18 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotationError.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotationError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt"); + doTest(fileName); + } + @TestMetadata("assigningArraysToVarargsInAnnotations.kt") public void testAssigningArraysToVarargsInAnnotations() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index d3572ca970c..3cc2dc981ee 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -24536,6 +24536,18 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing doTest(fileName); } + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotationError.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotationError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt"); + doTest(fileName); + } + @TestMetadata("assigningArraysToVarargsInAnnotations.kt") public void testAssigningArraysToVarargsInAnnotations() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt"); diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 63aaa2cdb1a..f091f0e07ca 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -67,6 +67,7 @@ enum class LanguageFeature( JvmStaticInInterface(KOTLIN_1_3), InlineClasses(KOTLIN_1_3), ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion(KOTLIN_1_3), + ProhibitNonConstValuesAsVarargsInAnnotations(KOTLIN_1_3), StrictJavaNullabilityAssertions(sinceVersion = null, defaultState = State.DISABLED), ProperIeee754Comparisons(sinceVersion = null, defaultState = State.DISABLED),