From c9ea0a57e6d558bb46f7d90ef6b17997a013a48d Mon Sep 17 00:00:00 2001 From: Sergey Patrikeev Date: Tue, 25 Jun 2019 16:17:44 +0300 Subject: [PATCH] Unstable\ScheduledForRemoval API usage inspections: improve messages for methods\fields declared in annotated classes. GitOrigin-RevId: 95db4460a5f65bfcc0846b0840dccf16af720645 --- .../jvm/analysis/JvmAnalysisBundle.properties | 19 ++-- .../UnstableApiUsageInspection.kt | 91 +++++++++++++------ .../UnstableTypeUsedInSignatureInspection.kt | 13 +-- .../experimental/UnstableElementsTest.java | 28 +++--- .../experimental/UnstableElementsTest.kt | 28 +++--- .../ScheduledForRemovalElementsTest.java | 30 +++--- .../ScheduledForRemovalElementsTest.kt | 30 +++--- 7 files changed, 141 insertions(+), 98 deletions(-) diff --git a/jvm/jvm-analysis-impl/resources/com/intellij/jvm/analysis/JvmAnalysisBundle.properties b/jvm/jvm-analysis-impl/resources/com/intellij/jvm/analysis/JvmAnalysisBundle.properties index e237f329e8eb..b0ab260e9f77 100644 --- a/jvm/jvm-analysis-impl/resources/com/intellij/jvm/analysis/JvmAnalysisBundle.properties +++ b/jvm/jvm-analysis-impl/resources/com/intellij/jvm/analysis/JvmAnalysisBundle.properties @@ -2,13 +2,18 @@ jvm.inspections.group.name=JVM languages jvm.inspections.unstable.api.usage.display.name=Unstable API Usage jvm.inspections.unstable.api.usage.annotations.list=Unstable API annotations -jvm.inspections.api.usage.ignore.inside.imports=Ignore inside imports -jvm.inspections.unstable.api.usage.description=''{0}'' is marked unstable -jvm.inspections.unstable.method.overridden.description=Overridden method ''{0}'' is marked unstable -jvm.inspections.scheduled.for.removal.description.no.version=''{0}'' is scheduled for removal -jvm.inspections.scheduled.for.removal.description.with.version=''{0}'' is scheduled for removal in {1} -jvm.inspections.scheduled.for.removal.method.overridden.no.version.description=Overridden method ''{0}'' is scheduled for removal -jvm.inspections.scheduled.for.removal.method.overridden.with.version.description=Overridden method ''{0}'' is scheduled for removal in {1} +jvm.inspections.unstable.api.usage.ignore.inside.imports=Ignore inside imports +jvm.inspections.unstable.api.usage.api.is.marked.unstable.itself=''{0}'' is marked unstable +jvm.inspections.unstable.api.usage.api.is.declared.in.unstable.api=''{0}'' is declared in unstable {1} ''{2}'' +jvm.inspections.unstable.api.usage.overridden.method.is.marked.unstable.itself=Overridden method ''{0}'' is marked unstable +jvm.inspections.unstable.api.usage.overridden.method.is.declared.in.unstable.api=Overridden method ''{0}'' is declared in unstable {1} ''{2}'' + +jvm.inspections.scheduled.for.removal.future.version=a future version +jvm.inspections.scheduled.for.removal.predefined.version=version {0} +jvm.inspections.scheduled.for.removal.api.is.marked.itself=''{0}'' is scheduled for removal in {1} +jvm.inspections.scheduled.for.removal.api.is.declared.in.marked.api=''{0}'' is declared in {1} ''{2}'' scheduled for removal in {3} +jvm.inspections.scheduled.for.removal.method.overridden.marked.itself=Overridden method ''{0}'' is scheduled for removal in {1} +jvm.inspections.scheduled.for.removal.method.overridden.declared.in.marked.api=Overridden method ''{0}'' is declared in {1} ''{2}'' scheduled for removal in {3} jvm.inspections.unstable.type.used.in.signature.display.name=Unstable type is used in signature jvm.inspections.unstable.type.used.in.class.signature.description=Class must be marked with ''@{0}'' annotation because its declaration references unstable type ''{1}'' 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 b8c3ed43fd63..6227c41002d8 100644 --- a/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt +++ b/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableApiUsageInspection.kt @@ -5,9 +5,10 @@ import com.intellij.analysis.JvmAnalysisBundle import com.intellij.codeInsight.AnnotationUtil import com.intellij.codeInspection.apiUsage.ApiUsageProcessor import com.intellij.codeInspection.apiUsage.ApiUsageUastVisitor -import com.intellij.codeInspection.deprecation.DeprecationInspectionBase.getPresentableName +import com.intellij.codeInspection.deprecation.DeprecationInspection import com.intellij.codeInspection.ui.SingleCheckboxOptionsPanel import com.intellij.codeInspection.util.SpecialAnnotationsUtil +import com.intellij.lang.findUsages.LanguageFindUsages import com.intellij.openapi.application.ApplicationManager import com.intellij.openapi.roots.ProjectFileIndex import com.intellij.psi.* @@ -61,7 +62,7 @@ class UnstableApiUsageInspection : LocalInspectionTool() { override fun createOptionsPanel(): JPanel { val checkboxPanel = SingleCheckboxOptionsPanel( - JvmAnalysisBundle.message("jvm.inspections.api.usage.ignore.inside.imports"), this, "myIgnoreInsideImports" + JvmAnalysisBundle.message("jvm.inspections.unstable.api.usage.ignore.inside.imports"), this, "myIgnoreInsideImports" ) //TODO in add annotation window "Include non-project items" should be enabled by default @@ -141,7 +142,19 @@ data class AnnotatedContainingDeclaration( val target: PsiModifierListOwner, val containingDeclaration: PsiModifierListOwner, val psiAnnotation: PsiAnnotation -) +) { + val targetName: String + get() = DeprecationInspection.getPresentableName(target) + + val containingDeclarationName: String + get() = DeprecationInspection.getPresentableName(containingDeclaration) + + val containingDeclarationType: String + get() = LanguageFindUsages.getType(containingDeclaration) + + val isOwnAnnotation: Boolean + get() = target == containingDeclaration +} fun findAnnotatedContainingDeclaration( target: PsiModifierListOwner, @@ -182,13 +195,24 @@ private object DefaultUnstableApiUsageMessageProvider : UnstableApiUsageMessageP override fun buildMessage( annotatedContainingDeclaration: AnnotatedContainingDeclaration, isMethodOverriding: Boolean - ): String { - val targetName = getPresentableName(annotatedContainingDeclaration.target) - return if (isMethodOverriding) { - JvmAnalysisBundle.message("jvm.inspections.unstable.method.overridden.description", targetName) - } - else { - JvmAnalysisBundle.message("jvm.inspections.unstable.api.usage.description", targetName) + ): 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) } } } @@ -198,23 +222,36 @@ private class ScheduledForRemovalMessageProvider : UnstableApiUsageMessageProvid annotatedContainingDeclaration: AnnotatedContainingDeclaration, isMethodOverriding: Boolean ): String { - val inVersion = AnnotationUtil.getDeclaredStringAttributeValue(annotatedContainingDeclaration.psiAnnotation, "inVersion") - val targetName = getPresentableName(annotatedContainingDeclaration.target) - val isEmptyVersion = inVersion == null || inVersion.isEmpty() - return when { - isEmptyVersion && isMethodOverriding -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.method.overridden.no.version.description", targetName - ) - - !isEmptyVersion && isMethodOverriding -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.method.overridden.with.version.description", targetName, inVersion - ) - - !isEmptyVersion && !isMethodOverriding -> JvmAnalysisBundle.message( - "jvm.inspections.scheduled.for.removal.description.with.version", targetName, inVersion - ) - - else -> JvmAnalysisBundle.message("jvm.inspections.scheduled.for.removal.description.no.version", targetName) + val versionValue = AnnotationUtil.getDeclaredStringAttributeValue(annotatedContainingDeclaration.psiAnnotation, "inVersion") + val versionMessage = 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-impl/src/com/intellij/codeInspection/UnstableTypeUsedInSignatureInspection.kt b/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableTypeUsedInSignatureInspection.kt index 272a00c8d077..2ab693832174 100644 --- a/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableTypeUsedInSignatureInspection.kt +++ b/jvm/jvm-analysis-impl/src/com/intellij/codeInspection/UnstableTypeUsedInSignatureInspection.kt @@ -122,9 +122,10 @@ class UnstableTypeUsedInSignatureInspection : LocalInspectionTool() { } private fun checkReferencesUnstableType(psiType: PsiType, declaration: UDeclaration): Boolean { - val (unstableClass, unstableAnnotation) = findReferencedUnstableType(psiType.deepComponentType) ?: return false + val annotatedContainingDeclaration = findReferencedUnstableType(psiType.deepComponentType) ?: return false + val unstableClass = annotatedContainingDeclaration.target as? PsiClass ?: return false val className = unstableClass.qualifiedName ?: return false - val annotationName = unstableAnnotation.qualifiedName ?: return false + val annotationName = annotatedContainingDeclaration.psiAnnotation.qualifiedName ?: return false val message = when (declaration) { is UMethod -> JvmAnalysisBundle.message("jvm.inspections.unstable.type.used.in.method.signature.description", annotationName, className) is UField -> JvmAnalysisBundle.message("jvm.inspections.unstable.type.used.in.field.signature.description", annotationName, className) @@ -135,13 +136,13 @@ class UnstableTypeUsedInSignatureInspection : LocalInspectionTool() { return true } - private fun findReferencedUnstableType(psiType: PsiType): Pair? { + private fun findReferencedUnstableType(psiType: PsiType): AnnotatedContainingDeclaration? { if (psiType is PsiClassType) { val psiClass = psiType.resolve() if (psiClass != null) { - val unstableApiAnnotation = findAnnotatedContainingDeclaration(psiClass, unstableApiAnnotations, false) - if (unstableApiAnnotation != null) { - return psiClass to unstableApiAnnotation.psiAnnotation + val unstableContainingDeclaration = findAnnotatedContainingDeclaration(psiClass, unstableApiAnnotations, false) + if (unstableContainingDeclaration != null) { + return unstableContainingDeclaration } } for (parameterType in psiType.parameters) { diff --git a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.java b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.java index 722b563cc47e..97240a4d163a 100644 --- a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.java +++ b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.java @@ -1,7 +1,7 @@ // 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.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; @@ -13,7 +13,7 @@ import static pkg.NonAnnotatedClass.AnnotatedEnum; import pkg.NonAnnotatedEnum; -import static pkg.AnnotatedEnum.NON_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; @@ -21,17 +21,17 @@ import static pkg.NonAnnotatedEnum.AnnotatedAnnotation; import pkg.NonAnnotatedAnnotation; -import annotatedPkg.ClassInAnnotatedPkg; +import annotatedPkg.ClassInAnnotatedPkg; public class UnstableElementsTest { 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(); @@ -61,8 +61,8 @@ public class UnstableElementsTest { // --------------------------------- - AnnotatedEnum nonAnnotatedValueInAnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; - nonAnnotatedValueInAnnotatedEnum = NON_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; @@ -74,7 +74,7 @@ public class UnstableElementsTest { // --------------------------------- @AnnotatedAnnotation class C1 {} - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 {} @NonAnnotatedAnnotation class C4 {} @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 {} diff --git a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.kt b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.kt index 75f3c7698d5e..635773909846 100644 --- a/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.kt +++ b/jvm/jvm-analysis-kotlin-tests/testData/codeInspection/unstableApiUsage/experimental/UnstableElementsTest.kt @@ -1,6 +1,6 @@ import pkg.AnnotatedClass -import pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS -import pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass +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 @@ -12,7 +12,7 @@ import pkg.NonAnnotatedClass.AnnotatedEnum import pkg.NonAnnotatedEnum -import pkg.AnnotatedEnum.NON_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 @@ -20,18 +20,18 @@ import pkg.NonAnnotatedEnum.AnnotatedAnnotation import pkg.NonAnnotatedAnnotation -import annotatedPkg.ClassInAnnotatedPkg +import annotatedPkg.ClassInAnnotatedPkg @Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE", "UNUSED_VALUE") class UnstableElementsTest { 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() @@ -61,8 +61,8 @@ class UnstableElementsTest { // --------------------------------- - var nonAnnotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM - nonAnnotatedValueInAnnotatedEnum = NON_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 @@ -74,7 +74,7 @@ class UnstableElementsTest { // --------------------------------- @AnnotatedAnnotation class C1 - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 @NonAnnotatedAnnotation class C4 @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 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 d83efa677d17..25570aa35288 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,7 +1,7 @@ // 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.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; @@ -13,7 +13,7 @@ import static pkg.NonAnnotatedClass.AnnotatedEnum; import pkg.NonAnnotatedEnum; -import static pkg.AnnotatedEnum.NON_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; @@ -21,17 +21,17 @@ import static pkg.NonAnnotatedEnum.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(); @@ -61,8 +61,8 @@ public class ScheduledForRemovalElementsTest { // --------------------------------- - AnnotatedEnum nonAnnotatedValueInAnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM; - nonAnnotatedValueInAnnotatedEnum = NON_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; @@ -74,7 +74,7 @@ public class ScheduledForRemovalElementsTest { // --------------------------------- @AnnotatedAnnotation class C1 {} - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {} @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 {} @NonAnnotatedAnnotation class C4 {} @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 {} @@ -84,7 +84,7 @@ public class ScheduledForRemovalElementsTest { class DirectOverrideAnnotatedMethod extends NonAnnotatedClass { @Override - public void annotatedMethodInNonAnnotatedClass() {} + public void annotatedMethodInNonAnnotatedClass() {} } class IndirectOverrideAnnotatedMethod extends DirectOverrideAnnotatedMethod { 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 d00bc16627c4..c667d6d6dc05 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,6 +1,6 @@ import pkg.AnnotatedClass -import pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS -import pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass +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 @@ -12,7 +12,7 @@ import pkg.NonAnnotatedClass.AnnotatedEnum import pkg.NonAnnotatedEnum -import pkg.AnnotatedEnum.NON_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 @@ -20,18 +20,18 @@ import pkg.NonAnnotatedEnum.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() @@ -61,8 +61,8 @@ class ScheduledForRemovalElementsTest { // --------------------------------- - var nonAnnotatedValueInAnnotatedEnum : AnnotatedEnum = AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM - nonAnnotatedValueInAnnotatedEnum = NON_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 @@ -74,7 +74,7 @@ class ScheduledForRemovalElementsTest { // --------------------------------- @AnnotatedAnnotation class C1 - @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 + @AnnotatedAnnotation(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 @AnnotatedAnnotation(annotatedAttributeInAnnotatedAnnotation = "123") class C3 @NonAnnotatedAnnotation class C4 @NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 @@ -83,7 +83,7 @@ class ScheduledForRemovalElementsTest { } open class DirectOverrideAnnotatedMethod : NonAnnotatedClass() { - override fun annotatedMethodInNonAnnotatedClass() {} + override fun annotatedMethodInNonAnnotatedClass() {} } //No warning should be produced.