FIR: report WRONG_ANNOTATION_TARGET(_WITH_USE_SITE_TARGET) on declarations

compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt

@@ -12,8 +12,8 @@ annotation class Ann2
 @Retention(AnnotationRetention.SOURCE)
 annotation class Ann3(val arg: Int, val s: String)
 
-@Ann3(
+<!WRONG_ANNOTATION_TARGET!>@Ann3(
     <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann3(
         <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann<!> 5, ""
     )<!> <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann2<!> 1, ""
-) val a = 0
+)<!> val a = 0

compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt

@@ -1,5 +1,5 @@
 // Should be something like TYPE_MISMATCH here
-@file:Some(return x)
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file:Some(return x)<!>
 
 const val x = 42
 

compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt

@@ -7,7 +7,7 @@ annotation class MyAnn
 fun bar(x: Int) {}
 
 fun foo() {
-    @MyAnn
+    <!WRONG_ANNOTATION_TARGET!>@MyAnn<!>
     val x: Int
     @MyAnn
     x = @MyAnn 42

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantSetterParameterTypeChecker.fir.txt

@@ -1,5 +1,5 @@
 FILE: RedundantSetterParameterTypeChecker.kt
-    @R|kotlin/annotation/Target|(vararg(Q|kotlin/annotation/AnnotationTarget|.R|kotlin/annotation/AnnotationTarget.CLASS|)) public final annotation class Ann : R|kotlin/Annotation| {
+    @R|kotlin/annotation/Target|(vararg(Q|kotlin/annotation/AnnotationTarget|.R|kotlin/annotation/AnnotationTarget.VALUE_PARAMETER|)) public final annotation class Ann : R|kotlin/Annotation| {
         public constructor(): R|Ann| {
             super<R|kotlin/Any|>()
         }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantSetterParameterTypeChecker.kt

@@ -1,5 +1,5 @@
 
-@Target(AnnotationTarget.CLASS)
+@Target(AnnotationTarget.VALUE_PARAMETER)
 annotation class Ann
 
 <!REDECLARATION!>var x: Int

compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt

@@ -41,6 +41,6 @@ class Second(val y: Char) : @WithInt(0) First() {
     constructor(): this('\n')
 }
 
-@WithInt(24)
+<!WRONG_ANNOTATION_TARGET!>@WithInt(24)<!>
-@VeryComplex(3.14f, 6.67e-11, false, 123456789012345L, null)
+<!WRONG_ANNOTATION_TARGET!>@VeryComplex(3.14f, 6.67e-11, false, 123456789012345L, null)<!>
 typealias Third = @Simple Second

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -176,6 +176,10 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
         val WRONG_ANNOTATION_TARGET by error<KtAnnotationEntry> {
             parameter<String>("actualTarget")
         }
+        val WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET by error<KtAnnotationEntry> {
+            parameter<String>("actualTarget")
+            parameter<String>("useSiteTarget")
+        }
     }
 
     val EXPOSED_VISIBILITY by object : DiagnosticGroup("Exposed visibility") {

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -180,6 +180,7 @@ object FirErrors {
     val ANNOTATION_ON_SUPERCLASS by error0<KtAnnotationEntry>()
     val RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION by error0<PsiElement>()
     val WRONG_ANNOTATION_TARGET by error1<KtAnnotationEntry, String>()
+    val WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET by error2<KtAnnotationEntry, String, String>()
 
     // Exposed visibility
     val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt

@@ -79,7 +79,8 @@ fun FirAnnotationCall.findSingleArgumentByName(name: Name): FirExpression? {
         return argumentMapping.keys.firstOrNull()?.takeIf { argumentMapping[it]?.name == name }
     }
     // NB: we have to consider both cases, because deserializer does not create argument mapping
-    val firstArgument = argumentList.arguments.firstOrNull() as? FirNamedArgumentExpression ?: return null
+    val arguments = argumentList.arguments
+    val firstArgument = arguments.firstOrNull() as? FirNamedArgumentExpression ?: return arguments.singleOrNull()
     return firstArgument.takeIf { it.name == name }?.expression
 }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt

@@ -5,18 +5,22 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
+import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
-import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.*
-import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.argumentMapping
 import org.jetbrains.kotlin.fir.resolve.fqName
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.AnnotationTargetList
+import org.jetbrains.kotlin.resolve.AnnotationTargetLists
 
 object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     private val deprecatedClassId = FqName("kotlin.Deprecated")
@@ -37,33 +41,158 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
             } else if (fqName == deprecatedSinceKotlinClassId) {
                 deprecatedSinceKotlinCall = annotation
             }
+            withSuppressedDiagnostics(annotation, context) {
+                checkAnnotationTarget(declaration, annotation, context, reporter)
+            }
+        }
+        if (deprecatedSinceKotlinCall != null) {
+            withSuppressedDiagnostics(deprecatedSinceKotlinCall, context) {
+                checkDeprecatedCalls(deprecatedSinceKotlinCall, deprecatedCall, context, reporter)
+            }
+        }
+    }
+
+    private fun checkAnnotationTarget(
+        declaration: FirAnnotatedDeclaration,
+        annotation: FirAnnotationCall,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ) {
+        if (declaration is FirValueParameter && declaration.source?.hasValOrVar() == true) {
+            // This will be checked later as property
+            return
+        }
+        val actualTargets = getActualTargetList(declaration)
+        val applicableTargets = annotation.getAllowedAnnotationTargets(context.session)
+        val useSiteTarget = annotation.useSiteTarget
+
+        fun check(targets: List<KotlinTarget>) = targets.any {
+            it in applicableTargets && (useSiteTarget == null || KotlinTarget.USE_SITE_MAPPING[useSiteTarget] == it)
         }
 
-        if (deprecatedSinceKotlinCall != null) {
+        fun checkWithUseSiteTargets(): Boolean {
-            val closestFirFile = context.findClosest<FirFile>()
+            if (useSiteTarget == null) return false
-            if (closestFirFile != null && !closestFirFile.packageFqName.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName())) {
-                reporter.reportOn(
-                    deprecatedSinceKotlinCall.source,
-                    FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE,
-                    context
-                )
-            }
 
-            if (deprecatedCall == null) {
+            val useSiteMapping = KotlinTarget.USE_SITE_MAPPING[useSiteTarget]
-                reporter.reportOn(deprecatedSinceKotlinCall.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context)
+            return actualTargets.onlyWithUseSiteTarget.any { it in applicableTargets && it == useSiteMapping }
-            } else {
+        }
-                val argumentMapping = deprecatedCall.argumentMapping ?: return
+
-                for (value in argumentMapping.values) {
+        if (check(actualTargets.defaultTargets) || check(actualTargets.canBeSubstituted) || checkWithUseSiteTargets()) {
-                    if (value.name.identifier == "level") {
+            return
-                        reporter.reportOn(
+        }
-                            deprecatedSinceKotlinCall.source,
+
-                            FirErrors.DEPRECATED_SINCE_KOTLIN_WITH_DEPRECATED_LEVEL,
+        val targetDescription = actualTargets.defaultTargets.firstOrNull()?.description ?: "unidentified target"
-                            context
+        if (useSiteTarget != null) {
-                        )
+            reporter.reportOn(
-                        break
+                annotation.source,
-                    }
+                FirErrors.WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET,
+                targetDescription,
+                useSiteTarget.renderName,
+                context
+            )
+        } else {
+            reporter.reportOn(
+                annotation.source,
+                FirErrors.WRONG_ANNOTATION_TARGET,
+                targetDescription,
+                context
+            )
+        }
+    }
+
+    private fun checkDeprecatedCalls(
+        deprecatedSinceKotlinCall: FirAnnotationCall,
+        deprecatedCall: FirAnnotationCall?,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ) {
+        val closestFirFile = context.findClosest<FirFile>()
+        if (closestFirFile != null && !closestFirFile.packageFqName.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName())) {
+            reporter.reportOn(
+                deprecatedSinceKotlinCall.source,
+                FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE,
+                context
+            )
+        }
+
+        if (deprecatedCall == null) {
+            reporter.reportOn(deprecatedSinceKotlinCall.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context)
+        } else {
+            val argumentMapping = deprecatedCall.argumentMapping ?: return
+            for (value in argumentMapping.values) {
+                if (value.name.identifier == "level") {
+                    reporter.reportOn(
+                        deprecatedSinceKotlinCall.source,
+                        FirErrors.DEPRECATED_SINCE_KOTLIN_WITH_DEPRECATED_LEVEL,
+                        context
+                    )
+                    break
                 }
             }
         }
     }
-}
+
+    private fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
+        return when (annotated) {
+            is FirRegularClass -> {
+                AnnotationTargetList(
+                    KotlinTarget.classActualTargets(annotated.classKind, annotated.isInner, annotated.isCompanion, annotated.isLocal)
+                )
+            }
+            is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
+            is FirProperty -> {
+                when {
+                    annotated.isLocal ->
+                        if (annotated.source?.kind == FirFakeSourceElementKind.DesugaredComponentFunctionCall) {
+                            TargetLists.T_DESTRUCTURING_DECLARATION
+                        } else {
+                            TargetLists.T_LOCAL_VARIABLE
+                        }
+                    annotated.symbol.callableId.classId != null ->
+                        if (annotated.source?.kind == FirFakeSourceElementKind.PropertyFromParameter) {
+                            TargetLists.T_VALUE_PARAMETER_WITH_VAL
+                        } else {
+                            TargetLists.T_MEMBER_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
+                        }
+                    else ->
+                        TargetLists.T_TOP_LEVEL_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
+                }
+            }
+            is FirValueParameter -> TargetLists.T_VALUE_PARAMETER_WITHOUT_VAL
+            is FirConstructor -> TargetLists.T_CONSTRUCTOR
+            is FirAnonymousFunction -> {
+                TargetLists.T_FUNCTION_EXPRESSION
+            }
+            is FirSimpleFunction -> {
+                when {
+                    annotated.isLocal -> TargetLists.T_LOCAL_FUNCTION
+                    annotated.symbol.callableId.classId != null -> TargetLists.T_MEMBER_FUNCTION
+                    else -> TargetLists.T_TOP_LEVEL_FUNCTION
+                }
+            }
+            is FirTypeAlias -> TargetLists.T_TYPEALIAS
+            is FirPropertyAccessor -> if (annotated.isGetter) TargetLists.T_PROPERTY_GETTER else TargetLists.T_PROPERTY_SETTER
+            is FirFile -> TargetLists.T_FILE
+            is FirTypeParameter -> TargetLists.T_TYPE_PARAMETER
+            is FirAnonymousInitializer -> TargetLists.T_INITIALIZER
+            is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
+            is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
+            is FirAnonymousObject ->
+                if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
+                    AnnotationTargetList(
+                        KotlinTarget.classActualTargets(
+                            ClassKind.ENUM_ENTRY,
+                            isInnerClass = false,
+                            isCompanionObject = false,
+                            isLocalClass = false
+                        )
+                    )
+                } else {
+                    TargetLists.T_OBJECT_LITERAL
+                }
+            else -> TargetLists.EMPTY
+        }
+    }
+}
+
+private typealias TargetLists = AnnotationTargetLists

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -51,15 +51,15 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) {
-        checkers.allBasicDeclarationCheckers.check(anonymousFunction, data, reporter)
+        checkers.allAnnotatedDeclarationCheckers.check(anonymousFunction, data, reporter)
     }
 
     override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: CheckerContext) {
-        checkers.allBasicDeclarationCheckers.check(propertyAccessor, data, reporter)
+        checkers.allAnnotatedDeclarationCheckers.check(propertyAccessor, data, reporter)
     }
 
     override fun visitValueParameter(valueParameter: FirValueParameter, data: CheckerContext) {
-        checkers.allBasicDeclarationCheckers.check(valueParameter, data, reporter)
+        checkers.allAnnotatedDeclarationCheckers.check(valueParameter, data, reporter)
     }
 
     override fun visitTypeParameter(typeParameter: FirTypeParameter, data: CheckerContext) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -329,6 +329,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VAR_ANNOTATION_PA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VAR_OVERRIDDEN_BY_VAL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VAR_TYPE_MISMATCH_ON_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_ANNOTATION_TARGET
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_GETTER_RETURN_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_INVOCATION_KIND
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_MODIFIER_TARGET
@@ -478,6 +479,12 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             )
             map.put(ANNOTATION_ON_SUPERCLASS, "Annotations on superclass are meaningless")
             map.put(WRONG_ANNOTATION_TARGET, "This annotation is not applicable to target ''{0}''", TO_STRING);
