diff --git a/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt b/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt index 6227c41002d8..48bface3a03d 100644 --- a/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt +++ b/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt @@ -129,7 +129,12 @@ private class UnstableApiUsageProcessor( } val annotationName = annotatedContainingDeclaration.psiAnnotation.qualifiedName ?: return val messageProvider = knownAnnotationMessageProviders[annotationName] ?: DefaultUnstableApiUsageMessageProvider - val message = messageProvider.buildMessage(annotatedContainingDeclaration, isMethodOverriding) + val message = if (isMethodOverriding) { + messageProvider.buildUnstableMethodOverriddenMessage(annotatedContainingDeclaration) + } + else { + messageProvider.buildMessage(annotatedContainingDeclaration) + } val elementToHighlight = (sourceNode as? UDeclaration)?.uastAnchor.sourcePsiElement ?: sourceNode.sourcePsi if (elementToHighlight != null) { problemsHolder.registerProblem(elementToHighlight, message, ProblemHighlightType.GENERIC_ERROR_OR_WARNING) @@ -185,73 +190,94 @@ private fun findAnnotatedContainingDeclaration( } private interface UnstableApiUsageMessageProvider { - fun buildMessage( - annotatedContainingDeclaration: AnnotatedContainingDeclaration, - isMethodOverriding: Boolean - ): String + + fun buildMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String + + fun buildUnstableMethodOverriddenMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String } private object DefaultUnstableApiUsageMessageProvider : UnstableApiUsageMessageProvider { - override fun buildMessage( - annotatedContainingDeclaration: AnnotatedContainingDeclaration, - isMethodOverriding: Boolean - ): String = with(annotatedContainingDeclaration) { - when { - isMethodOverriding && isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.unstable.api.usage.overridden.method.is.marked.unstable.itself", targetName - ) - isMethodOverriding && !isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.unstable.api.usage.overridden.method.is.declared.in.unstable.api", - targetName, - containingDeclarationType, - containingDeclarationName - ) - !isMethodOverriding && !isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.unstable.api.usage.api.is.declared.in.unstable.api", - targetName, - containingDeclarationType, - containingDeclarationName - ) - else -> JvmAnalysisBundle.message("jvm.inspections.unstable.api.usage.api.is.marked.unstable.itself", targetName) + override fun buildUnstableMethodOverriddenMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String = + with(annotatedContainingDeclaration) { + if (isOwnAnnotation) { + JvmAnalysisBundle.message("jvm.inspections.unstable.api.usage.overridden.method.is.marked.unstable.itself", targetName) + } + else { + JvmAnalysisBundle.message( + "jvm.inspections.unstable.api.usage.overridden.method.is.declared.in.unstable.api", + targetName, + containingDeclarationType, + containingDeclarationName + ) + } + } + + override fun buildMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String = + with(annotatedContainingDeclaration) { + if (isOwnAnnotation) { + JvmAnalysisBundle.message("jvm.inspections.unstable.api.usage.api.is.marked.unstable.itself", targetName) + } + else { + JvmAnalysisBundle.message( + "jvm.inspections.unstable.api.usage.api.is.declared.in.unstable.api", + targetName, + containingDeclarationType, + containingDeclarationName + ) + } } - } } private class ScheduledForRemovalMessageProvider : UnstableApiUsageMessageProvider { - override fun buildMessage( - annotatedContainingDeclaration: AnnotatedContainingDeclaration, - isMethodOverriding: Boolean - ): String { + override fun buildUnstableMethodOverriddenMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String { + val versionMessage = getVersionMessage(annotatedContainingDeclaration) + return with(annotatedContainingDeclaration) { + if (isOwnAnnotation) { + JvmAnalysisBundle.message( + "jvm.inspections.scheduled.for.removal.method.overridden.marked.itself", + targetName, + versionMessage + ) + } + else { + JvmAnalysisBundle.message( + "jvm.inspections.scheduled.for.removal.method.overridden.declared.in.marked.api", + targetName, + containingDeclarationType, + containingDeclarationName, + versionMessage + ) + } + } + } + + override fun buildMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String { + val versionMessage = getVersionMessage(annotatedContainingDeclaration) + return with(annotatedContainingDeclaration) { + if (!isOwnAnnotation) { + JvmAnalysisBundle.message( + "jvm.inspections.scheduled.for.removal.api.is.declared.in.marked.api", + targetName, + containingDeclarationType, + containingDeclarationName, + versionMessage + ) + } + else { + JvmAnalysisBundle.message( + "jvm.inspections.scheduled.for.removal.api.is.marked.itself", targetName, versionMessage + ) + } + } + } + + private fun getVersionMessage(annotatedContainingDeclaration: AnnotatedContainingDeclaration): String { val versionValue = AnnotationUtil.getDeclaredStringAttributeValue(annotatedContainingDeclaration.psiAnnotation, "inVersion") - val versionMessage = if (versionValue.isNullOrEmpty()) { + return if (versionValue.isNullOrEmpty()) { JvmAnalysisBundle.message("jvm.inspections.scheduled.for.removal.future.version") } else { JvmAnalysisBundle.message("jvm.inspections.scheduled.for.removal.predefined.version", versionValue) } - return with(annotatedContainingDeclaration) { - when { - isMethodOverriding && isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.method.overridden.marked.itself", targetName, versionMessage - ) - isMethodOverriding && !isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.method.overridden.declared.in.marked.api", - targetName, - containingDeclarationType, - containingDeclarationName, - versionValue - ) - !isMethodOverriding && !isOwnAnnotation -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.api.is.declared.in.marked.api", - targetName, - containingDeclarationType, - containingDeclarationName, - versionValue - ) - else -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.api.is.marked.itself", targetName, versionValue - ) - } - } } } \ No newline at end of file diff --git a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.java b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.java index 25570aa35288..29c9eb718902 100644 --- a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.java +++ b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.java @@ -1,45 +1,45 @@ // 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 file. -import pkg.AnnotatedClass; -import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; -import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass; -import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; -import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass; +import pkg.AnnotatedClass; +import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; +import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass; +import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; +import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass; import pkg.NonAnnotatedClass; import static pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; import static pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass; -import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; -import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass; +import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; +import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass; -import pkg.AnnotatedEnum; +import pkg.AnnotatedEnum; import pkg.NonAnnotatedEnum; -import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; -import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM; +import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; +import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM; import static pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; -import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; +import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; -import pkg.AnnotatedAnnotation; +import pkg.AnnotatedAnnotation; import pkg.NonAnnotatedAnnotation; -import annotatedPkg.ClassInAnnotatedPkg; +import annotatedPkg.ClassInAnnotatedPkg; public class ScheduledForRemovalElementsTest { public void test() { - String s = AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; - AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass(); - AnnotatedClass annotatedClassInstanceViaNonAnnotatedConstructor = new AnnotatedClass(); - s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass; - annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass(); - s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; - staticNonAnnotatedMethodInAnnotatedClass(); + String s = AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; + AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass(); + AnnotatedClass annotatedClassInstanceViaNonAnnotatedConstructor = new AnnotatedClass(); + s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass; + annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass(); + s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; + staticNonAnnotatedMethodInAnnotatedClass(); - s = AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; - AnnotatedClass.staticAnnotatedMethodInAnnotatedClass(); - AnnotatedClass annotatedClassInstanceViaAnnotatedConstructor = new AnnotatedClass(""); - s = annotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInAnnotatedClass; - annotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInAnnotatedClass(); - s = ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; - staticAnnotatedMethodInAnnotatedClass(); + s = AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; + AnnotatedClass.staticAnnotatedMethodInAnnotatedClass(); + AnnotatedClass annotatedClassInstanceViaAnnotatedConstructor = new AnnotatedClass(""); + s = annotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInAnnotatedClass; + annotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInAnnotatedClass(); + s = ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS; + staticAnnotatedMethodInAnnotatedClass(); // --------------------------------- @@ -51,34 +51,34 @@ public class ScheduledForRemovalElementsTest { s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; staticNonAnnotatedMethodInNonAnnotatedClass(); - s = NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; - NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass(); - NonAnnotatedClass nonAnnotatedClassInstanceViaAnnotatedConstructor = new NonAnnotatedClass(""); - s = nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInNonAnnotatedClass; - nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInNonAnnotatedClass(); - s = ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; - staticAnnotatedMethodInNonAnnotatedClass(); + s = NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; + NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass(); + NonAnnotatedClass nonAnnotatedClassInstanceViaAnnotatedConstructor = new NonAnnotatedClass(""); + s = nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInNonAnnotatedClass; + nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInNonAnnotatedClass(); + s = ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS; + staticAnnotatedMethodInNonAnnotatedClass(); // --------------------------------- - AnnotatedEnum nonAnnotatedValueInAnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; - nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; - AnnotatedEnum annotatedValueInAnnotatedEnum = AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM; - annotatedValueInAnnotatedEnum = ANNOTATED_VALUE_IN_ANNOTATED_ENUM; + AnnotatedEnum nonAnnotatedValueInAnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; + nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; + AnnotatedEnum annotatedValueInAnnotatedEnum = AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM; + annotatedValueInAnnotatedEnum = ANNOTATED_VALUE_IN_ANNOTATED_ENUM; NonAnnotatedEnum nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; - NonAnnotatedEnum annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; - annotatedValueInNonAnnotatedEnum = ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; + NonAnnotatedEnum annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; + annotatedValueInNonAnnotatedEnum = ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM; // --------------------------------- - @AnnotatedAnnotation class C1 {} - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} - @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 {} + @AnnotatedAnnotation class C1 {} + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} + @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 {} @NonAnnotatedAnnotation class C4 {} @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 {} - @NonAnnotatedAnnotation(annotatedAttributeInNonAnnotatedAnnotation = "123") class C6 {} + @NonAnnotatedAnnotation(annotatedAttributeInNonAnnotatedAnnotation = "123") class C6 {} } } diff --git a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.kt b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.kt index c667d6d6dc05..adabdc56560b 100644 --- a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.kt +++ b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/scheduledForRemoval/ScheduledForRemovalElementsTest.kt @@ -1,45 +1,45 @@ -import pkg.AnnotatedClass -import pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS -import pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass -import pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS -import pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass +import pkg.AnnotatedClass +import pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS +import pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass +import pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS +import pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass import pkg.NonAnnotatedClass import pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS import pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass -import pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS -import pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass +import pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS +import pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass -import pkg.AnnotatedEnum +import pkg.AnnotatedEnum import pkg.NonAnnotatedEnum -import pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM -import pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM +import pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM +import pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM import pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM -import pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM +import pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM -import pkg.AnnotatedAnnotation +import pkg.AnnotatedAnnotation import pkg.NonAnnotatedAnnotation -import annotatedPkg.ClassInAnnotatedPkg +import annotatedPkg.ClassInAnnotatedPkg @Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE", "UNUSED_VALUE") class ScheduledForRemovalElementsTest { fun test() { - var s = AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS - AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass() - val annotatedClassInstanceViaNonAnnotatedConstructor : AnnotatedClass = AnnotatedClass() - s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass - annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass() - s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS - staticNonAnnotatedMethodInAnnotatedClass() + var s = AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS + AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass() + val annotatedClassInstanceViaNonAnnotatedConstructor : AnnotatedClass = AnnotatedClass() + s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass + annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass() + s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS + staticNonAnnotatedMethodInAnnotatedClass() - s = AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS - AnnotatedClass.staticAnnotatedMethodInAnnotatedClass() - val annotatedClassInstanceViaAnnotatedConstructor : AnnotatedClass = AnnotatedClass("") - s = annotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInAnnotatedClass - annotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInAnnotatedClass() - s = ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS - staticAnnotatedMethodInAnnotatedClass() + s = AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS + AnnotatedClass.staticAnnotatedMethodInAnnotatedClass() + val annotatedClassInstanceViaAnnotatedConstructor : AnnotatedClass = AnnotatedClass("") + s = annotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInAnnotatedClass + annotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInAnnotatedClass() + s = ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS + staticAnnotatedMethodInAnnotatedClass() // --------------------------------- @@ -51,34 +51,34 @@ class ScheduledForRemovalElementsTest { s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS staticNonAnnotatedMethodInNonAnnotatedClass() - s = NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS - NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass() - val nonAnnotatedClassInstanceViaAnnotatedConstructor = NonAnnotatedClass("") - s = nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInNonAnnotatedClass - nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInNonAnnotatedClass() - s = ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS - staticAnnotatedMethodInNonAnnotatedClass() + s = NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS + NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass() + val nonAnnotatedClassInstanceViaAnnotatedConstructor = NonAnnotatedClass("") + s = nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedFieldInNonAnnotatedClass + nonAnnotatedClassInstanceViaAnnotatedConstructor.annotatedMethodInNonAnnotatedClass() + s = ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS + staticAnnotatedMethodInNonAnnotatedClass() // --------------------------------- - var nonAnnotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM - nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM - var annotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM - annotatedValueInAnnotatedEnum = ANNOTATED_VALUE_IN_ANNOTATED_ENUM + var nonAnnotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM + nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM + var annotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM + annotatedValueInAnnotatedEnum = ANNOTATED_VALUE_IN_ANNOTATED_ENUM var nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM - var annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM - annotatedValueInNonAnnotatedEnum = ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM + var annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM + annotatedValueInNonAnnotatedEnum = ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM // --------------------------------- - @AnnotatedAnnotation class C1 - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 - @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 + @AnnotatedAnnotation class C1 + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 + @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 @NonAnnotatedAnnotation class C4 @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 - @NonAnnotatedAnnotation(annotatedAttributeInNonAnnotatedAnnotation = "123") class C6 + @NonAnnotatedAnnotation(annotatedAttributeInNonAnnotatedAnnotation = "123") class C6 } }