K2: deprecate use-site targeted annotations on expressions

#KT-75242 Fixed

Author: mglukhikh

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDataClassConverters.kt

@@ -1238,6 +1238,18 @@ internal val KT_DIAGNOSTIC_CONVERTER = KaDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION.errorFactory) { firDiagnostic ->
+        AnnotationWithUseSiteTargetOnExpressionErrorImpl(
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
+    add(FirErrors.ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION.warningFactory) { firDiagnostic ->
+        AnnotationWithUseSiteTargetOnExpressionWarningImpl(
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.INAPPLICABLE_TARGET_ON_PROPERTY) { firDiagnostic ->
         InapplicableTargetOnPropertyImpl(
             firDiagnostic.a,

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnostics.kt

@@ -896,6 +896,14 @@ sealed interface KaFirDiagnostic<PSI : PsiElement> : KaDiagnosticWithPsi<PSI> {
         val allowedTargets: List<KotlinTarget>
     }
 
+    interface AnnotationWithUseSiteTargetOnExpressionError : KaFirDiagnostic<KtAnnotationEntry> {
+        override val diagnosticClass get() = AnnotationWithUseSiteTargetOnExpressionError::class
+    }
+
+    interface AnnotationWithUseSiteTargetOnExpressionWarning : KaFirDiagnostic<KtAnnotationEntry> {
+        override val diagnosticClass get() = AnnotationWithUseSiteTargetOnExpressionWarning::class
+    }
+
     interface InapplicableTargetOnProperty : KaFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetOnProperty::class
         val useSiteDescription: String

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnosticsImpl.kt

@@ -1071,6 +1071,16 @@ internal class WrongAnnotationTargetWithUseSiteTargetImpl(
     token: KaLifetimeToken,
 ) : KaAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KaFirDiagnostic.WrongAnnotationTargetWithUseSiteTarget
 
+internal class AnnotationWithUseSiteTargetOnExpressionErrorImpl(
+    firDiagnostic: KtPsiDiagnostic,
+    token: KaLifetimeToken,
+) : KaAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KaFirDiagnostic.AnnotationWithUseSiteTargetOnExpressionError
+
+internal class AnnotationWithUseSiteTargetOnExpressionWarningImpl(
+    firDiagnostic: KtPsiDiagnostic,
+    token: KaLifetimeToken,
+) : KaAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KaFirDiagnostic.AnnotationWithUseSiteTargetOnExpressionWarning
+
 internal class InapplicableTargetOnPropertyImpl(
     override val useSiteDescription: String,
     firDiagnostic: KtPsiDiagnostic,

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLDiagnosticsFirTestGenerated.java

@@ -1,30 +1,31 @@
 // RUN_PIPELINE_TILL: BACKEND
+// LANGUAGE: -ForbidAnnotationsWithUseSiteTargetOnExpressions
 // ISSUE: KT-75242
 
 annotation class Decl
 
 fun test(x: Int) {
     if (x > 10)
-        @all:Decl { }
+        <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@all:Decl<!> { }
 
-    for (i in 1..10) @field:Decl { }
+    for (i in 1..10) <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@field:Decl<!> { }
 
     when (x) {
-        1 -> @setparam:Decl { "" }
+        1 -> <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@setparam:Decl<!> { "" }
     }
 }
 
 @Retention(AnnotationRetention.SOURCE)
 @Target(AnnotationTarget.EXPRESSION)
 annotation class Source
 
-fun test(){
-    @all:Source
+fun test() {
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@all:Source<!>
     when { else -> {} }
 
-    @get:Source
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@get:Source<!>
     while (true) { break }
 
-    @receiver:Source
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_WARNING!>@receiver:Source<!>
     for (i in 1..10) {}
 }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLReversedDiagnosticsFirTestGenerated.java

@@ -0,0 +1,31 @@
+// RUN_PIPELINE_TILL: FRONTEND
+// LANGUAGE: +ForbidAnnotationsWithUseSiteTargetOnExpressions
+// ISSUE: KT-75242
+
+annotation class Decl
+
+fun test(x: Int) {
+    if (x > 10)
+        <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@all:Decl<!> { }
+
+    for (i in 1..10) <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@field:Decl<!> { }
+
+    when (x) {
+        1 -> <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@setparam:Decl<!> { "" }
+    }
+}
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Source
+
+fun test() {
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@all:Source<!>
+    when { else -> {} }
+
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@get:Source<!>
+    while (true) { break }
+
+    <!ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION_ERROR!>@receiver:Source<!>
+    for (i in 1..10) {}
+}

compiler/fir/analysis-tests/testData/resolveWithStdlib/annotations/useSiteTargetOnExpression.kt

@@ -417,6 +417,9 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<String>("useSiteTarget")
             parameter<Collection<KotlinTarget>>("allowedTargets")
         }
+        val ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION by deprecationError<KtAnnotationEntry>(
+            LanguageFeature.ForbidAnnotationsWithUseSiteTargetOnExpressions
+        )
         val INAPPLICABLE_TARGET_ON_PROPERTY by error<KtAnnotationEntry> {
             parameter<String>("useSiteDescription")
         }

compiler/fir/analysis-tests/testData/resolveWithStdlib/annotations/useSiteTargetOnExpressionForbidden.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageFeature.ErrorAboutDataClassCopyVisibilityChange
+import org.jetbrains.kotlin.config.LanguageFeature.ForbidAnnotationsWithUseSiteTargetOnExpressions
 import org.jetbrains.kotlin.config.LanguageFeature.ForbidCompanionInLocalInnerClass
 import org.jetbrains.kotlin.config.LanguageFeature.ForbidEnumEntryNamedEntries
 import org.jetbrains.kotlin.config.LanguageFeature.ForbidExposingTypesInPrimaryConstructorProperties
@@ -328,6 +329,7 @@ object FirErrors {
     val WRONG_ANNOTATION_TARGET: KtDiagnosticFactory2<String, Collection<KotlinTarget>> = KtDiagnosticFactory2("WRONG_ANNOTATION_TARGET", ERROR, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
     val WRONG_ANNOTATION_TARGET_WARNING: KtDiagnosticFactory2<String, Collection<KotlinTarget>> = KtDiagnosticFactory2("WRONG_ANNOTATION_TARGET_WARNING", WARNING, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
     val WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET: KtDiagnosticFactory3<String, String, Collection<KotlinTarget>> = KtDiagnosticFactory3("WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET", ERROR, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
+    val ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION: KtDiagnosticFactoryForDeprecation0 = KtDiagnosticFactoryForDeprecation0("ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION", ForbidAnnotationsWithUseSiteTargetOnExpressions, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
     val INAPPLICABLE_TARGET_ON_PROPERTY: KtDiagnosticFactory1<String> = KtDiagnosticFactory1("INAPPLICABLE_TARGET_ON_PROPERTY", ERROR, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
     val INAPPLICABLE_TARGET_ON_PROPERTY_WARNING: KtDiagnosticFactory1<String> = KtDiagnosticFactory1("INAPPLICABLE_TARGET_ON_PROPERTY_WARNING", WARNING, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)
     val INAPPLICABLE_TARGET_PROPERTY_IMMUTABLE: KtDiagnosticFactory1<String> = KtDiagnosticFactory1("INAPPLICABLE_TARGET_PROPERTY_IMMUTABLE", ERROR, SourceElementPositioningStrategies.DEFAULT, KtAnnotationEntry::class)

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeDiagnosticsWithLatestLanguageVersionTestGenerated.java

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.expression
 
-import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
@@ -30,10 +29,9 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker(MppCheckerKind
     override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
         // Declarations are checked separately
         // See KT-58723 about annotations on non-expression statements
-        if (expression is FirDeclaration ||
-            expression is FirErrorExpression ||
-            expression is FirBlock && expression.source?.kind == KtRealSourceElementKind
-        ) return
+        if (expression is FirDeclaration || expression is FirErrorExpression) {
+            return
+        }
 
         // To prevent double-reporting (we have also a call in this case)
         if (expression is FirVariableAssignment && expression.lValue is FirDesugaredAssignmentValueReferenceExpression) {
@@ -44,14 +42,18 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker(MppCheckerKind
         if (annotations.isEmpty()) return
 
         val annotationsMap = hashMapOf<ConeKotlinType, MutableList<AnnotationUseSiteTarget?>>()
+        val inRealBlock = expression is FirBlock && expression.source?.kind == KtRealSourceElementKind
 
         for (annotation in annotations) {
             val useSiteTarget = annotation.useSiteTarget ?: expression.getDefaultUseSiteTarget(annotation, context)
             val existingTargetsForAnnotation = annotationsMap.getOrPut(annotation.annotationTypeRef.coneType) { arrayListOf() }
 
             val allowedAnnotationTargets = annotation.getAllowedAnnotationTargets(context.session)
-            if (KotlinTarget.EXPRESSION !in allowedAnnotationTargets) {
+            // We don't want to report WRONG_ANNOTATION_TARGET on a block according to KT-52175
+            if (!inRealBlock && KotlinTarget.EXPRESSION !in allowedAnnotationTargets) {
                 reporter.reportOn(annotation.source, FirErrors.WRONG_ANNOTATION_TARGET, "expression", allowedAnnotationTargets, context)
+            } else if (useSiteTarget != null) {
+                reporter.reportOn(annotation.source, FirErrors.ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION, context)
             }
 
             checkRepeatedAnnotation(useSiteTarget, existingTargetsForAnnotation, annotation, context, reporter, annotation.source)

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/PhasedJvmDiagnosticLightTreeTestGenerated.java

@@ -428,6 +428,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MODIFIER_FORM_FOR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MODIFIER_FORM_FOR_NON_BUILT_IN_SUSPEND_FUN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_CONTEXT_ARGUMENT
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATIONS_ON_BLOCK_LEVEL_EXPRESSION_ON_THE_SAME_LINE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ATOMIC_REF_WITHOUT_CONSISTENT_IDENTITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CALLABLE_REFERENCE_TO_CONTEXTUAL_DECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPARE_TO_TYPE_MISMATCH
@@ -1213,6 +1214,12 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
             TO_STRING,
             KOTLIN_TARGETS,
         )
+        map.put(
+            ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION.warningFactory,
+            "Use-site targets in annotations on expressions will become an error in Kotlin " +
+                    "${ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION.deprecatingFeature.sinceVersion?.versionString}."
+        )
+        map.put(ANNOTATION_WITH_USE_SITE_TARGET_ON_EXPRESSION.errorFactory, "Use-site targets are forbidden in annotations on expressions.")
         map.put(REPEATED_ANNOTATION, "This annotation is not repeatable.")
         map.put(REPEATED_ANNOTATION_WARNING, "This annotation is not repeatable.")
         map.put(NON_INTERNAL_PUBLISHED_API, "'@PublishedApi' annotation is only applicable to internal declaration.")

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/PhasedJvmDiagnosticPsiTestGenerated.java

@@ -403,6 +403,7 @@ enum class LanguageFeature(
     DontMakeExplicitJavaTypeArgumentsFlexible(KOTLIN_2_3, kind = OTHER), // KT-71718
     ResolveTopLevelLambdasAsSyntheticCallArgument(KOTLIN_2_3, kind = OTHER), // KT-67869
     UnstableSmartcastOnDelegatedProperties(KOTLIN_2_3, kind = BUG_FIX), // KTLC-273
+    ForbidAnnotationsWithUseSiteTargetOnExpressions(KOTLIN_2_3, kind = BUG_FIX), // KT-75242
 
     // End of 2.* language features --------------------------------------------------