From e20b354dbd8d037a931a03b22c026fe532aecb31 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 28 Jul 2021 01:10:43 +0200 Subject: [PATCH] Check repeatable annotation container parameters, retention, target #KT-12794 #KT-47928 --- ...irOldFrontendDiagnosticsTestGenerated.java | 30 ++++ ...DiagnosticsWithLightTreeTestGenerated.java | 30 ++++ .../jvm/checkers/ExplicitMetadataChecker.kt | 2 + .../checkers/FileClassAnnotationsChecker.kt | 1 + .../checkers/RepeatableAnnotationChecker.kt | 118 ++++++++++++- .../diagnostics/DefaultErrorMessagesJvm.java | 10 +- .../resolve/jvm/diagnostics/ErrorsJvm.java | 12 ++ .../kotlin/resolve/AnnotationChecker.kt | 3 +- ...entalMarkerDeclarationAnnotationChecker.kt | 3 +- .../repeatable/containerArguments_1_5.fir.kt | 50 ++++++ .../repeatable/containerArguments_1_5.kt | 50 ++++++ .../repeatable/containerArguments_1_5.txt | 163 ++++++++++++++++++ .../repeatable/containerArguments_1_6.fir.kt | 50 ++++++ .../repeatable/containerArguments_1_6.kt | 50 ++++++ .../repeatable/containerArguments_1_6.txt | 163 ++++++++++++++++++ .../repeatable/containerRetention_1_5.fir.kt | 40 +++++ .../repeatable/containerRetention_1_5.kt | 40 +++++ .../repeatable/containerRetention_1_5.txt | 91 ++++++++++ .../repeatable/containerRetention_1_6.fir.kt | 40 +++++ .../repeatable/containerRetention_1_6.kt | 40 +++++ .../repeatable/containerRetention_1_6.txt | 91 ++++++++++ .../repeatable/containerTarget_1_6.fir.kt | 53 ++++++ .../repeatable/containerTarget_1_6.kt | 53 ++++++ .../repeatable/containerTarget_1_6.txt | 121 +++++++++++++ .../test/runners/DiagnosticTestGenerated.java | 30 ++++ .../kotlin/config/LanguageVersionSettings.kt | 1 + ...CompilerTestFE10TestdataTestGenerated.java | 30 ++++ .../resolve/diagnostics/JsQualifierChecker.kt | 2 + 28 files changed, 1362 insertions(+), 5 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.fir.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.txt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.fir.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.txt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.fir.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.txt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.fir.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.txt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.fir.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt create mode 100644 compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.txt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index a9dbfb74bad..b09e6db1beb 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -2106,6 +2106,36 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_6.kt"); } + @Test + @TestMetadata("containerArguments_1_5.kt") + public void testContainerArguments_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt"); + } + + @Test + @TestMetadata("containerArguments_1_6.kt") + public void testContainerArguments_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt"); + } + + @Test + @TestMetadata("containerRetention_1_5.kt") + public void testContainerRetention_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt"); + } + + @Test + @TestMetadata("containerRetention_1_6.kt") + public void testContainerRetention_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt"); + } + + @Test + @TestMetadata("containerTarget_1_6.kt") + public void testContainerTarget_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt"); + } + @Test @TestMetadata("javaRepeatableJvmTarget6.kt") public void testJavaRepeatableJvmTarget6() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 843711b224b..13a59f03986 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -2106,6 +2106,36 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_6.kt"); } + @Test + @TestMetadata("containerArguments_1_5.kt") + public void testContainerArguments_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt"); + } + + @Test + @TestMetadata("containerArguments_1_6.kt") + public void testContainerArguments_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt"); + } + + @Test + @TestMetadata("containerRetention_1_5.kt") + public void testContainerRetention_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt"); + } + + @Test + @TestMetadata("containerRetention_1_6.kt") + public void testContainerRetention_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt"); + } + + @Test + @TestMetadata("containerTarget_1_6.kt") + public void testContainerTarget_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt"); + } + @Test @TestMetadata("javaRepeatableJvmTarget6.kt") public void testJavaRepeatableJvmTarget6() throws Exception { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ExplicitMetadataChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ExplicitMetadataChecker.kt index 12e04fa1b09..2adf1f8b745 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ExplicitMetadataChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ExplicitMetadataChecker.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.jvm.checkers import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.psi.KtAnnotated import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker import org.jetbrains.kotlin.resolve.BindingContext @@ -21,6 +22,7 @@ object ExplicitMetadataChecker : AdditionalAnnotationChecker { entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) { for (entry in entries) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/FileClassAnnotationsChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/FileClassAnnotationsChecker.kt index fe5c973a36b..eae5816c4b9 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/FileClassAnnotationsChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/FileClassAnnotationsChecker.kt @@ -41,6 +41,7 @@ object FileClassAnnotationsChecker : AdditionalAnnotationChecker { entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) { val fileAnnotationsToCheck = arrayListOf>() diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/RepeatableAnnotationChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/RepeatableAnnotationChecker.kt index 2987f61c586..65b1ec05497 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/RepeatableAnnotationChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/RepeatableAnnotationChecker.kt @@ -5,37 +5,48 @@ package org.jetbrains.kotlin.resolve.jvm.checkers +import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.KtAnnotated import org.jetbrains.kotlin.psi.KtAnnotationEntry +import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker +import org.jetbrains.kotlin.resolve.AnnotationChecker import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.constants.KClassValue import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention import org.jetbrains.kotlin.resolve.descriptorUtil.isAnnotatedWithKotlinRepeatable import org.jetbrains.kotlin.resolve.jvm.JvmPlatformAnnotationFeaturesSupport import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm +import org.jetbrains.kotlin.types.TypeUtils class RepeatableAnnotationChecker( - languageVersionSettings: LanguageVersionSettings, + private val languageVersionSettings: LanguageVersionSettings, private val jvmTarget: JvmTarget, private val platformAnnotationFeaturesSupport: JvmPlatformAnnotationFeaturesSupport, + private val module: ModuleDescriptor, ) : AdditionalAnnotationChecker { override fun checkEntries( entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) { if (entries.isEmpty()) return @@ -49,6 +60,20 @@ class RepeatableAnnotationChecker( } checkRepeatedEntries(annotations, trace) + + if (annotated is KtClassOrObject && annotated.hasModifier(KtTokens.ANNOTATION_KEYWORD)) { + val annotationClass = trace.get(BindingContext.CLASS, annotated) + val repeatable = annotations.find { it.descriptor.fqName == JvmAnnotationNames.REPEATABLE_ANNOTATION } + if (annotationClass != null && repeatable != null) { + val containerKClassValue = repeatable.descriptor.allValueArguments[Name.identifier("value")] + if (containerKClassValue is KClassValue) { + val containerClass = TypeUtils.getClassDescriptor(containerKClassValue.getArgumentType(module)) + if (containerClass != null) { + checkRepeatableAnnotationContainer(annotationClass, containerClass, trace, repeatable.entry) + } + } + } + } } private fun checkRepeatedEntries(annotations: List, trace: BindingTrace) { @@ -88,6 +113,97 @@ class RepeatableAnnotationChecker( } } + private fun checkRepeatableAnnotationContainer( + annotationClass: ClassDescriptor, + containerClass: ClassDescriptor, + trace: BindingTrace, + reportOn: KtAnnotationEntry, + ) { + checkContainerParameters(containerClass, annotationClass, reportOn)?.let(trace::report) + checkContainerRetention(containerClass, annotationClass, reportOn)?.let(trace::report) + checkContainerTarget(containerClass, annotationClass, reportOn)?.let(trace::report) + } + + private fun checkContainerParameters( + containerClass: ClassDescriptor, + annotationClass: ClassDescriptor, + reportOn: KtAnnotationEntry, + ): Diagnostic? { + val containerCtor = containerClass.unsubstitutedPrimaryConstructor ?: return null + + val value = containerCtor.valueParameters.find { it.name.asString() == "value" } + if (value == null || !KotlinBuiltIns.isArray(value.type) || + value.type.arguments.single().type.constructor.declarationDescriptor != annotationClass + ) { + return select( + ErrorsJvm.REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY, ErrorsJvm.REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY_ERROR + ).on(reportOn, containerClass.fqNameSafe, annotationClass.fqNameSafe) + } + + val otherNonDefault = containerCtor.valueParameters.find { it.name.asString() != "value" && !it.declaresDefaultValue() } + if (otherNonDefault != null) { + return select( + ErrorsJvm.REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER, ErrorsJvm.REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER_ERROR + ).on(reportOn, containerClass.fqNameSafe, otherNonDefault) + } + + return null + } + + private fun checkContainerRetention( + containerClass: ClassDescriptor, + annotationClass: ClassDescriptor, + reportOn: KtAnnotationEntry, + ): Diagnostic? { + val annotationRetention = annotationClass.getAnnotationRetention() ?: KotlinRetention.RUNTIME + val containerRetention = containerClass.getAnnotationRetention() ?: KotlinRetention.RUNTIME + if (containerRetention > annotationRetention) { + return select( + ErrorsJvm.REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION, ErrorsJvm.REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION_ERROR + ).on(reportOn, containerClass.fqNameSafe, containerRetention.name, annotationClass.fqNameSafe, annotationRetention.name) + } + return null + } + + private fun checkContainerTarget( + containerClass: ClassDescriptor, + annotationClass: ClassDescriptor, + reportOn: KtAnnotationEntry, + ): Diagnostic? { + val annotationTargets = AnnotationChecker.applicableTargetSet(annotationClass) ?: KotlinTarget.DEFAULT_TARGET_SET + val containerTargets = AnnotationChecker.applicableTargetSet(containerClass) ?: KotlinTarget.DEFAULT_TARGET_SET + + // See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.6.3. + // (TBH, the rules about TYPE/TYPE_USE and TYPE_PARAMETER/TYPE_USE don't seem to make a lot of sense, but it's JLS + // so we better obey it for full interop with the Java language and reflection.) + for (target in containerTargets) { + val ok = when (target) { + in annotationTargets -> true + KotlinTarget.ANNOTATION_CLASS -> + KotlinTarget.CLASS in annotationTargets || + KotlinTarget.TYPE in annotationTargets + KotlinTarget.CLASS -> + KotlinTarget.TYPE in annotationTargets + KotlinTarget.TYPE_PARAMETER -> + KotlinTarget.TYPE in annotationTargets + else -> false + } + if (!ok) { + return select( + ErrorsJvm.REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET, ErrorsJvm.REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET_ERROR + ).on(reportOn, containerClass.fqNameSafe, annotationClass.fqNameSafe) + } + } + + return null + } + + private fun select(warning: D, error: D): D = + if (languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotationContainerConstraints)) + error + else + warning + private fun isRepeatableAnnotation(classDescriptor: ClassDescriptor): Boolean = classDescriptor.isAnnotatedWithKotlinRepeatable() || platformAnnotationFeaturesSupport.isRepeatableAnnotationClass(classDescriptor) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java index 3d7ed0fc0e4..b7dd06596f4 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.utils.StringsKt; import java.util.List; import static kotlin.collections.CollectionsKt.*; -import static org.jetbrains.kotlin.diagnostics.Errors.UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION; import static org.jetbrains.kotlin.diagnostics.rendering.Renderers.*; import static org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.*; @@ -76,6 +75,15 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { MAP.put(REPEATED_ANNOTATION_WITH_CONTAINER, "Repeated annotation ''@{0}'' cannot be used on a declaration which is annotated with its container annotation ''@{1}''", TO_STRING, TO_STRING); MAP.put(ANNOTATION_IS_NOT_APPLICABLE_TO_MULTIFILE_CLASSES, "Annotation ''@{0}'' is not applicable to the multi-file classes", TO_STRING); + MAP.put(REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY, "Container annotation ''{0}'' must have a property ''value'' of type ''Array<{1}>''. This code will be prohibited in Kotlin 1.6", TO_STRING, TO_STRING); + MAP.put(REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY_ERROR, "Container annotation ''{0}'' must have a property ''value'' of type ''Array<{1}>''", TO_STRING, TO_STRING); + MAP.put(REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER, "Container annotation ''{0}'' does not have a default value for ''{1}''. This code will be prohibited in Kotlin 1.6", TO_STRING, NAME); + MAP.put(REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER_ERROR, "Container annotation ''{0}'' does not have a default value for ''{1}''", TO_STRING, NAME); + MAP.put(REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION, "Container annotation ''{0}'' has shorter retention (''{1}'') than the repeatable annotation ''{2}'' (''{3}''). This code will be prohibited in Kotlin 1.6", TO_STRING, TO_STRING, TO_STRING, TO_STRING); + MAP.put(REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION_ERROR, "Container annotation ''{0}'' has shorter retention (''{1}'') than the repeatable annotation ''{2}'' (''{3}'')", TO_STRING, TO_STRING, TO_STRING, TO_STRING); + MAP.put(REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET, "Target set of container annotation ''{0}'' must be a subset of the target set of contained annotation ''{1}''. This code will be prohibited in Kotlin 1.6", TO_STRING, TO_STRING); + MAP.put(REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET_ERROR, "Target set of container annotation ''{0}'' must be a subset of the target set of contained annotation ''{1}''", TO_STRING, TO_STRING); + MAP.put(JVM_PACKAGE_NAME_CANNOT_BE_EMPTY, "''@JvmPackageName'' annotation value cannot be empty"); MAP.put(JVM_PACKAGE_NAME_MUST_BE_VALID_NAME, "''@JvmPackageName'' annotation value must be a valid dot-qualified name of a package"); MAP.put(JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES, "''@JvmPackageName'' annotation is not supported for files with class declarations"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java index afddc9a9e66..b3c49cde010 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java @@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement; import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.descriptors.ClassifierDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; +import org.jetbrains.kotlin.descriptors.Named; import org.jetbrains.kotlin.diagnostics.*; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; @@ -69,9 +70,20 @@ public interface ErrorsJvm { DiagnosticFactory0 POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION = DiagnosticFactory0.create(ERROR); DiagnosticFactory1 DEPRECATED_JAVA_ANNOTATION = DiagnosticFactory1.create(WARNING); + DiagnosticFactory0 NON_SOURCE_REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 REPEATED_ANNOTATION_TARGET6 = DiagnosticFactory0.create(ERROR); DiagnosticFactory2 REPEATED_ANNOTATION_WITH_CONTAINER = DiagnosticFactory2.create(ERROR); + + DiagnosticFactory2 REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY = DiagnosticFactory2.create(WARNING); + DiagnosticFactory2 REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY_ERROR = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER = DiagnosticFactory2.create(WARNING); + DiagnosticFactory2 REPEATABLE_CONTAINER_HAS_NON_DEFAULT_PARAMETER_ERROR = DiagnosticFactory2.create(ERROR); + DiagnosticFactory4 REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION = DiagnosticFactory4.create(WARNING); + DiagnosticFactory4 REPEATABLE_CONTAINER_HAS_SHORTER_RETENTION_ERROR = DiagnosticFactory4.create(ERROR); + DiagnosticFactory2 REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET = DiagnosticFactory2.create(WARNING); + DiagnosticFactory2 REPEATABLE_CONTAINER_TARGET_SET_NOT_A_SUBSET_ERROR = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1 ANNOTATION_IS_NOT_APPLICABLE_TO_MULTIFILE_CLASSES = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 JVM_PACKAGE_NAME_CANNOT_BE_EMPTY = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt index f863eef52aa..faa69287e84 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt @@ -240,7 +240,7 @@ class AnnotationChecker( } for (checker in additionalCheckers) { - checker.checkEntries(entries, actualTargets.defaultTargets, trace, languageVersionSettings) + checker.checkEntries(entries, actualTargets.defaultTargets, trace, annotated, languageVersionSettings) } } @@ -398,6 +398,7 @@ interface AdditionalAnnotationChecker { entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt index f5d50827742..07dd82f7c13 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt @@ -22,7 +22,6 @@ import org.jetbrains.kotlin.psi.KtAnnotated import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.psi.KtCallableDeclaration import org.jetbrains.kotlin.psi.KtPropertyAccessor -import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker import org.jetbrains.kotlin.resolve.AnnotationChecker import org.jetbrains.kotlin.resolve.BindingContext @@ -40,6 +39,7 @@ class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleD entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) { var isAnnotatedWithExperimental = false @@ -81,7 +81,6 @@ class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleD ) { trace.report(Errors.EXPERIMENTAL_ANNOTATION_ON_WRONG_TARGET.on(entry, "field")) } - val annotated = entry.getStrictParentOfType() ?: continue if (annotated is KtCallableDeclaration && annotated !is KtPropertyAccessor && annotationUseSiteTarget == null && diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.fir.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.fir.kt new file mode 100644 index 00000000000..db6844ff75b --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.fir.kt @@ -0,0 +1,50 @@ +// !LANGUAGE: -RepeatableAnnotations -RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R + +@R(C1::class) +annotation class A1 +annotation class C1 + +@R(C2::class) +annotation class A2 +annotation class C2(val value: A2) + +@R(C3::class) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +annotation class A4 +annotation class C4(val notValue: Array) + +@R(C5::class) +annotation class A5 +annotation class C5(val value: Array, val irrelevant: String) + +@R(C6::class) +annotation class A6 +annotation class C6(val irrelevant: Double, val value: Array = []) + +// Should be an error after fixing KT-47932. +@R(A7::class) +annotation class A7(val value: Array) + + + +@R(D1::class) +annotation class B1 +annotation class D1(val value: Array) + +@R(D2::class) +annotation class B2 +annotation class D2(val value: Array = []) + +@R(D3::class) +annotation class B3 +annotation class D3(val value: Array, val other1: String = "", val other2: Int = 42) + +@R(D4::class) +annotation class B4 +annotation class D4(val value1: Array = [], val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt new file mode 100644 index 00000000000..e9ae5028c0d --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt @@ -0,0 +1,50 @@ +// !LANGUAGE: -RepeatableAnnotations -RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R + +@R(C1::class) +annotation class A1 +annotation class C1 + +@R(C2::class) +annotation class A2 +annotation class C2(val value: A2) + +@R(C3::class) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +annotation class A4 +annotation class C4(val notValue: Array) + +@R(C5::class) +annotation class A5 +annotation class C5(val value: Array, val irrelevant: String) + +@R(C6::class) +annotation class A6 +annotation class C6(val irrelevant: Double, val value: Array = []) + +// Should be an error after fixing KT-47932. +@R(A7::class) +annotation class A7(val value: Array) + + + +@R(D1::class) +annotation class B1 +annotation class D1(val value: Array) + +@R(D2::class) +annotation class B2 +annotation class D2(val value: Array = []) + +@R(D3::class) +annotation class B3 +annotation class D3(val value: Array, val other1: String = "", val other2: Int = 42) + +@R(D4::class) +annotation class B4 +annotation class D4(val value1: Array = [], val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.txt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.txt new file mode 100644 index 00000000000..0586e370a21 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.txt @@ -0,0 +1,163 @@ +package + +@java.lang.annotation.Repeatable(value = C1::class) public final annotation class A1 : kotlin.Annotation { + public constructor A1() + 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 +} + +@java.lang.annotation.Repeatable(value = C2::class) public final annotation class A2 : kotlin.Annotation { + public constructor A2() + 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 +} + +@java.lang.annotation.Repeatable(value = C3::class) public final annotation class A3 : kotlin.Annotation { + public constructor A3() + 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 +} + +@java.lang.annotation.Repeatable(value = C4::class) public final annotation class A4 : kotlin.Annotation { + public constructor A4() + 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 +} + +@java.lang.annotation.Repeatable(value = C5::class) public final annotation class A5 : kotlin.Annotation { + public constructor A5() + 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 +} + +@java.lang.annotation.Repeatable(value = C6::class) public final annotation class A6 : kotlin.Annotation { + public constructor A6() + 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 +} + +@java.lang.annotation.Repeatable(value = A7::class) public final annotation class A7 : kotlin.Annotation { + public constructor A7(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@java.lang.annotation.Repeatable(value = D1::class) public final annotation class B1 : kotlin.Annotation { + public constructor B1() + 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 +} + +@java.lang.annotation.Repeatable(value = D2::class) public final annotation class B2 : kotlin.Annotation { + public constructor B2() + 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 +} + +@java.lang.annotation.Repeatable(value = D3::class) public final annotation class B3 : kotlin.Annotation { + public constructor B3() + 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 +} + +@java.lang.annotation.Repeatable(value = D4::class) public final annotation class B4 : kotlin.Annotation { + public constructor B4() + 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 final annotation class C1 : kotlin.Annotation { + public constructor C1() + 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 final annotation class C2 : kotlin.Annotation { + public constructor C2(/*0*/ value: A2) + public final val value: A2 + 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 final annotation class C3 : kotlin.Annotation { + public constructor C3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class C4 : kotlin.Annotation { + public constructor C4(/*0*/ notValue: kotlin.Array) + public final val notValue: kotlin.Array + 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 final annotation class C5 : kotlin.Annotation { + public constructor C5(/*0*/ value: kotlin.Array, /*1*/ irrelevant: kotlin.String) + public final val irrelevant: kotlin.String + public final val value: kotlin.Array + 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 final annotation class C6 : kotlin.Annotation { + public constructor C6(/*0*/ irrelevant: kotlin.Double, /*1*/ value: kotlin.Array = ...) + public final val irrelevant: kotlin.Double + public final val value: kotlin.Array + 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 final annotation class D1 : kotlin.Annotation { + public constructor D1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class D2 : kotlin.Annotation { + public constructor D2(/*0*/ value: kotlin.Array = ...) + public final val value: kotlin.Array + 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 final annotation class D3 : kotlin.Annotation { + public constructor D3(/*0*/ value: kotlin.Array, /*1*/ other1: kotlin.String = ..., /*2*/ other2: kotlin.Int = ...) + public final val other1: kotlin.String + public final val other2: kotlin.Int + public final val value: kotlin.Array + 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 final annotation class D4 : kotlin.Annotation { + public constructor D4(/*0*/ value1: kotlin.Array = ..., /*1*/ value: kotlin.Array) + public final val value: kotlin.Array + public final val value1: kotlin.Array + 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/annotations/repeatable/containerArguments_1_6.fir.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.fir.kt new file mode 100644 index 00000000000..a45006f4e49 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.fir.kt @@ -0,0 +1,50 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R + +@R(C1::class) +annotation class A1 +annotation class C1 + +@R(C2::class) +annotation class A2 +annotation class C2(val value: A2) + +@R(C3::class) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +annotation class A4 +annotation class C4(val notValue: Array) + +@R(C5::class) +annotation class A5 +annotation class C5(val value: Array, val irrelevant: String) + +@R(C6::class) +annotation class A6 +annotation class C6(val irrelevant: Double, val value: Array = []) + +// Should be an error after fixing KT-47932. +@R(A7::class) +annotation class A7(val value: Array) + + + +@R(D1::class) +annotation class B1 +annotation class D1(val value: Array) + +@R(D2::class) +annotation class B2 +annotation class D2(val value: Array = []) + +@R(D3::class) +annotation class B3 +annotation class D3(val value: Array, val other1: String = "", val other2: Int = 42) + +@R(D4::class) +annotation class B4 +annotation class D4(val value1: Array = [], val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt new file mode 100644 index 00000000000..9f342eb5267 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt @@ -0,0 +1,50 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R + +@R(C1::class) +annotation class A1 +annotation class C1 + +@R(C2::class) +annotation class A2 +annotation class C2(val value: A2) + +@R(C3::class) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +annotation class A4 +annotation class C4(val notValue: Array) + +@R(C5::class) +annotation class A5 +annotation class C5(val value: Array, val irrelevant: String) + +@R(C6::class) +annotation class A6 +annotation class C6(val irrelevant: Double, val value: Array = []) + +// Should be an error after fixing KT-47932. +@R(A7::class) +annotation class A7(val value: Array) + + + +@R(D1::class) +annotation class B1 +annotation class D1(val value: Array) + +@R(D2::class) +annotation class B2 +annotation class D2(val value: Array = []) + +@R(D3::class) +annotation class B3 +annotation class D3(val value: Array, val other1: String = "", val other2: Int = 42) + +@R(D4::class) +annotation class B4 +annotation class D4(val value1: Array = [], val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.txt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.txt new file mode 100644 index 00000000000..0586e370a21 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.txt @@ -0,0 +1,163 @@ +package + +@java.lang.annotation.Repeatable(value = C1::class) public final annotation class A1 : kotlin.Annotation { + public constructor A1() + 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 +} + +@java.lang.annotation.Repeatable(value = C2::class) public final annotation class A2 : kotlin.Annotation { + public constructor A2() + 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 +} + +@java.lang.annotation.Repeatable(value = C3::class) public final annotation class A3 : kotlin.Annotation { + public constructor A3() + 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 +} + +@java.lang.annotation.Repeatable(value = C4::class) public final annotation class A4 : kotlin.Annotation { + public constructor A4() + 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 +} + +@java.lang.annotation.Repeatable(value = C5::class) public final annotation class A5 : kotlin.Annotation { + public constructor A5() + 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 +} + +@java.lang.annotation.Repeatable(value = C6::class) public final annotation class A6 : kotlin.Annotation { + public constructor A6() + 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 +} + +@java.lang.annotation.Repeatable(value = A7::class) public final annotation class A7 : kotlin.Annotation { + public constructor A7(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@java.lang.annotation.Repeatable(value = D1::class) public final annotation class B1 : kotlin.Annotation { + public constructor B1() + 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 +} + +@java.lang.annotation.Repeatable(value = D2::class) public final annotation class B2 : kotlin.Annotation { + public constructor B2() + 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 +} + +@java.lang.annotation.Repeatable(value = D3::class) public final annotation class B3 : kotlin.Annotation { + public constructor B3() + 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 +} + +@java.lang.annotation.Repeatable(value = D4::class) public final annotation class B4 : kotlin.Annotation { + public constructor B4() + 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 final annotation class C1 : kotlin.Annotation { + public constructor C1() + 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 final annotation class C2 : kotlin.Annotation { + public constructor C2(/*0*/ value: A2) + public final val value: A2 + 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 final annotation class C3 : kotlin.Annotation { + public constructor C3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class C4 : kotlin.Annotation { + public constructor C4(/*0*/ notValue: kotlin.Array) + public final val notValue: kotlin.Array + 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 final annotation class C5 : kotlin.Annotation { + public constructor C5(/*0*/ value: kotlin.Array, /*1*/ irrelevant: kotlin.String) + public final val irrelevant: kotlin.String + public final val value: kotlin.Array + 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 final annotation class C6 : kotlin.Annotation { + public constructor C6(/*0*/ irrelevant: kotlin.Double, /*1*/ value: kotlin.Array = ...) + public final val irrelevant: kotlin.Double + public final val value: kotlin.Array + 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 final annotation class D1 : kotlin.Annotation { + public constructor D1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class D2 : kotlin.Annotation { + public constructor D2(/*0*/ value: kotlin.Array = ...) + public final val value: kotlin.Array + 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 final annotation class D3 : kotlin.Annotation { + public constructor D3(/*0*/ value: kotlin.Array, /*1*/ other1: kotlin.String = ..., /*2*/ other2: kotlin.Int = ...) + public final val other1: kotlin.String + public final val other2: kotlin.Int + public final val value: kotlin.Array + 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 final annotation class D4 : kotlin.Annotation { + public constructor D4(/*0*/ value1: kotlin.Array = ..., /*1*/ value: kotlin.Array) + public final val value: kotlin.Array + public final val value1: kotlin.Array + 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/annotations/repeatable/containerRetention_1_5.fir.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.fir.kt new file mode 100644 index 00000000000..303659f3f5b --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.fir.kt @@ -0,0 +1,40 @@ +// !LANGUAGE: -RepeatableAnnotations -RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationRetention.* + +@R(C1::class) +@Retention(RUNTIME) +annotation class A1 +@Retention(BINARY) +annotation class C1(val value: Array) + +@R(C2::class) +@Retention(BINARY) +annotation class A2 +@Retention(SOURCE) +annotation class C2(val value: Array) + +@R(C3::class) +annotation class A3 +@Retention(SOURCE) +annotation class C3(val value: Array) + + + +@R(D1::class) +annotation class B1 +@Retention(RUNTIME) +annotation class D1(val value: Array) + +@R(D2::class) +@Retention(SOURCE) +annotation class B2 +@Retention(BINARY) +annotation class D2(val value: Array) + +@R(D3::class) +@Retention(BINARY) +annotation class B3 +annotation class D3(val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt new file mode 100644 index 00000000000..3b83f655f40 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt @@ -0,0 +1,40 @@ +// !LANGUAGE: -RepeatableAnnotations -RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationRetention.* + +@R(C1::class) +@Retention(RUNTIME) +annotation class A1 +@Retention(BINARY) +annotation class C1(val value: Array) + +@R(C2::class) +@Retention(BINARY) +annotation class A2 +@Retention(SOURCE) +annotation class C2(val value: Array) + +@R(C3::class) +annotation class A3 +@Retention(SOURCE) +annotation class C3(val value: Array) + + + +@R(D1::class) +annotation class B1 +@Retention(RUNTIME) +annotation class D1(val value: Array) + +@R(D2::class) +@Retention(SOURCE) +annotation class B2 +@Retention(BINARY) +annotation class D2(val value: Array) + +@R(D3::class) +@Retention(BINARY) +annotation class B3 +annotation class D3(val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.txt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.txt new file mode 100644 index 00000000000..be57d7747b3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.txt @@ -0,0 +1,91 @@ +package + +@java.lang.annotation.Repeatable(value = C1::class) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class A1 : kotlin.Annotation { + public constructor A1() + 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 +} + +@java.lang.annotation.Repeatable(value = C2::class) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class A2 : kotlin.Annotation { + public constructor A2() + 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 +} + +@java.lang.annotation.Repeatable(value = C3::class) public final annotation class A3 : kotlin.Annotation { + public constructor A3() + 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 +} + +@java.lang.annotation.Repeatable(value = D1::class) public final annotation class B1 : kotlin.Annotation { + public constructor B1() + 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 +} + +@java.lang.annotation.Repeatable(value = D2::class) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class B2 : kotlin.Annotation { + public constructor B2() + 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 +} + +@java.lang.annotation.Repeatable(value = D3::class) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class B3 : kotlin.Annotation { + public constructor B3() + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class C1 : kotlin.Annotation { + public constructor C1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class C2 : kotlin.Annotation { + public constructor C2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class C3 : kotlin.Annotation { + public constructor C3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class D1 : kotlin.Annotation { + public constructor D1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class D2 : kotlin.Annotation { + public constructor D2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class D3 : kotlin.Annotation { + public constructor D3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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/annotations/repeatable/containerRetention_1_6.fir.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.fir.kt new file mode 100644 index 00000000000..6111d2eb0c6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.fir.kt @@ -0,0 +1,40 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationRetention.* + +@R(C1::class) +@Retention(RUNTIME) +annotation class A1 +@Retention(BINARY) +annotation class C1(val value: Array) + +@R(C2::class) +@Retention(BINARY) +annotation class A2 +@Retention(SOURCE) +annotation class C2(val value: Array) + +@R(C3::class) +annotation class A3 +@Retention(SOURCE) +annotation class C3(val value: Array) + + + +@R(D1::class) +annotation class B1 +@Retention(RUNTIME) +annotation class D1(val value: Array) + +@R(D2::class) +@Retention(SOURCE) +annotation class B2 +@Retention(BINARY) +annotation class D2(val value: Array) + +@R(D3::class) +@Retention(BINARY) +annotation class B3 +annotation class D3(val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt new file mode 100644 index 00000000000..1b05aa9a640 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt @@ -0,0 +1,40 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationRetention.* + +@R(C1::class) +@Retention(RUNTIME) +annotation class A1 +@Retention(BINARY) +annotation class C1(val value: Array) + +@R(C2::class) +@Retention(BINARY) +annotation class A2 +@Retention(SOURCE) +annotation class C2(val value: Array) + +@R(C3::class) +annotation class A3 +@Retention(SOURCE) +annotation class C3(val value: Array) + + + +@R(D1::class) +annotation class B1 +@Retention(RUNTIME) +annotation class D1(val value: Array) + +@R(D2::class) +@Retention(SOURCE) +annotation class B2 +@Retention(BINARY) +annotation class D2(val value: Array) + +@R(D3::class) +@Retention(BINARY) +annotation class B3 +annotation class D3(val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.txt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.txt new file mode 100644 index 00000000000..be57d7747b3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.txt @@ -0,0 +1,91 @@ +package + +@java.lang.annotation.Repeatable(value = C1::class) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class A1 : kotlin.Annotation { + public constructor A1() + 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 +} + +@java.lang.annotation.Repeatable(value = C2::class) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class A2 : kotlin.Annotation { + public constructor A2() + 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 +} + +@java.lang.annotation.Repeatable(value = C3::class) public final annotation class A3 : kotlin.Annotation { + public constructor A3() + 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 +} + +@java.lang.annotation.Repeatable(value = D1::class) public final annotation class B1 : kotlin.Annotation { + public constructor B1() + 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 +} + +@java.lang.annotation.Repeatable(value = D2::class) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class B2 : kotlin.Annotation { + public constructor B2() + 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 +} + +@java.lang.annotation.Repeatable(value = D3::class) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class B3 : kotlin.Annotation { + public constructor B3() + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class C1 : kotlin.Annotation { + public constructor C1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class C2 : kotlin.Annotation { + public constructor C2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class C3 : kotlin.Annotation { + public constructor C3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class D1 : kotlin.Annotation { + public constructor D1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class D2 : kotlin.Annotation { + public constructor D2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class D3 : kotlin.Annotation { + public constructor D3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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/annotations/repeatable/containerTarget_1_6.fir.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.fir.kt new file mode 100644 index 00000000000..7f5c118db9a --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.fir.kt @@ -0,0 +1,53 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationTarget.* + +@R(C1::class) +annotation class A1 +@Target(FILE) +annotation class C1(val value: Array) + +@R(C2::class) +@Target(CLASS) +annotation class A2 +@Target(CLASS, FUNCTION) +annotation class C2(val value: Array) + +@R(C3::class) +@Target(TYPE) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +@Target(ANNOTATION_CLASS) +annotation class A4 +@Target(CLASS) +annotation class C4(val value: Array) + + + + +@R(D1::class) +annotation class B1 +@Target(CLASS, ANNOTATION_CLASS, PROPERTY, FIELD, LOCAL_VARIABLE, VALUE_PARAMETER, CONSTRUCTOR, FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER) // Default target set +annotation class D1(val value: Array) + +@R(D2::class) +@Target(CLASS, FILE) +annotation class B2 +@Target(CLASS) +annotation class D2(val value: Array) + +@R(D3::class) +@Target(CLASS) +annotation class B3 +@Target(ANNOTATION_CLASS) +annotation class D3(val value: Array) + +@R(D4::class) +@Target(TYPE) +annotation class B4 +@Target(ANNOTATION_CLASS, CLASS, TYPE_PARAMETER) +annotation class D4(val value: Array) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt new file mode 100644 index 00000000000..658155fc41d --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt @@ -0,0 +1,53 @@ +// !LANGUAGE: +RepeatableAnnotations +RepeatableAnnotationContainerConstraints +// FULL_JDK + +import java.lang.annotation.Repeatable as R +import kotlin.annotation.AnnotationTarget.* + +@R(C1::class) +annotation class A1 +@Target(FILE) +annotation class C1(val value: Array) + +@R(C2::class) +@Target(CLASS) +annotation class A2 +@Target(CLASS, FUNCTION) +annotation class C2(val value: Array) + +@R(C3::class) +@Target(TYPE) +annotation class A3 +annotation class C3(val value: Array) + +@R(C4::class) +@Target(ANNOTATION_CLASS) +annotation class A4 +@Target(CLASS) +annotation class C4(val value: Array) + + + + +@R(D1::class) +annotation class B1 +@Target(CLASS, ANNOTATION_CLASS, PROPERTY, FIELD, LOCAL_VARIABLE, VALUE_PARAMETER, CONSTRUCTOR, FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER) // Default target set +annotation class D1(val value: Array) + +@R(D2::class) +@Target(CLASS, FILE) +annotation class B2 +@Target(CLASS) +annotation class D2(val value: Array) + +@R(D3::class) +@Target(CLASS) +annotation class B3 +@Target(ANNOTATION_CLASS) +annotation class D3(val value: Array) + +@R(D4::class) +@Target(TYPE) +annotation class B4 +@Target(ANNOTATION_CLASS, CLASS, TYPE_PARAMETER) +annotation class D4(val value: Array) diff --git a/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.txt b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.txt new file mode 100644 index 00000000000..653f70e17f8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.txt @@ -0,0 +1,121 @@ +package + +@java.lang.annotation.Repeatable(value = C1::class) public final annotation class A1 : kotlin.Annotation { + public constructor A1() + 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 +} + +@java.lang.annotation.Repeatable(value = C2::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class A2 : kotlin.Annotation { + public constructor A2() + 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 +} + +@java.lang.annotation.Repeatable(value = C3::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class A3 : kotlin.Annotation { + public constructor A3() + 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 +} + +@java.lang.annotation.Repeatable(value = C4::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class A4 : kotlin.Annotation { + public constructor A4() + 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 +} + +@java.lang.annotation.Repeatable(value = D1::class) public final annotation class B1 : kotlin.Annotation { + public constructor B1() + 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 +} + +@java.lang.annotation.Repeatable(value = D2::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final annotation class B2 : kotlin.Annotation { + public constructor B2() + 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 +} + +@java.lang.annotation.Repeatable(value = D3::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class B3 : kotlin.Annotation { + public constructor B3() + 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 +} + +@java.lang.annotation.Repeatable(value = D4::class) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class B4 : kotlin.Annotation { + public constructor B4() + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) public final annotation class C1 : kotlin.Annotation { + public constructor C1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION}) public final annotation class C2 : kotlin.Annotation { + public constructor C2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 final annotation class C3 : kotlin.Annotation { + public constructor C3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class C4 : kotlin.Annotation { + public constructor C4(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public final annotation class D1 : kotlin.Annotation { + public constructor D1(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class D2 : kotlin.Annotation { + public constructor D2(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class D3 : kotlin.Annotation { + public constructor D3(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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 +} + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS, AnnotationTarget.TYPE_PARAMETER}) public final annotation class D4 : kotlin.Annotation { + public constructor D4(/*0*/ value: kotlin.Array) + public final val value: kotlin.Array + 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-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 272556ec631..2b87dcfa096 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -2112,6 +2112,36 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_6.kt"); } + @Test + @TestMetadata("containerArguments_1_5.kt") + public void testContainerArguments_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt"); + } + + @Test + @TestMetadata("containerArguments_1_6.kt") + public void testContainerArguments_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt"); + } + + @Test + @TestMetadata("containerRetention_1_5.kt") + public void testContainerRetention_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt"); + } + + @Test + @TestMetadata("containerRetention_1_6.kt") + public void testContainerRetention_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt"); + } + + @Test + @TestMetadata("containerTarget_1_6.kt") + public void testContainerTarget_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt"); + } + @Test @TestMetadata("javaRepeatableJvmTarget6.kt") public void testJavaRepeatableJvmTarget6() throws Exception { diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 883ddbf916b..2fa92b3618c 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -219,6 +219,7 @@ enum class LanguageFeature( OptInOnOverrideForbidden(KOTLIN_1_6, kind = BUG_FIX), OptInContagiousSignatures(KOTLIN_1_6, kind = BUG_FIX), RepeatableAnnotations(KOTLIN_1_6), + RepeatableAnnotationContainerConstraints(KOTLIN_1_6, kind = BUG_FIX), // 1.7 diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index 926f098500f..f05f0b09c75 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -2106,6 +2106,36 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_6.kt"); } + @Test + @TestMetadata("containerArguments_1_5.kt") + public void testContainerArguments_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt"); + } + + @Test + @TestMetadata("containerArguments_1_6.kt") + public void testContainerArguments_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt"); + } + + @Test + @TestMetadata("containerRetention_1_5.kt") + public void testContainerRetention_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt"); + } + + @Test + @TestMetadata("containerRetention_1_6.kt") + public void testContainerRetention_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt"); + } + + @Test + @TestMetadata("containerTarget_1_6.kt") + public void testContainerTarget_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt"); + } + @Test @TestMetadata("javaRepeatableJvmTarget6.kt") public void testJavaRepeatableJvmTarget6() throws Exception { diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsQualifierChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsQualifierChecker.kt index 9f298d5d279..56ba44a9c88 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsQualifierChecker.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsQualifierChecker.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.js.resolve.diagnostics import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils +import org.jetbrains.kotlin.psi.KtAnnotated import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker import org.jetbrains.kotlin.resolve.BindingContext @@ -29,6 +30,7 @@ object JsQualifierChecker : AdditionalAnnotationChecker { entries: List, actualTargets: List, trace: BindingTrace, + annotated: KtAnnotated?, languageVersionSettings: LanguageVersionSettings ) { val bindingContext = trace.bindingContext