+            map.put(
+                WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET,
+                "This annotation is not applicable to target ''{0}'' and use site target ''@{1}''",
+                TO_STRING,
+                TO_STRING
+            );
 
             // Exposed visibility group // #
             map.put(

compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt

@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
+class TopLevelClass<<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!> T> {
-    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
+    class InnerClass<<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!> T> {
         fun test() {
-            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T>
+            class InFun<<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!> T>
         }
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt

@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> topFun() = 12
+fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!>  T> topFun() = 12
 
 class SomeClass {
-    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> method() = 12
+    fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!> T> method() = 12
 
     fun foo() {
-        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> innerFun() = 12
+        fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!>  T> innerFun() = 12
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt

@@ -3,10 +3,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> T.topProp: Int get() = 12
+val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!>  T> T.topProp: Int get() = 12
 
 class SomeClass {
-    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> T.field: Int get() = 12
+    val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET!>@A2<!> <!WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET!>@A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)<!> T> T.field: Int get() = 12
 
     fun foo() {
         val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12

compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.fir.kt

@@ -2,6 +2,6 @@
 annotation class My
 data class Pair(val a: Int, val b: Int)
 fun foo(): Int {
-    val (@My private a, @My public b) = Pair(12, 34)
+    val (<!WRONG_ANNOTATION_TARGET!>@My<!> private a, <!WRONG_ANNOTATION_TARGET!>@My<!> public b) = Pair(12, 34)
     return a + b
 }

compiler/testData/diagnostics/tests/annotations/options/setterParam.fir.kt

@@ -5,4 +5,4 @@ annotation class Ann
 
 var x: Int
     get() = 1
-    set(@Ann private x) { }
+    set(<!WRONG_ANNOTATION_TARGET!>@Ann<!> private x) { }

compiler/testData/diagnostics/tests/annotations/options/targets/accessors.fir.kt

@@ -8,9 +8,9 @@ annotation class smartset
 annotation class base
 
 class My(x: Int) {
-    @smartget var y = x
+    <!WRONG_ANNOTATION_TARGET!>@smartget<!> var y = x
     @base @smartget @smartset get
     @base @smartget @smartset set
 
-    @base @smartget @smartset fun foo() = y
+    @base <!WRONG_ANNOTATION_TARGET!>@smartget<!> <!WRONG_ANNOTATION_TARGET!>@smartset<!> fun foo() = y
 }

compiler/testData/diagnostics/tests/annotations/options/targets/annotation.fir.kt

@@ -2,19 +2,19 @@
 
 @base annotation class derived
 
-@base class correct(@base val x: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(<!WRONG_ANNOTATION_TARGET!>@base<!> val x: Int) {
-    @base constructor(): this(0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0)
 }
 
-@base enum class My {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/classifier.fir.kt

@@ -3,19 +3,19 @@
 
 @base annotation class derived
 
-@base class correct(@base val x: Int, @base w: @base Int) {
+@base class correct(<!WRONG_ANNOTATION_TARGET!>@base<!> val x: Int, <!WRONG_ANNOTATION_TARGET!>@base<!> w: @base Int) {
-    @base constructor(): this(0, 0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0, 0)
 }
 
-@base enum class My @base constructor() {
+@base enum class My <!WRONG_ANNOTATION_TARGET!>@base<!> constructor() {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/constructor.fir.kt

@@ -1,20 +1,20 @@
 @Target(AnnotationTarget.CONSTRUCTOR) annotation class base
 
-@base annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived
 
-@base class correct(@base val x: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(<!WRONG_ANNOTATION_TARGET!>@base<!> val x: Int) {
     @base constructor(): this(0)
 }
 
-@base enum class My @base constructor() {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My @base constructor() {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/expr.fir.kt

@@ -6,7 +6,7 @@ annotation class special
 
 fun transform(i: Int, tr: (Int) -> Int): Int = <!WRONG_ANNOTATION_TARGET!>@base<!> @special tr(@special i)
 
-@base @special fun foo(i: Int): Int {
+@base <!WRONG_ANNOTATION_TARGET!>@special<!> fun foo(i: Int): Int {
     val j = <!WRONG_ANNOTATION_TARGET!>@base<!> @special i + 1
     if (j == 1) return foo(@special <!WRONG_ANNOTATION_TARGET!>@base<!> 42)
     return transform(@special j, @base @special { @special it * 2 })

compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt

@@ -2,32 +2,32 @@
 @Target(AnnotationTarget.FIELD) 
 annotation class Field
 
-@Field
+<!WRONG_ANNOTATION_TARGET!>@Field<!>
 annotation class Another
 
 @Field
 val x: Int = 42
 
-@Field
+<!WRONG_ANNOTATION_TARGET!>@Field<!>
 val y: Int
     get() = 13
 
-@Field
+<!WRONG_ANNOTATION_TARGET!>@Field<!>
-abstract class My(@Field arg: Int, @Field val w: Int) {
+abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: Int) {
     @Field
     val x: Int = arg
 
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     val y: Int
         get() = 0
 
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     abstract val z: Int
 
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     fun foo() {}
 
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.lazy { 42 }
 }
 
@@ -36,10 +36,10 @@ enum class Your {
 }
 
 interface His {
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     val x: Int
 
-    @Field
+    <!WRONG_ANNOTATION_TARGET!>@Field<!>
     val y: Int
         get() = 42
 }

compiler/testData/diagnostics/tests/annotations/options/targets/file.fir.kt

@@ -1,23 +0,0 @@
-// FILE: annotation.kt
-
-package test
-
-@Target(AnnotationTarget.FILE) annotation class special
-
-annotation class common
-
-// FILE: other.kt
-
-@file:special
-
-package test
-
-@special class Incorrect
-
-// FILE: another.kt
-
-@file:common
-
-package test
-
-@common class Correct

compiler/testData/diagnostics/tests/annotations/options/targets/file.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: annotation.kt
 
 package test

compiler/testData/diagnostics/tests/annotations/options/targets/function.fir.kt

@@ -1,22 +1,22 @@
 @Target(AnnotationTarget.FUNCTION) annotation class base
 
-@base annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived
 
-@base class correct(@base val x: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(<!WRONG_ANNOTATION_TARGET!>@base<!> val x: Int) {
-    @base constructor(): this(0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0)
 
     @base public fun baz() {}
 }
 
-@base enum class My @base constructor() {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My <!WRONG_ANNOTATION_TARGET!>@base<!> constructor() {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+@base fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    @base fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.fir.kt

@@ -1,21 +1,21 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 @Target(AnnotationTarget.<!UNRESOLVED_REFERENCE!>INIT<!>) annotation class incorrect
 
-@incorrect annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@incorrect<!> annotation class derived
 
-@incorrect class correct(@incorrect val x: Int, @incorrect w: @incorrect Int) {
+<!WRONG_ANNOTATION_TARGET!>@incorrect<!> class correct(<!WRONG_ANNOTATION_TARGET!>@incorrect<!> val x: Int, <!WRONG_ANNOTATION_TARGET!>@incorrect<!> w: @incorrect Int) {
-    @incorrect constructor(): this(0, 0)
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> constructor(): this(0, 0)
 }
 
-@incorrect enum class My @incorrect constructor() {
+<!WRONG_ANNOTATION_TARGET!>@incorrect<!> enum class My <!WRONG_ANNOTATION_TARGET!>@incorrect<!> constructor() {
-    @incorrect FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> FIRST,
-    @incorrect SECOND
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> SECOND
 }
 
-@incorrect fun foo(@incorrect y: @incorrect Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@incorrect<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@incorrect<!> y: @incorrect Int): Int {
-    @incorrect fun bar(@incorrect z: @incorrect Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@incorrect<!> z: @incorrect Int) = z + 1
-    @incorrect val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> val local = bar(y)
     return local
 }
 
-@incorrect val z = <!WRONG_ANNOTATION_TARGET!>@incorrect<!> 0
+<!WRONG_ANNOTATION_TARGET!>@incorrect<!> val z = <!WRONG_ANNOTATION_TARGET!>@incorrect<!> 0

compiler/testData/diagnostics/tests/annotations/options/targets/java.fir.kt

@@ -60,23 +60,23 @@ package test
 
 import test.AnnotationTargets.*
 
-@base @meta @type @konstructor annotation class KMeta
+@base @meta @type <!WRONG_ANNOTATION_TARGET!>@konstructor<!> annotation class KMeta
 
-@base @meta @type @method @multiple class KClass(
+@base <!WRONG_ANNOTATION_TARGET!>@meta<!> @type <!WRONG_ANNOTATION_TARGET!>@method<!> <!WRONG_ANNOTATION_TARGET!>@multiple<!> class KClass(
         @base @fieldann @parameter val y:
         @base @type Int) {
 
-    @base @multiple @fieldann @local val x = 0
+    @base @multiple @fieldann <!WRONG_ANNOTATION_TARGET!>@local<!> val x = 0
     @method @konstructor @type get
 
-    @base @method @multiple @konstructor
+    @base @method @multiple <!WRONG_ANNOTATION_TARGET!>@konstructor<!>
-    fun foo(@parameter @type i:
+    fun foo(@parameter <!WRONG_ANNOTATION_TARGET!>@type<!> i:
     @base @multiple Int
     ): @fieldann @parameter Int {
 
-        @local @base @multiple @fieldann val j = i + 1
+        @local @base <!WRONG_ANNOTATION_TARGET!>@multiple<!> <!WRONG_ANNOTATION_TARGET!>@fieldann<!> val j = i + 1
         <!WRONG_ANNOTATION_TARGET!>@base<!> <!WRONG_ANNOTATION_TARGET!>@multiple<!> return j
     }
 
-    @base @method @konstructor constructor(): this(0)
+    @base <!WRONG_ANNOTATION_TARGET!>@method<!> @konstructor constructor(): this(0)
 }

compiler/testData/diagnostics/tests/annotations/options/targets/local.fir.kt

@@ -1,20 +1,20 @@
 @Target(AnnotationTarget.LOCAL_VARIABLE) annotation class base
 
-@base annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived
 
-@base class correct(@base val x: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(<!WRONG_ANNOTATION_TARGET!>@base<!> val x: Int) {
-    @base constructor(): this(0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0)
 }
 
-@base enum class My {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
     @base val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/nested.fir.kt

@@ -1,15 +0,0 @@
-@Target(AnnotationTarget.CLASS)
-annotation class base
-
-@Target(AnnotationTarget.ANNOTATION_CLASS)
-annotation class meta
-
-@base class Outer {
-    @base @meta class Nested
-
-    @base @meta annotation class Annotated
-
-    fun foo() {
-        @base @meta class Local
-    }
-}

compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 @Target(AnnotationTarget.CLASS)
 annotation class base
 

compiler/testData/diagnostics/tests/annotations/options/targets/property.fir.kt

@@ -1,20 +1,20 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 @Target(AnnotationTarget.PROPERTY) annotation class base
 
-@base annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived
 
-@base class correct(@base val x: Int, @base w: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(@base val x: Int, <!WRONG_ANNOTATION_TARGET!>@base<!> w: Int) {
-    @base constructor(): this(0, 0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0, 0)
 }
 
-@base enum class My {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My {
     @base FIRST,
     @base SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>@base<!> y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>@base<!> z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 

compiler/testData/diagnostics/tests/annotations/options/targets/type.fir.kt

@@ -1,20 +0,0 @@
-@Target(AnnotationTarget.TYPE) annotation class base
-
-@base annotation class derived
-
-@base class correct(@base val x: @base Int) {
-    @base constructor(): this(0)
-}
-
-@base enum class My @base constructor() {
-    @base FIRST,
-    @base SECOND
-}
-
-@base fun foo(@base y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
-    @base val local = bar(y)
-    return local
-}
-
-@base val z = 0

compiler/testData/diagnostics/tests/annotations/options/targets/type.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 @Target(AnnotationTarget.TYPE) annotation class base
 
 <!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived

compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.fir.kt

@@ -24,10 +24,10 @@ class Class2 {
 }
 
 
-@A fun foo() {}
+<!WRONG_ANNOTATION_TARGET!>@A<!> fun foo() {}
-@A class D
+<!WRONG_ANNOTATION_TARGET!>@A<!> class D
 fun foo(i: @A Int) {
-    @A val i = 1
+    <!WRONG_ANNOTATION_TARGET!>@A<!> val i = 1
 }
 fun <T> test(t: @A T): T = t
 
@@ -35,4 +35,4 @@ fun <T> test(t: @A T): T = t
 @Target(AnnotationTarget.TYPE)
 internal annotation class C
 
-fun <@C T> test2(t: T): T = t
+fun <<!WRONG_ANNOTATION_TARGET!>@C<!> T> test2(t: T): T = t

compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.fir.kt

@@ -1,21 +1,21 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 @Target(AnnotationTarget.VALUE_PARAMETER) annotation class base
 
-@base annotation class derived
+<!WRONG_ANNOTATION_TARGET!>@base<!> annotation class derived
 
-@base class correct(@base val x: Int, @base w: Int) {
+<!WRONG_ANNOTATION_TARGET!>@base<!> class correct(@base val x: Int, @base w: Int) {
-    @base constructor(): this(0, 0)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> constructor(): this(0, 0)
 }
 
-@base enum class My {
+<!WRONG_ANNOTATION_TARGET!>@base<!> enum class My {
-    @base FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
-    @base SECOND
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
 }
 
-@base fun foo(@base y: @base Int): Int {
+<!WRONG_ANNOTATION_TARGET!>@base<!> fun foo(@base y: @base Int): Int {
-    @base fun bar(@base z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(@base z: @base Int) = z + 1
-    @base val local = bar(y)
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
     return local
 }
 
-@base val z = 0
+<!WRONG_ANNOTATION_TARGET!>@base<!> val z = 0

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.fir.kt

@@ -8,26 +8,26 @@ class CustomDelegate {
     operator fun getValue(thisRef: Any?, prop: KProperty<*>): String = prop.name
 }
 
-@delegate:Field
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Field<!>
 class SomeClass {
 
-    @delegate:Field
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Field<!>
     constructor()
 
-    @delegate:Field @delegate:Prop
+    @delegate:Field <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Prop<!>
     protected val simpleProperty: String = "text"
 
-    @delegate:Field @delegate:Prop
+    @delegate:Field <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Prop<!>
     protected val delegatedProperty: String by CustomDelegate()
 
-    @delegate:Field @delegate:Prop
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Field<!> <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Prop<!>
     val propertyWithCustomGetter: Int
         get() = 5
 
 }
 
-class WithPrimaryConstructor(@delegate:Field @delegate:Prop val a: String,
+class WithPrimaryConstructor(@delegate:Field <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Prop<!> val a: String,
-                             @param:Field @param:Prop val b: String)
+                             <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@param:Field<!> <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@param:Prop<!> val b: String)
 
-fun foo(@delegate:Field @delegate:Prop x: Int) = x
+fun foo(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Field<!> <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@delegate:Prop<!> x: Int) = x
 

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.fir.kt

@@ -6,10 +6,10 @@ class CustomDelegate {
     operator fun getValue(thisRef: Any?, prop: KProperty<*>): String = prop.name
 }
 
-@field:Ann
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!>
 class SomeClass {
 
-    @field:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!>
     constructor()
 
     @field:Ann
@@ -21,13 +21,13 @@ class SomeClass {
     @field:Ann
     protected val delegatedProperty: String by CustomDelegate()
 
-    @field:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!>
     val propertyWithCustomGetter: Int
         get() = 5
 
-    @field:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!>
-    fun anotherFun(@field:Ann s: String) {
+    fun anotherFun(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!> s: String) {
-        @field:Ann
+        <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@field:Ann<!>
         val localVariable = 5
     }
 

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.fir.kt

@@ -1,12 +0,0 @@
-// FILE: annotations.kt
-@Target(AnnotationTarget.CLASS)
-public annotation class ClassAnn
-
-@Target(AnnotationTarget.FILE)
-public annotation class FileAnn
-
-// FILE: 1.kt
-@file:ClassAnn
-
-// FILE: 2.kt
-@file:FileAnn

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: annotations.kt
 @Target(AnnotationTarget.CLASS)
 public annotation class ClassAnn

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.fir.kt

@@ -1,39 +0,0 @@
-import kotlin.reflect.KProperty
-
-annotation class Ann
-
-class CustomDelegate {
-    operator fun getValue(thisRef: Any?, prop: KProperty<*>): String = prop.name
-}
-
-@get:Ann
-class SomeClass {
-
-    @get:Ann
-    constructor()
-
-    @get:Ann
-    protected val simpleProperty: String = "text"
-
-    @get:Ann
-    protected var mutableProperty: String = "text"
-
-    @get:[Ann]
-    protected val simplePropertyWithAnnotationList: String = "text"
-
-    @get:Ann
-    protected val delegatedProperty: String by CustomDelegate()
-
-    @get:Ann
-    val propertyWithCustomGetter: Int
-        get() = 5
-
-    @get:Ann
-    fun annotationOnFunction(a: Int) = a + 5
-
-    fun anotherFun() {
-        @get:Ann
-        val localVariable = 5
-    }
-
-}

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 import kotlin.reflect.KProperty
 
 annotation class Ann

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.fir.kt

@@ -1,10 +1,10 @@
 annotation class Ann
 annotation class Second
 
-@param:Ann
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@param:Ann<!>
 class SomeClass {
 
-    @param:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@param:Ann<!>
     constructor(@param:Ann a: String)
 
     @param:Ann

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.fir.kt

@@ -1,39 +0,0 @@
-import kotlin.reflect.KProperty
-
-annotation class Ann
-annotation class Second
-
-class CustomDelegate {
-    operator fun getValue(thisRef: Any?, prop: KProperty<*>): String = prop.name
-}
-
-@property:Ann
-class SomeClass {
-
-    @property:Ann
-    constructor(s: String)
-
-    @property:Ann
-    protected val p1: String = ""
-
-    @property:[Ann Second]
-    protected val p2: String = ""
-
-    @property:Ann
-    protected var p3: String = ""
-
-    @property:Ann
-    protected val p4: String by CustomDelegate()
-
-    @property:Ann
-    var propertyWithCustomSetter: Int
-        get() = 5
-        set(v) {}
-
-    @property:Ann
-    fun anotherFun() {
-        @property:Ann
-        val localVariable = 5
-    }
-
-}

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 import kotlin.reflect.KProperty
 
 annotation class Ann

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.fir.kt

@@ -1,9 +1,9 @@
 annotation class Ann
 
-@receiver:Ann
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@receiver:Ann<!>
 class SomeClass {
 
-    @receiver:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@receiver:Ann<!>
     constructor(@receiver:Ann a: String)
 
     @receiver:Ann

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.fir.kt

@@ -7,7 +7,7 @@ class CustomDelegate {
     operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {}
 }
 
-@set:Ann
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@set:Ann<!>
 class SomeClass {
 
     @set:Ann
@@ -27,7 +27,7 @@ class SomeClass {
         get() = 5
         set(v) {}
 
-    @set:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@set:Ann<!>
     fun annotationOnFunction(a: Int) = a + 5
 
     fun anotherFun() {

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.fir.kt

@@ -7,10 +7,10 @@ class CustomDelegate {
     operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {}
 }
 
-@setparam:Ann
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@setparam:Ann<!>
 class SomeClass {
 
-    @setparam:Ann
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@setparam:Ann<!>
     constructor()
 
     @setparam:Ann

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.fir.kt

@@ -1,12 +1,12 @@
 package bar
 
-<!MUST_BE_INITIALIZED!>@file:foo
+<!MUST_BE_INITIALIZED!><!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file:foo<!>
 val prop<!>
 
-@file:[bar baz]
+@file:[<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>bar<!> <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>baz<!>]
 fun func() {}
 
-@file:[baz]
+@file:[<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>baz<!>]
 class C
 
 <!SYNTAX!>@file:<!>

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.fir.kt

@@ -1,6 +1,6 @@
-@file:foo
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file:foo<!>
 @foo @bar
-@file:[baz]
+@file:[<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>baz<!>]
 fun test() {}
 
 annotation class foo

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.fir.kt

@@ -1,6 +1,6 @@
-@file:foo
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file:foo<!>
 @foo @bar
-@file: baz
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file: baz<!>
 fun test() {}
 
 annotation class foo

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.fir.kt

@@ -1,9 +1,9 @@
 // !LANGUAGE: +RestrictionOfWrongAnnotationsWithUseSiteTargetsOnTypes
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-fun test1(@file<!SYNTAX!><!> Suppress("") x: Int) {}
+fun test1(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file<!SYNTAX!><!> Suppress("")<!> x: Int) {}
 
-@file <!SYNTAX!>@<!>Suppress("")
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file <!SYNTAX!>@<!>Suppress("")<!>
 fun test2() {}
 
 class OnType(x: @file<!SYNTAX!><!> Suppress("") Int)

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.fir.kt

@@ -1,9 +1,9 @@
 // !LANGUAGE: -RestrictionOfWrongAnnotationsWithUseSiteTargetsOnTypes
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-fun test1(@file<!SYNTAX!><!> Suppress("") x: Int) {}
+fun test1(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file<!SYNTAX!><!> Suppress("")<!> x: Int) {}
 
-@file <!SYNTAX!>@<!>Suppress("")
+<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file <!SYNTAX!>@<!>Suppress("")<!>
 fun test2() {}
 
 class OnType(x: @file<!SYNTAX!><!> Suppress("") Int)

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.fir.kt

@@ -45,12 +45,12 @@ annotation class fieldOrPropAnn
 @Target(AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.VALUE_PARAMETER)
 annotation class getSetAndParamAnn
 
-public class B(@param:fieldOrPropAnn @fieldOrPropAnn val x: Int,
+public class B(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@param:fieldOrPropAnn<!> @fieldOrPropAnn val x: Int,
                @property:fieldOrPropAnn @fieldOrPropAnn val y: Int) {
     @fieldOrPropAnn @field:fieldOrPropAnn
     val z: Int = 42
 
-    @getSetAndParamAnn
+    <!WRONG_ANNOTATION_TARGET!>@getSetAndParamAnn<!>
     @setparam:getSetAndParamAnn
     var w: Int
         @getSetAndParamAnn @get:getSetAndParamAnn get() = 0

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.fir.kt

@@ -8,7 +8,7 @@ fun foo(block: (A) -> Unit) { }
 annotation class Ann
 
 fun bar() {
-    foo { (private inline a, @Ann b) ->
+    foo { (private inline a, <!WRONG_ANNOTATION_TARGET!>@Ann<!> b) ->
         a checkType { _<Int>() }
         b checkType { _<String>() }
     }

compiler/testData/diagnostics/tests/typealias/annotationsOnTypeAliases.fir.kt

@@ -1,15 +0,0 @@
-// WITH_RUNTIME
-import kotlin.annotation.AnnotationTarget.*
-
-annotation class NoTarget
-
-@Target(CLASS)
-annotation class IrrelevantTarget
-
-@Target(TYPEALIAS)
-annotation class TypealiasTarget
-
-@NoTarget
-@IrrelevantTarget
-@TypealiasTarget
-typealias Test = String

compiler/testData/diagnostics/tests/typealias/annotationsOnTypeAliases.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // WITH_RUNTIME
 import kotlin.annotation.AnnotationTarget.*
 

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.fir.kt

@@ -8,6 +8,6 @@ interface Test {
     @get:Synchronized
     val c: Int
 
-    @get:JvmOverloads
+    <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@get:JvmOverloads<!>
     val d: Int
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmName.fir.kt

@@ -6,10 +6,10 @@ fun foo() {}
 @JvmName("b")
 fun Any.foo() {}
 
-@JvmName("c")
+<!WRONG_ANNOTATION_TARGET!>@JvmName("c")<!>
 val px = 1
 
-@JvmName("d")
+<!WRONG_ANNOTATION_TARGET!>@JvmName("d")<!>
 val Any.px : Int
     get() = 1
 
@@ -29,9 +29,9 @@ var vardef: Int = 1
     @JvmName("i")
     set
 
-@JvmName("C")
+<!WRONG_ANNOTATION_TARGET!>@JvmName("C")<!>
-class C @JvmName("primary") constructor() {
+class C <!WRONG_ANNOTATION_TARGET!>@JvmName("primary")<!> constructor() {
-    @JvmName("ctr") constructor(x: Int): this() {}
+    <!WRONG_ANNOTATION_TARGET!>@JvmName("ctr")<!> constructor(x: Int): this() {}
 
     @JvmName("a")
     fun foo() {}
@@ -39,10 +39,10 @@ class C @JvmName("primary") constructor() {
     @JvmName("b")
     fun Any.foo() {}
 
-    @JvmName("c")
+    <!WRONG_ANNOTATION_TARGET!>@JvmName("c")<!>
     val px = 1
 
-    @JvmName("d")
+    <!WRONG_ANNOTATION_TARGET!>@JvmName("d")<!>
     val Any.px : Int
     get() = 1
 
@@ -61,7 +61,7 @@ fun foo1() {
     @JvmName("a")
     fun foo() {}
 
-    @JvmName("a")
+    <!WRONG_ANNOTATION_TARGET!>@JvmName("a")<!>
     val x = 1
 }
 

compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.fir.kt

@@ -4,6 +4,6 @@ class A
 @Metadata(extraString = "_")
 annotation class B(val m: Metadata)
 
-@Metadata(extraInt = 0)
+<!WRONG_ANNOTATION_TARGET!>@Metadata(extraInt = 0)<!>
 @B(Metadata())
 fun f() {}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/propertyAccessor.fir.kt

@@ -5,10 +5,10 @@ interface B {
 
     @JvmDefault
     val prop1: String
-    @JvmDefault get() = ""
+    <!WRONG_ANNOTATION_TARGET!>@JvmDefault<!> get() = ""
 
 
     var prop2: String
-        @JvmDefault get() = ""
+        <!WRONG_ANNOTATION_TARGET!>@JvmDefault<!> get() = ""
-        @JvmDefault set(value) {}
+        <!WRONG_ANNOTATION_TARGET!>@JvmDefault<!> set(value) {}
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability_1_5.fir.kt

@@ -1,27 +1,27 @@
 // !LANGUAGE: +NestedClassesInAnnotations +InlineClasses -JvmInlineValueClasses -ProhibitJvmFieldOnOverrideFromInterfaceInPrimaryConstructor
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 
-@kotlin.jvm.JvmField
+<!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!>
 fun foo() {
-    @kotlin.jvm.JvmField val x = "A"
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> val x = "A"
 }
 
 annotation class DemoAnnotation
 
-@JvmField
+<!WRONG_ANNOTATION_TARGET!>@JvmField<!>
 abstract class C : I{
 
-    @kotlin.jvm.JvmField constructor(s: String) {
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> constructor(s: String) {
     }
 
-    @kotlin.jvm.JvmField private fun foo(s: String = "OK") {
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> private fun foo(s: String = "OK") {
     }
 
-    @JvmField val a: String by lazy { "A" }
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val a: String by lazy { "A" }
 
     @JvmField open val b: Int = 3
 
-    @JvmField abstract val c: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> abstract val c: Int
 
     @JvmField
     val customGetter: String = ""
@@ -49,7 +49,7 @@ abstract class C : I{
             field = s
         }
 
-    @JvmField
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!>
     val noBackingField: String
         get() = "a"
 
@@ -61,8 +61,8 @@ abstract class C : I{
 }
 
 interface I {
-    @JvmField val ai: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val ai: Int
-    @JvmField val bi: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val bi: Int
         get() = 5
 }
 

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability_1_6.fir.kt

@@ -1,27 +1,27 @@
 // !LANGUAGE: +NestedClassesInAnnotations +InlineClasses -JvmInlineValueClasses +ProhibitJvmFieldOnOverrideFromInterfaceInPrimaryConstructor
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 
-@kotlin.jvm.JvmField
+<!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!>
 fun foo() {
-    @kotlin.jvm.JvmField val x = "A"
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> val x = "A"
 }
 
 annotation class DemoAnnotation
 
-@JvmField
+<!WRONG_ANNOTATION_TARGET!>@JvmField<!>
 abstract class C : I{
 
-    @kotlin.jvm.JvmField constructor(s: String) {
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> constructor(s: String) {
     }
 
-    @kotlin.jvm.JvmField private fun foo(s: String = "OK") {
+    <!WRONG_ANNOTATION_TARGET!>@kotlin.jvm.JvmField<!> private fun foo(s: String = "OK") {
     }
 
-    @JvmField val a: String by lazy { "A" }
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val a: String by lazy { "A" }
 
     @JvmField open val b: Int = 3
 
-    @JvmField abstract val c: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> abstract val c: Int
 
     @JvmField
     val customGetter: String = ""
@@ -49,7 +49,7 @@ abstract class C : I{
             field = s
         }
 
-    @JvmField
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!>
     val noBackingField: String
         get() = "a"
 
@@ -61,8 +61,8 @@ abstract class C : I{
 }
 
 interface I {
-    @JvmField val ai: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val ai: Int
-    @JvmField val bi: Int
+    <!WRONG_ANNOTATION_TARGET!>@JvmField<!> val bi: Int
         get() = 5
 }
 

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructors.fir.kt

@@ -1,8 +0,0 @@
-class A {
-    @JvmStatic constructor() {}
-    inner class B {
-        @JvmStatic constructor() {}
-    }
-}
-
-class C @JvmStatic constructor()

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructors.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
     <!WRONG_ANNOTATION_TARGET!>@JvmStatic<!> constructor() {}
     inner class B {

compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithDisabledFeature.fir.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_TYPEALIAS_PARAMETER
 // !LANGUAGE: -TrailingCommas
 
-@Target(AnnotationTarget.TYPE)
+@Target(AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER)
 annotation class Anno
 
 class Foo1<T1,>

compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithDisabledFeature.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_TYPEALIAS_PARAMETER
 // !LANGUAGE: -TrailingCommas
 
-@Target(AnnotationTarget.TYPE)
+@Target(AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER)
 annotation class Anno
 
 class Foo1<T1<!UNSUPPORTED_FEATURE!>,<!>>

compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithDisabledFeature.txt

@@ -19,7 +19,7 @@ public interface A1</*0*/ T> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Anno : kotlin.Annotation {
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER}) public final annotation class Anno : kotlin.Annotation {
     public constructor Anno()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int

compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithEnabledFeature.kt

@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_TYPEALIAS_PARAMETER
 // !LANGUAGE: +TrailingCommas
 
-@Target(AnnotationTarget.TYPE)
+@Target(AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER)
 annotation class Anno
 
 class Foo1<T1,>

compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithEnabledFeature.txt

@@ -20,7 +20,7 @@ public interface A1</*0*/ T> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Anno : kotlin.Annotation {
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER}) public final annotation class Anno : kotlin.Annotation {
     public constructor Anno()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -620,6 +620,14 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET) { firDiagnostic ->
+        WrongAnnotationTargetWithUseSiteTargetImpl(
+            firDiagnostic.a,
+            firDiagnostic.b,
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
     add(FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE) { firDiagnostic ->
         ExposedTypealiasExpandedTypeImpl(
             firDiagnostic.a,

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -443,6 +443,12 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
         abstract val actualTarget: String
     }
 
+    abstract class WrongAnnotationTargetWithUseSiteTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+        override val diagnosticClass get() = WrongAnnotationTargetWithUseSiteTarget::class
+        abstract val actualTarget: String
+        abstract val useSiteTarget: String
+    }
+
     abstract class ExposedTypealiasExpandedType : KtFirDiagnostic<KtNamedDeclaration>() {
         override val diagnosticClass get() = ExposedTypealiasExpandedType::class
         abstract val elementVisibility: EffectiveVisibility

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -720,6 +720,15 @@ internal class WrongAnnotationTargetImpl(
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
+internal class WrongAnnotationTargetWithUseSiteTargetImpl(
+    override val actualTarget: String,
+    override val useSiteTarget: String,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.WrongAnnotationTargetWithUseSiteTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class ExposedTypealiasExpandedTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,