[FIR] Fix handling of WRONG_MODIFIER_TARGET

Implement DEPRECATED_MODIFIER, DEPRECATED_MODIFIER_FOR_TARGET, REDUNDANT_MODIFIER_FOR_TARGET

compiler/fir/analysis-tests/testData/resolve/constVal/constValNotTopLevelOrObject.kt

@@ -38,5 +38,5 @@ object F {
 }
 
 fun foo() {
-    const val a = "2"
+    <!WRONG_MODIFIER_TARGET!>const<!> val a = "2"
 }

compiler/fir/analysis-tests/testData/resolve/diagnostics/infixFunctions.kt

@@ -6,11 +6,11 @@ infix fun Int.good(x: Int) {}
 
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun baz(x: Int, y: Int) {}<!>
 
-infix class A
+<!WRONG_MODIFIER_TARGET!>infix<!> class A
 
-infix typealias B = A
+<!WRONG_MODIFIER_TARGET!>infix<!> typealias B = A
 
-infix val x = 1
+<!WRONG_MODIFIER_TARGET!>infix<!> val x = 1
 
 class C {
     infix fun good(x: Int) {}

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

@@ -82,4 +82,4 @@ abstract interface AbstractInterface
 // Redundant final object
 <!REDUNDANT_MODALITY_MODIFIER!>final<!> object FinalObject
 // Open interface
-open interface OpenInterface
+<!REDUNDANT_MODIFIER_FOR_TARGET!>open<!> interface OpenInterface

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

@@ -1,5 +1,5 @@
 fun f() {
-    <!REDUNDANT_VISIBILITY_MODIFIER!>public<!> <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE!>baz<!> = 0
+    <!REDUNDANT_VISIBILITY_MODIFIER, WRONG_MODIFIER_TARGET!>public<!> <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE!>baz<!> = 0
     class LocalClass {
         <!REDUNDANT_VISIBILITY_MODIFIER!>internal<!> var foo = 0
     }

compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassDeclaration.kt

@@ -1,7 +1,7 @@
 class A {
     <!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> inner class B(val x: Int)
     fun foo() {
-        <!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> class C(val x: Int)
+        <!INLINE_CLASS_NOT_TOP_LEVEL, WRONG_MODIFIER_TARGET!>inline<!> class C(val x: Int)
     }
     inner <!INLINE_CLASS_NOT_TOP_LEVEL!>value<!> class D(val x: Int)
 }

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

@@ -307,10 +307,22 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<String>("redundantModifier")
             parameter<String>("conflictingModifier")
         }
+        val DEPRECATED_MODIFIER by warning<PsiElement> {
+            parameter<String>("deprecatedModifier")
+            parameter<String>("actualModifier")
+        }
         val DEPRECATED_MODIFIER_PAIR by error<PsiElement> {
             parameter<String>("deprecatedModifier")
             parameter<String>("conflictingModifier")
         }
+        val DEPRECATED_MODIFIER_FOR_TARGET by warning<PsiElement> {
+            parameter<String>("deprecatedModifier")
+            parameter<String>("target")
+        }
+        val REDUNDANT_MODIFIER_FOR_TARGET by warning<PsiElement> {
+            parameter<String>("redundantModifier")
+            parameter<String>("target")
+        }
         val INCOMPATIBLE_MODIFIERS by error<PsiElement> {
             parameter<String>("modifier1")
             parameter<String>("modifier2")

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

@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.lexer.KtKeywordToken
-import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtAnnotationEntry
@@ -256,7 +255,10 @@ object FirErrors {
     val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
     val REPEATED_MODIFIER by error1<PsiElement, String>()
     val REDUNDANT_MODIFIER by error2<PsiElement, String, String>()
+    val DEPRECATED_MODIFIER by warning2<PsiElement, String, String>()
     val DEPRECATED_MODIFIER_PAIR by error2<PsiElement, String, String>()
+    val DEPRECATED_MODIFIER_FOR_TARGET by warning2<PsiElement, String, String>()
+    val REDUNDANT_MODIFIER_FOR_TARGET by warning2<PsiElement, String, String>()
     val INCOMPATIBLE_MODIFIERS by error2<PsiElement, String, String>()
     val REDUNDANT_OPEN_IN_INTERFACE by warning0<KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
     val WRONG_MODIFIER_TARGET by error2<PsiElement, String, String>()

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
@@ -33,13 +34,12 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.*
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
+import org.jetbrains.kotlin.resolve.AnnotationTargetList
+import org.jetbrains.kotlin.resolve.AnnotationTargetLists
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
@@ -671,3 +671,80 @@ fun FirFunctionSymbol<*>.isFunctionForExpectTypeFromCastFeature(): Boolean {
 
     return true
 }
+
+fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
+    fun CallableId.isMember(): Boolean {
+        return classId != null || isLocal // TODO: Replace with .containingClass (after fixing)
+    }
+
+    return when (annotated) {
+        is FirRegularClass -> {
+            AnnotationTargetList(
+                KotlinTarget.classActualTargets(annotated.classKind, annotated.isInner, annotated.isCompanion, annotated.isLocal)
+            )
+        }
+        is FirEnumEntry -> AnnotationTargetList(
+            KotlinTarget.classActualTargets(ClassKind.ENUM_ENTRY, annotated.isInner, isCompanionObject = false, isLocalClass = false)
+        )
+        is FirProperty -> {
+            when {
+                annotated.isLocal ->
+                    if (annotated.source?.kind == FirFakeSourceElementKind.DesugaredComponentFunctionCall) {
+                        TargetLists.T_DESTRUCTURING_DECLARATION
+                    } else {
+                        TargetLists.T_LOCAL_VARIABLE
+                    }
+                annotated.symbol.callableId.isMember() ->
+                    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 -> {
+            when {
+                annotated.hasValOrVar -> TargetLists.T_VALUE_PARAMETER_WITH_VAL
+                else -> 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.isMember() -> 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 FirAnonymousObject ->
+            if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
+                AnnotationTargetList(
+                    KotlinTarget.classActualTargets(
+                        ClassKind.ENUM_ENTRY,
+                        isInnerClass = false,
+                        isCompanionObject = false,
+                        isLocalClass = false
+                    )
+                )
+            } else {
+                TargetLists.T_OBJECT_LITERAL
+            }
+//            TODO: properly implement those cases
+//            is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
+//            is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
+//            is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
+        else -> TargetLists.EMPTY
+    }
+}
+
+private typealias TargetLists = AnnotationTargetLists

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

@@ -11,6 +11,7 @@ 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.checkers.getActualTargetList
 import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -198,72 +199,5 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
             }
         }
     }
-
-    private fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
-        return when (annotated) {
-            is FirRegularClass -> {
-                AnnotationTargetList(
-                    KotlinTarget.classActualTargets(annotated.classKind, annotated.isInner, annotated.isCompanion, annotated.isLocal)
-                )
-            }
-            is FirEnumEntry -> AnnotationTargetList(
-                KotlinTarget.classActualTargets(ClassKind.ENUM_ENTRY, annotated.isInner, isCompanionObject = false, isLocalClass = false)
-            )
-            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 FirAnonymousObject ->
-                if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
-                    AnnotationTargetList(
-                        KotlinTarget.classActualTargets(
-                            ClassKind.ENUM_ENTRY,
-                            isInnerClass = false,
-                            isCompanionObject = false,
-                            isLocalClass = false
-                        )
-                    )
-                } else {
-                    TargetLists.T_OBJECT_LITERAL
-                }
-//            TODO: properly implement those cases
-//            is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
-//            is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
-//            is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
-            else -> TargetLists.EMPTY
-        }
-    }
 }
 
-private typealias TargetLists = AnnotationTargetLists

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

@@ -5,61 +5,65 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
-import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.analysis.checkers.FirModifier
+import org.jetbrains.kotlin.fir.analysis.checkers.*
-import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
-import org.jetbrains.kotlin.fir.analysis.checkers.getKeywordType
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory2
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor
-import org.jetbrains.kotlin.resolve.Compatibility
+import org.jetbrains.kotlin.fir.declarations.utils.hasBody
-import org.jetbrains.kotlin.resolve.KeywordType
+import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
-import org.jetbrains.kotlin.resolve.compatibility
+import org.jetbrains.kotlin.fir.declarations.utils.isInner
+import org.jetbrains.kotlin.fir.declarations.utils.isLocal
+import org.jetbrains.kotlin.fir.languageVersionSettings
+import org.jetbrains.kotlin.resolve.*
 
 object FirModifierChecker : FirBasicDeclarationChecker() {
     override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirFile) return
 
         val source = declaration.source ?: return
-        if (!isDeclarationMappedToSourceCorrectly(declaration, source)) return
+        if (source.kind is FirFakeSourceElementKind) return
-        if (context.containingDeclarations.last() is FirDefaultPropertyAccessor) return
 
-        val modifierList = source.getModifierList()
+        if (declaration is FirProperty) {
-        modifierList?.let { checkModifiers(it, declaration, reporter, context) }
+            fun checkPropertyAccessor(propertyAccessor: FirPropertyAccessor?) {
-    }
+                if (propertyAccessor != null && !propertyAccessor.hasBody) {
+                    check(propertyAccessor, context, reporter)
+                }
+            }
 
-    private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration, source: FirSourceElement): Boolean =
+            checkPropertyAccessor(declaration.getter)
-        when (source.elementType) {
+            checkPropertyAccessor(declaration.setter)
-            KtNodeTypes.CLASS -> declaration is FirClass
-            KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass
-            KtNodeTypes.PROPERTY -> declaration is FirProperty
-            KtNodeTypes.VALUE_PARAMETER -> declaration is FirValueParameter
-            // TODO more FIR-PSI relations possibly have to be added
-            else -> true
         }
 
+        source.getModifierList()?.let { checkModifiers(it, declaration, context, reporter) }
+    }
+
     private fun checkModifiers(
         list: FirModifierList,
         owner: FirDeclaration,
-        reporter: DiagnosticReporter,
+        context: CheckerContext,
-        context: CheckerContext
+        reporter: DiagnosticReporter
     ) {
         // general strategy: report no more than one error and any number of warnings
         // therefore, a track of nodes with already reported errors should be kept
         val reportedNodes = hashSetOf<FirModifier<*>>()
+        val actualTargets = getActualTargetList(owner).defaultTargets
 
         val modifiers = list.modifiers
-        for (secondModifier in modifiers) {
+        for ((secondIndex, secondModifier) in modifiers.withIndex()) {
-            for (firstModifier in modifiers) {
+            for (firstIndex in 0 until secondIndex) {
-                if (firstModifier == secondModifier) {
+                checkCompatibilityType(modifiers[firstIndex], secondModifier, reporter, reportedNodes, owner, context)
-                    break
+            }
+            if (secondModifier !in reportedNodes) {
+                when {
+                    !checkTarget(modifierSource, modifierType, actualTargets, parent, context, reporter) -> reportedNodes += secondModifier
+                    !checkParent(modifierSource, modifierType, actualParents, context, reporter) -> reportedNodes += secondModifier
                 }
-                checkCompatibilityType(firstModifier, secondModifier, reporter, reportedNodes, owner, context)
             }
         }
     }
@@ -141,7 +145,68 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
         }
     }
 
-    private fun KeywordType.render(): String {
+    private fun checkTarget(
-        return this.toString().lowercase()
+        modifier: FirModifier<*>,
+        actualTargets: List<KotlinTarget>,
+        parent: FirDeclaration?,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ): Boolean {
+        val modifierType = getKeywordType(modifier)
+
+        fun checkModifier(factory: FirDiagnosticFactory2<String, String>): Boolean {
+            val map = when (factory) {
+                FirErrors.WRONG_MODIFIER_TARGET -> possibleTargetMap
+                FirErrors.DEPRECATED_MODIFIER_FOR_TARGET -> deprecatedTargetMap
+                else -> redundantTargetMap
+            }
+            val set = map[modifierType] ?: emptySet()
+            val checkResult = if (factory == FirErrors.WRONG_MODIFIER_TARGET) {
+                actualTargets.none { it in set }
+            } else {
+                actualTargets.any { it in set }
+            }
+            if (checkResult) {
+                reporter.reportOn(
+                    modifier.source,
+                    factory,
+                    modifierType.render(),
+                    actualTargets.firstOrThis(),
+                    context
+                )
+                return false
+            }
+            return true
+        }
+
+        if (!checkModifier(FirErrors.WRONG_MODIFIER_TARGET)) {
+            return false
+        }
+
+        if (parent is FirRegularClass) {
+            if (modifierType == KeywordType.Expect || modifierType == KeywordType.Header) {
+                reporter.reportOn(modifierSource, FirErrors.WRONG_MODIFIER_TARGET, modifierType.render(), "nested class", context)
+                return false
+            }
+        }
+
+        val deprecatedModifierReplacement = deprecatedModifierMap[modifierType]
+        if (deprecatedModifierReplacement != null) {
+            reporter.reportOn(
+                modifier.source,
+                FirErrors.DEPRECATED_MODIFIER,
+                modifierType.render(),
+                deprecatedModifierReplacement.render(),
+                context
+            )
+        } else if (checkModifier(FirErrors.DEPRECATED_MODIFIER_FOR_TARGET)) {
+            checkModifier(FirErrors.REDUNDANT_MODIFIER_FOR_TARGET)
+        }
+
+        return true
+    }
+
+    private fun List<KotlinTarget>.firstOrThis(): String {
+        return firstOrNull()?.description ?: "this"
     }
 }

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

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.diagnostics.rendering.Renderers.RENDER_POSITION_VARI
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers.STRING
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers.commaSeparated
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.AMBIGUOUS_CALLS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.COLLECTION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECLARATION_NAME
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FIR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FQ_NAMES_IN_TYPES
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.COLLECTION
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.MODULE_DATA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FUNCTION_PARAMETERS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.MODULE_DATA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NOT_RENDERED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NULLABLE_STRING
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_CLASS_OR_OBJECT
@@ -125,6 +125,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_IN_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_NOT_TO_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER_FOR_TARGET
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER_PAIR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_ARGUMENTS
@@ -340,6 +342,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_EXPLICI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODALITY_MODIFIER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODIFIER
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODIFIER_FOR_TARGET
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_OPEN_IN_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_PROJECTION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_RETURN_UNIT_TYPE
@@ -466,7 +469,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_MODIFIER_TA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_SETTER_PARAMETER_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_SETTER_RETURN_TYPE
-import org.jetbrains.kotlin.name.StandardClassIds
 
 @Suppress("unused")
 class FirDefaultErrorMessages {
@@ -727,7 +729,10 @@ class FirDefaultErrorMessages {
             map.put(INAPPLICABLE_INFIX_MODIFIER, "''infix'' modifier is inapplicable on this function")
             map.put(REPEATED_MODIFIER, "Repeated ''{0}''", STRING)
             map.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", STRING, STRING)
+            map.put(DEPRECATED_MODIFIER, "Modifier ''{0}'' is deprecated, use ''{1}'' instead", STRING, STRING)
             map.put(DEPRECATED_MODIFIER_PAIR, "Modifier ''{0}'' is deprecated in presence of ''{1}''", STRING, STRING)
+            map.put(DEPRECATED_MODIFIER_FOR_TARGET, "Modifier ''{0}'' is deprecated for ''{1}''", STRING, STRING)
+            map.put(REDUNDANT_MODIFIER_FOR_TARGET, "Modifier ''{0}'' is redundant for ''{1}''", STRING, STRING)
             map.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", STRING, STRING)
             map.put(REDUNDANT_OPEN_IN_INTERFACE, "Modifier 'open' is redundant for abstract interface members")
             map.put(WRONG_MODIFIER_TARGET, "Modifier ''{0}'' is not applicable to ''{1}''", STRING, STRING)

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -1379,7 +1379,7 @@ class DeclarationsConverter(
         }
 
         return buildValueParameter {
-            source = setterParameter.toFirSourceElement()
+            source = firValueParameter.source
             moduleData = baseModuleData
             origin = FirDeclarationOrigin.Source
             returnTypeRef = if (firValueParameter.returnTypeRef == implicitType) propertyTypeRef else firValueParameter.returnTypeRef

compiler/testData/diagnostics/tests/Abstract.fir.kt

@@ -3,44 +3,44 @@ package MyPackage
     //properties
     <!MUST_BE_INITIALIZED!>val a: Int<!>
     val a1: Int = 1
-    abstract val a2: Int
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val a2: Int
-    abstract val a3: Int = 1
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val a3: Int = 1
 
     <!MUST_BE_INITIALIZED!>var b: Int<!>                private set
     var b1: Int = 0;                         private set
-    abstract var b2: Int      private set
+    <!WRONG_MODIFIER_TARGET!>abstract<!> var b2: Int      private set
-    abstract var b3: Int = 0; private set
+    <!WRONG_MODIFIER_TARGET!>abstract<!> var b3: Int = 0; private set
 
     <!MUST_BE_INITIALIZED!>var c: Int<!>                set(v: Int) { field = v }
     var c1: Int = 0;                         set(v: Int) { field = v }
-    abstract var c2: Int      set(v: Int) { field = v }
+    <!WRONG_MODIFIER_TARGET!>abstract<!> var c2: Int      set(v: Int) { field = v }
-    abstract var c3: Int = 0; set(v: Int) { field = v }
+    <!WRONG_MODIFIER_TARGET!>abstract<!> var c3: Int = 0; set(v: Int) { field = v }
 
     val e: Int                               get() = a
     val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
-    abstract val e2: Int      get() = a
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val e2: Int      get() = a
-    abstract val e3: Int = 0; get() = a
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val e3: Int = 0; get() = a
 
     //methods
     <!NON_MEMBER_FUNCTION_NO_BODY!>fun f()<!>
     fun g() {}
-    abstract fun h()
+    <!WRONG_MODIFIER_TARGET!>abstract<!> fun h()
-    abstract fun j() {}
+    <!WRONG_MODIFIER_TARGET!>abstract<!> fun j() {}
 
     //property accessors
-    var i: Int                       abstract get  abstract set
+    var i: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var j: Int                       get() = i;    abstract set
+    var j: Int                       get() = i;    <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    abstract set
+    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    <!MUST_BE_INITIALIZED!>var k: Int<!>        abstract set
+    <!MUST_BE_INITIALIZED!>var k: Int<!>        <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var k1: Int = 0;                 abstract set
+    var k1: Int = 0;                 <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var l: Int                       abstract get  abstract set
+    var l: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var n: Int                       abstract get abstract set(v: Int) {}
+    var n: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
 
 // FILE: c.kt
 //creating an instance

compiler/testData/diagnostics/tests/AbstractInAbstractClass.fir.kt

@@ -1,45 +0,0 @@
-package abstract
-
-abstract class MyAbstractClass() {
-    //properties
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a: Int<!>
-    val a1: Int = 1
-    abstract val a2: Int
-    abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var b: Int<!>                private set
-    var b1: Int = 0;                         private set
-    abstract var b2: Int      <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
-    abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
-
-    <!MUST_BE_INITIALIZED!>var c: Int<!>                set(v: Int) { field = v }
-    var c1: Int = 0;                         set(v: Int) { field = v }
-    abstract var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
-    abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
-
-    val e: Int                               get() = a
-    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
-    abstract val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
-    abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
-
-    //methods
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun f()<!>
-    fun g() {}
-    abstract fun h()
-    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
-
-    //property accessors
-    var i: Int                       abstract get  abstract set
-    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
-
-    var j: Int                       get() = i;    abstract set
-    var j1: Int                      get() = i;    abstract set
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!>        abstract set
-    var k1: Int = 0;                 abstract set
-
-    var l: Int                       abstract get  abstract set
-    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
-
-    var n: Int                       abstract get abstract set(v: Int) {}
-}

compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package abstract
 
 abstract class MyAbstractClass() {

compiler/testData/diagnostics/tests/AbstractInClass.fir.kt

@@ -1,45 +0,0 @@
-package abstract
-
-class MyClass() {
-    //properties
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a: Int<!>
-    val a1: Int = 1
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a2: Int
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a3: Int = 1
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var b: Int<!>                private set
-    var b1: Int = 0;                         private set
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b2: Int      private set
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b3: Int = 0; private set
-
-    <!MUST_BE_INITIALIZED!>var c: Int<!>                set(v: Int) { field = v }
-    var c1: Int = 0;                         set(v: Int) { field = v }
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c2: Int      set(v: Int) { field = v }
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { field = v }
-
-    val e: Int                               get() = a
-    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e2: Int      get() = a
-    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e3: Int = 0; get() = a
-
-    //methods
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun f()<!>
-    fun g() {}
-    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun h()
-    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
-
-    //property accessors
-    var i: Int                       abstract get  abstract set
-    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
-
-    var j: Int                       get() = i;    abstract set
-    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    abstract set
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!>        abstract set
-    var k1: Int = 0;                 abstract set
-
-    var l: Int                       abstract get  abstract set
-    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
-
-    var n: Int                       abstract get abstract set(v: Int) {}
-}

compiler/testData/diagnostics/tests/AbstractInClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package abstract
 
 class MyClass() {

compiler/testData/diagnostics/tests/AbstractInTrait.fir.kt

@@ -1,45 +0,0 @@
-package abstract
-
-interface MyTrait {
-    //properties
-    val a: Int
-    val a1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>1<!>
-    abstract val a2: Int
-    abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
-
-    var b: Int                                                                                              <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
-    var b1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;                                                <!PRIVATE_SETTER_FOR_OPEN_PROPERTY!>private<!> set
-    abstract var b2: Int                                               <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
-    abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
-
-    <!BACKING_FIELD_IN_INTERFACE!>var c: Int<!>                                   set(v: Int) { field = v }
-    <!BACKING_FIELD_IN_INTERFACE!>var c1: Int<!> = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;              set(v: Int) { field = v }
-    abstract var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
-    abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
-
-    val e: Int                                                  get() = a
-    val e1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;                             get() = a
-    abstract val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
-    abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
-
-    //methods
-    fun f()
-    fun g() {}
-    abstract fun h()
-    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
-
-    //property accessors
-    var i: Int                       abstract get  abstract set
-    var i1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;  abstract get  abstract set
-
-    var j: Int                       get() = i;    abstract set
-    var j1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;  get() = i;    abstract set
-
-    var k: Int                       abstract set
-    var k1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;  abstract set
-
-    var l: Int                       abstract get  abstract set
-    var l1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>;  abstract get  abstract set
-
-    var n: Int                       abstract get abstract set(v: Int) {}
-}

compiler/testData/diagnostics/tests/AbstractInTrait.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package abstract
 
 interface MyTrait {

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

@@ -1,15 +0,0 @@
-annotation class B
-
-class A {
-   annotation companion object {}
-}
-
-annotation object O {}
-
-annotation interface T {}
-
-annotation fun f() = 0
-
-annotation val x = 0
-
-annotation var y = 0

compiler/testData/diagnostics/tests/annotations/annotationModifier.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 annotation class B
 
 class A {

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

@@ -4,7 +4,7 @@
 annotation class Ann
 
 fun foo() {
-    for (@Ann private x in 1..100) {
+    for (@Ann <!WRONG_MODIFIER_TARGET!>private<!> x in 1..100) {
         if (x == 1) return
     }
-}
+}

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

@@ -1,7 +0,0 @@
-@Target(AnnotationTarget.CLASS)
-annotation class My
-data class Pair(val a: Int, val b: Int)
-fun foo(): Int {
-    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/multiDeclaration.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 @Target(AnnotationTarget.CLASS)
 annotation class My
 data class Pair(val a: Int, val b: Int)

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

@@ -1,8 +0,0 @@
-// KT-9145
-
-@Target(AnnotationTarget.CLASS)
-annotation class Ann
-
-var x: Int
-    get() = 1
-    set(<!WRONG_ANNOTATION_TARGET!>@Ann<!> private x) { }

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-9145
 
 @Target(AnnotationTarget.CLASS)

compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.fir.kt

@@ -1,9 +0,0 @@
-// See EA-73584
-data class<!SYNTAX!><!> {
-
-}
-
-// See KT-9296
-data interface<!SYNTAX!><!> {
-
-}

compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // See EA-73584
 data class<!SYNTAX!><!> {
 

compiler/testData/diagnostics/tests/dataClasses/dataObject.fir.kt

@@ -1 +0,0 @@
-data object Object<!CONSTRUCTOR_IN_OBJECT!>(val x: Int, val y: Int)<!>

compiler/testData/diagnostics/tests/dataClasses/dataObject.kt

@@ -1 +1,2 @@
+// FIR_IDENTICAL
 <!WRONG_MODIFIER_TARGET!>data<!> object Object<!CONSTRUCTOR_IN_OBJECT!>(val x: Int, val y: Int)<!>

compiler/testData/diagnostics/tests/dataClasses/strange.fir.kt

@@ -1,10 +1,10 @@
-data enum class First(val x: Int) {
+<!WRONG_MODIFIER_TARGET!>data<!> enum class First(val x: Int) {
     A(1),
     B(2)
 }
 
-data object Second
+<!WRONG_MODIFIER_TARGET!>data<!> object Second
 
-data interface Third
+<!WRONG_MODIFIER_TARGET!>data<!> interface Third
 
-data annotation class Fourth(val x: Int)
+<!WRONG_MODIFIER_TARGET!>data<!> annotation class Fourth(val x: Int)

compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt

@@ -93,7 +93,7 @@ class Foo {
 
 private val packagePrivateProperty = object : MyClass(), MyTrait {}
 
-protected val packageProtectedProperty = object : MyClass(), MyTrait {}
+<!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty = object : MyClass(), MyTrait {}
 
 val packageInternalProperty = object : MyClass(), MyTrait {}
 
@@ -101,7 +101,7 @@ internal val packageInternal2Property = object : MyClass(), MyTrait {}
 
 public val packagePublicProperty = object : MyClass(), MyTrait {}
 
-protected fun packageProtectedFunction() = object : MyClass(), MyTrait {}
+<!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction() = object : MyClass(), MyTrait {}
 
 fun packageInternalFunction() = object : MyClass(), MyTrait {}
 

compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt

@@ -1,19 +0,0 @@
-// !DIAGNOSTICS: -MANY_COMPANION_OBJECTS -REDECLARATION -DUPLICATE_CLASS_NAMES
-
-// KT-3464 Front-end shouldn't allow override modifier in class declaration
-
-override class A {
-    override companion object {}
-    open companion object {}
-    abstract companion object {}
-    final companion object {}
-}
-
-override object B1 {}
-open object B2 {}
-abstract object B3 {}
-final object B4 {}
-
-override enum class C {}
-override interface D {}
-override annotation class E

compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -MANY_COMPANION_OBJECTS -REDECLARATION -DUPLICATE_CLASS_NAMES
 
 // KT-3464 Front-end shouldn't allow override modifier in class declaration

compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.fir.kt

@@ -5,8 +5,8 @@ class T {
 }
 
 fun foo() {
-    public val i = 11
+    <!WRONG_MODIFIER_TARGET!>public<!> val i = 11
-    abstract val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
-    override fun T.baz() = 2
+    <!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
-    private fun bar() = 2
+    <!WRONG_MODIFIER_TARGET!>private<!> fun bar() = 2
 }

compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.fir.kt

@@ -4,10 +4,10 @@ class T {
     fun baz() = 1
 }
 
-override fun zzz() {}
+<!WRONG_MODIFIER_TARGET!>override<!> fun zzz() {}
 
 fun foo(t: T) {
-    override fun T.baz() = 2
+    <!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
 
     // was "Visibility is unknown yet exception"
     t.baz()

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt

@@ -7,7 +7,7 @@ fun test() {
     val <T> a0 = 0
     val <T : __UNRESOLVED__> a1 = ""
     val <T : String> a2 = 0
-    const val <T> a3 = 0
+    <!WRONG_MODIFIER_TARGET!>const<!> val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
     val <T> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt

@@ -7,7 +7,7 @@ fun test() {
     val <T> a0 = 0
     val <T : __UNRESOLVED__> a1 = ""
     val <T : String> a2 = 0
-    const val <T> a3 = 0
+    <!WRONG_MODIFIER_TARGET!>const<!> val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
     val <T> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>

compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.fir.kt

@@ -1,12 +0,0 @@
-package d
-
-abstract val a : Int = 1
-
-override val c : Int = 1
-
-final fun foo() = 2
-
-abstract fun baz() = 2
-
-class T {}
-override fun T.bar() = 2

compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package d
 
 <!WRONG_MODIFIER_TARGET!>abstract<!> val a : Int = 1

compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.fir.kt

@@ -1,10 +1,10 @@
 package d
 
-override val f : ()-> Int = { 12 }
+<!WRONG_MODIFIER_TARGET!>override<!> val f : ()-> Int = { 12 }
 
 fun test() {
     f()
 }
 
 var g: Int = 1
-    protected set(i: Int) {}
+    protected set(i: Int) {}

compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.fir.kt

@@ -1,18 +0,0 @@
-interface A {
-    sealed fun foo()
-    sealed var bar: Unit
-}
-
-interface B {
-    abstract fun foo()
-    abstract var bar: Unit
-}
-
-interface C : A, B
-
-abstract class D(sealed var x: Int) {
-    abstract var y: Unit
-        sealed set
-}
-
-abstract class E : D(42)

compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface A {
     <!WRONG_MODIFIER_TARGET!>sealed<!> fun foo()
     <!WRONG_MODIFIER_TARGET!>sealed<!> var bar: Unit

compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.fir.kt

@@ -1,175 +0,0 @@
-open class MyClass {
-    fun f1() {}
-}
-
-
-class Foo {
-
-    protected val protectedProperty = object : MyClass() {}
-
-    public val publicProperty = object : MyClass() {}
-
-    protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
-
-    public val public2Property : MyClass = object : MyClass() {fun invisible() {}}
-
-    private val privateProperty = object : MyClass() {fun visible() {}}
-
-    internal val internalProperty = object : MyClass() { fun invisible() {}}
-
-
-    fun testProperties() {
-        privateProperty.f1()
-        internalProperty.f1()
-        protected2Property.f1()
-        public2Property.f1()
-
-        privateProperty.visible()
-        protected2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
-        public2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
-        internalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
-    }
-
-
-    protected fun protectedFunction() = object : MyClass() {}
-
-    public fun publicFunction() = object : MyClass() {}
-
-    protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
-
-    public fun public2Function(): MyClass = object : MyClass() {fun visible() {}}
-
-    private fun privateFunction() = object : MyClass() {fun visible() {}}
-
-    internal fun internalFunction() = object : MyClass() {fun invisible() {}}
-
-
-    fun testFunctions() {
-        privateFunction().f1()
-        internalFunction().f1()
-        public2Function().f1()
-        protected2Function().f1()
-
-        privateFunction().visible()
-        internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
-        public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
-        protected2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
-    }
-
-
-    class FooInner {
-
-        public val publicProperty = object : MyClass() {}
-
-        protected val protectedProperty = object : MyClass() {}
-
-        protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
-
-        public val public2Property : MyClass = object : MyClass() {fun invisible() {}}
-
-        private val privateProperty = object : MyClass() {fun visible() {}}
-
-        internal val internalProperty = object : MyClass() { fun invisible() {}}
-
-
-        fun testProperties() {
-            privateProperty.f1()
-            internalProperty.f1()
-            protected2Property.f1()
-            public2Property.f1()
-
-            privateProperty.visible()
-            protected2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
-            public2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
-            internalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
-        }
-
-
-        protected fun protectedFunction() = object : MyClass() {}
-
-        public fun publicFunction() = object : MyClass() {}
-
-        protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
-
-        public fun public2Function(): MyClass = object : MyClass() {fun visible() {}}
-
-        private fun privateFunction() = object : MyClass() {fun visible() {}}
-
-        internal fun internalFunction() = object : MyClass() {fun invisible() {}}
-
-
-        fun testFunctions() {
-            privateFunction().f1()
-            internalFunction().f1()
-            public2Function().f1()
-            protected2Function().f1()
-
-            privateFunction().visible()
-            internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
-            public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
-            protected2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
-        }
-    }
-
-    fun foo() {
-        val localVar = object : MyClass() {}
-        localVar.f1()
-        fun foo2() = object : MyClass() {}
-        foo2().f1()
-    }
-
-}
-
-protected val packageProtectedProperty = object : MyClass() {}
-
-public val packagePublicProperty = object : MyClass() {}
-
-public val packagePublic2Property : MyClass = object : MyClass() {fun invisible() {}}
-
-private val packagePrivateProperty = object : MyClass() {fun invisible() {}}
-
-internal val packageInternalProperty = object : MyClass() {fun invisible() {}}
-
-
-fun testProperties() {
-    packagePrivateProperty.f1()
-    packageInternalProperty.f1()
-    packagePublic2Property.f1()
-
-    packagePrivateProperty.invisible()
-    packageInternalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
-    packagePublic2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
-}
-
-
-private fun privateFunction() = object : MyClass() {fun invisible() {}}
-
-protected fun protectedFunction() = object : MyClass() {}
-
-public fun publicFunction() = object : MyClass() {}
-
-public fun public2Function() : MyClass = object : MyClass() {fun invisible() {}}
-
-internal fun internalFunction() = object : MyClass() {fun invisible() {}}
-
-
-
-fun testFunctions() {
-    privateFunction().f1()
-    internalFunction().f1()
-    public2Function().f1()
-
-    privateFunction().invisible()
-    internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
-    public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
-}
-
-fun fooPackage() {
-    val packageLocalVar = object : MyClass() {fun visible() {}}
-    packageLocalVar.f1()
-    packageLocalVar.visible()
-
-    fun fooPackageLocal() = object : MyClass() {fun visible() {}}
-    fooPackageLocal().f1()
-    fooPackageLocal().visible()
-}

compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 open class MyClass {
     fun f1() {}
 }

compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.fir.kt

@@ -8,7 +8,7 @@ interface T {}
 
 class Br(t : T) : T by t {}
 
-open enum class EN() {
+<!WRONG_MODIFIER_TARGET!>open<!> enum class EN() {
   A
 }
 

compiler/testData/diagnostics/tests/enum/AbstractEnum.fir.kt

@@ -1,3 +0,0 @@
-package abstract
-
-abstract enum class MyAbstractEnum() {}

compiler/testData/diagnostics/tests/enum/AbstractEnum.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package abstract
 
 <!WRONG_MODIFIER_TARGET!>abstract<!> enum class MyAbstractEnum() {}

compiler/testData/diagnostics/tests/enum/AbstractInEnum.fir.kt

@@ -31,17 +31,17 @@ enum class MyEnum() {
     <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
 
     //property accessors
-    var i: Int                       abstract get  abstract set
+    var i: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  abstract get  abstract set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var j: Int                       get() = i;    abstract set
+    var j: Int                       get() = i;    <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    abstract set
+    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!>        abstract set
+    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!>        <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var k1: Int = 0;                 abstract set
+    var k1: Int = 0;                 <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var l: Int                       abstract get  abstract set
+    var l: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
-    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;   abstract get  abstract set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;   <!WRONG_MODIFIER_TARGET!>abstract<!> get  <!WRONG_MODIFIER_TARGET!>abstract<!> set
 
-    var n: Int                       abstract get abstract set(v: Int) {}
+    var n: Int                       <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
 }

compiler/testData/diagnostics/tests/enum/enumModifier.fir.kt

@@ -1,15 +0,0 @@
-enum class B {}
-
-class A {
-   enum companion object {}
-}
-
-enum object O {}
-
-enum interface T {}
-
-enum fun f() = 0
-
-enum val x = 0
-
-enum var y = 0

compiler/testData/diagnostics/tests/enum/enumModifier.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 enum class B {}
 
 class A {

compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.fir.kt

@@ -1,3 +0,0 @@
-annotation enum class E {
-    D
-}

compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 <!WRONG_MODIFIER_TARGET!>annotation<!> enum class E {
     D
 }

compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.fir.kt

@@ -2,7 +2,7 @@
 public enum MyJavaEnum {}
 
 // FILE: test.kt
-open enum class MyEnum() {
+<!WRONG_MODIFIER_TARGET!>open<!> enum class MyEnum() {
     A()
 }
 

compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_after.fir.kt

@@ -2,7 +2,7 @@
 
 enum class E {
     ABC {
-        enum class F {
+        <!WRONG_MODIFIER_TARGET!>enum<!> class F {
             DEF
         }
     }

compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_before.fir.kt

@@ -2,7 +2,7 @@
 
 enum class E {
     ABC {
-        enum class F {
+        <!WRONG_MODIFIER_TARGET!>enum<!> class F {
             DEF
         }
     }

compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.fir.kt

@@ -1,8 +1,8 @@
-enum interface Some {
+<!WRONG_MODIFIER_TARGET!>enum<!> interface Some {
     // Enum part
     D;
 
     // Interface like part
     fun test()
     val foo: Int
-}
+}

compiler/testData/diagnostics/tests/enum/localEnums.fir.kt

@@ -1,20 +1,20 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 fun foo() {
-    enum class A {
+    <!WRONG_MODIFIER_TARGET!>enum<!> class A {
         FOO,
         BAR
     }
     val foo = A.FOO
     val b = object {
-        enum class B {}
+        <!WRONG_MODIFIER_TARGET!>enum<!> class B {}
     }
     class C {
-        enum class D {}
+        <!WRONG_MODIFIER_TARGET!>enum<!> class D {}
     }
     val f = {
-        enum class E {}
+        <!WRONG_MODIFIER_TARGET!>enum<!> class E {}
     }
 
-    enum class<!SYNTAX!><!> {}
+    <!WRONG_MODIFIER_TARGET!>enum<!> class<!SYNTAX!><!> {}
 }

compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.fir.kt

@@ -1,23 +0,0 @@
-enum class E {
-    public final SUBCLASS {
-        fun foo() {}
-    },
-
-    public PUBLIC,
-    protected PROTECTED,
-    private PRIVATE,
-    internal INTERNAL,
-
-    abstract ABSTRACT,
-    open OPEN,
-    override OVERRIDE,
-    final FINAL,
-
-    inner INNER,
-    annotation ANNOTATION,
-    enum ENUM,
-    out OUT,
-    in IN,
-    vararg VARARG,
-    reified REIFIED
-}

compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 enum class E {
     <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>final<!> SUBCLASS {
         fun foo() {}

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

@@ -1,15 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-data class A(val x: Int, val y: String)
-
-fun foo(block: (A) -> Unit) { }
-
-@Target(AnnotationTarget.VALUE_PARAMETER)
-annotation class Ann
-
-fun bar() {
-    foo { (private inline a, <!WRONG_ANNOTATION_TARGET!>@Ann<!> b) ->
-        a checkType { _<Int>() }
-        b checkType { _<String>() }
-    }
-}

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 data class A(val x: Int, val y: String)

compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.fir.kt

@@ -1,59 +0,0 @@
-abstract class Test() {
-    abstract val x : Int
-    abstract val x1 : Int get
-    abstract val x2 : Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a : Int<!>
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val b : Int<!> get
-    val c = 1
-
-    val c1 = 1
-      get
-    val c2 : Int
-        get() = 1
-    val c3 : Int
-        get() { return 1 }
-    val c4 : Int
-        get() = 1
-    <!MUST_BE_INITIALIZED!>val c5 : Int<!>
-        get() = field + 1
-
-    abstract var y : Int
-    abstract var y1 : Int get
-    abstract var y2 : Int set
-    abstract var y3 : Int set get
-    abstract var y4 : Int set <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
-    abstract var y5 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!> <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
-    abstract var y6 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!>
-
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v : Int<!>
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v1 : Int<!> get
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v2 : Int<!> get set
-    <!MUST_BE_INITIALIZED!>var v3 : Int<!> get() = 1; set
-    var v4 : Int get() = 1; set(x){}
-
-    <!MUST_BE_INITIALIZED!>var v5 : Int<!> get() = 1; set(x){field = x}
-    <!MUST_BE_INITIALIZED!>var v6 : Int<!> get() = field + 1; set(x){}
-
-  abstract val v7 : Int get
-  abstract var v8 : Int get set
-  <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v9 : Int<!> set
-  <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v10 : Int<!>  get
-  abstract val v11 : Int abstract get
-  abstract var v12 : Int abstract get abstract set
-
-}
-
-open class Super(i : Int)
-
-class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
-
-  val xx = w
-
-  init {
-    w + 1
-  }
-
-  fun foo() = <!UNRESOLVED_REFERENCE!>x<!>
-
-}

compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 abstract class Test() {
     abstract val x : Int
     abstract val x1 : Int get

compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.fir.kt

@@ -1,8 +0,0 @@
-// !LANGUAGE: +InlineClasses, -JvmInlineValueClasses
-
-inline class Foo(val x: Int)
-
-inline interface InlineInterface
-inline annotation class InlineAnn
-inline object InlineObject
-inline enum class InlineEnum

compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +InlineClasses, -JvmInlineValueClasses
 
 inline class Foo(val x: Int)

compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt

@@ -3,8 +3,8 @@
 
 inline class Foo(val x: Int)
 
-inline annotation class InlineAnn
+<!WRONG_MODIFIER_TARGET!>inline<!> annotation class InlineAnn
-inline object InlineObject
+<!WRONG_MODIFIER_TARGET!>inline<!> object InlineObject
-inline enum class InlineEnum
+<!WRONG_MODIFIER_TARGET!>inline<!> enum class InlineEnum
 
 inline class NotVal(<!INLINE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER!>x: Int<!>)

compiler/testData/diagnostics/tests/inlineClasses/inlineClassDeclarationCheck.fir.kt

@@ -29,7 +29,7 @@ object B2 {
 }
 
 fun foo() {
-    <!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> class C4(val x: Int)
+    <!INLINE_CLASS_NOT_TOP_LEVEL, WRONG_MODIFIER_TARGET!>inline<!> class C4(val x: Int)
 }
 
 final inline class D0(val x: Int)

compiler/testData/diagnostics/tests/inlineClasses/innerClassInsideInlineClass.fir.kt

@@ -3,6 +3,6 @@
 
 inline class Foo(val x: Int) {
     <!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> class InnerC
-    <!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> object InnerO
+    <!INNER_CLASS_INSIDE_INLINE_CLASS, WRONG_MODIFIER_TARGET!>inner<!> object InnerO
-    <!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> interface InnerI
+    <!INNER_CLASS_INSIDE_INLINE_CLASS, WRONG_MODIFIER_TARGET!>inner<!> interface InnerI
 }

compiler/testData/diagnostics/tests/inner/illegalModifier.fir.kt

@@ -1,45 +0,0 @@
-// !LANGUAGE: -InnerClassInEnumEntryClass
-inner fun foo() {}
-inner val prop = 42
-
-inner class A
-inner interface B
-inner object C
-
-class D {
-    inner class E
-    inner interface F
-    inner object G
-    inner enum class R
-    inner annotation class S
-    inner companion object
-}
-
-enum class H {
-    I0 {
-        inner class II0
-    },
-    inner I {
-        inner class II
-    };
-    
-    inner class J
-}
-
-interface K {
-    inner class L
-}
-
-object N {
-    inner class O
-}
-
-class P {
-    companion object {
-        inner class Q
-    }
-}
-
-val R = object {
-    inner class S
-}

compiler/testData/diagnostics/tests/inner/illegalModifier.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: -InnerClassInEnumEntryClass
 <!WRONG_MODIFIER_TARGET!>inner<!> fun foo() {}
 <!WRONG_MODIFIER_TARGET!>inner<!> val prop = 42

compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.fir.kt

@@ -1,45 +0,0 @@
-// !LANGUAGE: +InnerClassInEnumEntryClass
-inner fun foo() {}
-inner val prop = 42
-
-inner class A
-inner interface B
-inner object C
-
-class D {
-    inner class E
-    inner interface F
-    inner object G
-    inner enum class R
-    inner annotation class S
-    inner companion object
-}
-
-enum class H {
-    I0 {
-        inner class II0
-    },
-    inner I {
-        inner class II
-    };
-    
-    inner class J
-}
-
-interface K {
-    inner class L
-}
-
-object N {
-    inner class O
-}
-
-class P {
-    companion object {
-        inner class Q
-    }
-}
-
-val R = object {
-    inner class S
-}

compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +InnerClassInEnumEntryClass
 <!WRONG_MODIFIER_TARGET!>inner<!> fun foo() {}
 <!WRONG_MODIFIER_TARGET!>inner<!> val prop = 42

compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv11.fir.kt

@@ -10,7 +10,7 @@ enum class Enum {
 
         <!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
 
-        enum class TestEnumClass {
+        <!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
             OTHER_ENTRY
         }
 

compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv12.fir.kt

@@ -10,7 +10,7 @@ enum class Enum {
 
         <!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
 
-        enum class TestEnumClass {
+        <!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
             OTHER_ENTRY
         }
 

compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv13.fir.kt

@@ -10,7 +10,7 @@ enum class Enum {
 
         <!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
 
-        enum class TestEnumClass {
+        <!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
             OTHER_ENTRY
         }
 

compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt

@@ -8,17 +8,17 @@ abstract class A() {
 
     <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>open var r: String<!>
         get
-        abstract protected set
+        <!WRONG_MODIFIER_TARGET!>abstract<!> protected set
 }
 
-final interface T {}
+<!WRONG_MODIFIER_TARGET!>final<!> interface T {}
 
 class FinalClass() {
     <!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
     val i: Int = 1
-        open get(): Int = field
+        <!WRONG_MODIFIER_TARGET!>open<!> get(): Int = field
     var j: Int = 1
-        open set(v: Int) {}
+        <!WRONG_MODIFIER_TARGET!>open<!> set(v: Int) {}
 }
 
 <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>public<!> class C
@@ -32,107 +32,107 @@ class LegalModifier(val a: Int, @annotated private var b: String, @annotated var
 
 //Check illegal modifier in constructor parameters
 class IllegalModifiers1(
-    <!INCOMPATIBLE_MODIFIERS!>in<!>
+    <!WRONG_MODIFIER_TARGET!>in<!>
     <!INCOMPATIBLE_MODIFIERS!>out<!>
-    reified
+    <!WRONG_MODIFIER_TARGET!>reified<!>
-    enum
+    <!WRONG_MODIFIER_TARGET!>enum<!>
-    private
+    <!WRONG_MODIFIER_TARGET!>private<!>
-    const
+    <!WRONG_MODIFIER_TARGET!>const<!>
     a: Int)
 
 //Check multiple illegal modifiers in constructor
-class IllegalModifiers2(<!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> a: Int)
+class IllegalModifiers2(<!WRONG_MODIFIER_TARGET!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> a: Int)
 
 
 //Check annotations with illegal modifiers in constructor
-class IllegalModifiers3(@annotated public abstract b: String)
+class IllegalModifiers3(@annotated <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> b: String)
 
 //Check annotations and vararg with illegal modifiers in constructor
-class IllegalModifiers4(val a: Int, @annotated("a text") protected vararg v: Int)
+class IllegalModifiers4(val a: Int, @annotated("a text") <!WRONG_MODIFIER_TARGET!>protected<!> vararg v: Int)
 
 //Check illegal modifiers for functions and catch block
 abstract class IllegalModifiers5() {
 
     //Check illegal modifier in function parameter
-    abstract fun foo(public a: Int, vararg v: String)
+    abstract fun foo(<!WRONG_MODIFIER_TARGET!>public<!> a: Int, vararg v: String)
 
     //Check multiple illegal modifiers in function parameter
-    abstract fun bar(public abstract a: Int, vararg v: String)
+    abstract fun bar(<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int, vararg v: String)
 
     //Check annotations with illegal modifiers
-    abstract fun baz(@annotated("a text") public abstract a: Int)
+    abstract fun baz(@annotated("a text") <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int)
 
     private fun qux() {
 
         //Check illegal modifier in catch block
-        try {} catch (<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> reified enum public e: Exception) {}
+        try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
 
         //Check multiple illegal modifiers in catch block
-        try {} catch (<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> reified enum abstract public e: Exception) {}
+        try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
 
         //Check annotations with illegal modifiers
-        try {} catch (@annotated("a text") abstract public e: Exception) {}
+        try {} catch (@annotated("a text") <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
     }
 }
 
 //Check illegal modifiers on anonymous initializers
 abstract class IllegalModifiers6() {
-    public init {}
+    <!WRONG_MODIFIER_TARGET!>public<!> init {}
-    private init {}
+    <!WRONG_MODIFIER_TARGET!>private<!> init {}
-    protected init {}
+    <!WRONG_MODIFIER_TARGET!>protected<!> init {}
-    vararg init {}
+    <!WRONG_MODIFIER_TARGET!>vararg<!> init {}
-    abstract init {}
+    <!WRONG_MODIFIER_TARGET!>abstract<!> init {}
-    open init {}
+    <!WRONG_MODIFIER_TARGET!>open<!> init {}
-    final init {}
+    <!WRONG_MODIFIER_TARGET!>final<!> init {}
 
-    public @annotated init {}
+    <!WRONG_MODIFIER_TARGET!>public<!> @annotated init {}
 
-    private @IllegalModifiers6() init {}
+    <!WRONG_MODIFIER_TARGET!>private<!> @IllegalModifiers6() init {}
 }
 
 // strange inappropriate modifiers usages
-override
+<!WRONG_MODIFIER_TARGET!>override<!>
-<!INCOMPATIBLE_MODIFIERS!>out<!>
+<!WRONG_MODIFIER_TARGET!>out<!>
 <!INCOMPATIBLE_MODIFIERS!>in<!>
-vararg
+<!WRONG_MODIFIER_TARGET!>vararg<!>
-reified
+<!WRONG_MODIFIER_TARGET!>reified<!>
 class IllegalModifiers7() {
-    enum
+    <!WRONG_MODIFIER_TARGET!>enum<!>
-    inner
+    <!WRONG_MODIFIER_TARGET!>inner<!>
-    annotation
+    <!WRONG_MODIFIER_TARGET!>annotation<!>
-    <!INCOMPATIBLE_MODIFIERS!>out<!>
+    <!WRONG_MODIFIER_TARGET!>out<!>
     <!INCOMPATIBLE_MODIFIERS!>in<!>
-    vararg
+    <!WRONG_MODIFIER_TARGET!>vararg<!>
-    reified
+    <!WRONG_MODIFIER_TARGET!>reified<!>
     val x = 1
-    enum
+    <!WRONG_MODIFIER_TARGET!>enum<!>
-    inner
+    <!WRONG_MODIFIER_TARGET!>inner<!>
-    annotation
+    <!WRONG_MODIFIER_TARGET!>annotation<!>
-    <!INCOMPATIBLE_MODIFIERS!>out<!>
+    <!WRONG_MODIFIER_TARGET!>out<!>
     <!INCOMPATIBLE_MODIFIERS!>in<!>
-    vararg
+    <!WRONG_MODIFIER_TARGET!>vararg<!>
-    reified
+    <!WRONG_MODIFIER_TARGET!>reified<!>
-    const
+    <!WRONG_MODIFIER_TARGET!>const<!>
     fun foo() {}
 }
 
 // Secondary constructors
 class IllegalModifiers8 {
-    <!INCOMPATIBLE_MODIFIERS!>abstract<!>
+    <!WRONG_MODIFIER_TARGET!>abstract<!>
     enum
-    <!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
+    <!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>open<!>
-    inner
+    <!WRONG_MODIFIER_TARGET!>inner<!>
-    annotation
+    <!WRONG_MODIFIER_TARGET!>annotation<!>
-    <!INCOMPATIBLE_MODIFIERS!>override<!>
+    <!WRONG_MODIFIER_TARGET!>override<!>
-    <!INCOMPATIBLE_MODIFIERS!>out<!>
+    <!WRONG_MODIFIER_TARGET!>out<!>
     <!INCOMPATIBLE_MODIFIERS!>in<!>
     <!INCOMPATIBLE_MODIFIERS!>final<!>
-    vararg
+    <!WRONG_MODIFIER_TARGET!>vararg<!>
-    reified
+    <!WRONG_MODIFIER_TARGET!>reified<!>
     <!INCOMPATIBLE_MODIFIERS!>const<!><!SYNTAX!><!>
     constructor() {}
 
-    constructor(<!INCOMPATIBLE_MODIFIERS!>private<!> enum <!INCOMPATIBLE_MODIFIERS!>abstract<!> x: Int) {}
+    constructor(<!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> x: Int) {}
 }
 
 class IllegalModifiers9 {
@@ -143,17 +143,17 @@ class IllegalModifiers9 {
 // Illegal modifiers on primary constructor
 
 class IllegalModifiers10
-<!INCOMPATIBLE_MODIFIERS!>abstract<!>
+<!WRONG_MODIFIER_TARGET!>abstract<!>
-enum
+<!WRONG_MODIFIER_TARGET!>enum<!>
-<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
+<!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>open<!>
-inner
+<!WRONG_MODIFIER_TARGET!>inner<!>
-annotation
+<!WRONG_MODIFIER_TARGET!>annotation<!>
-<!INCOMPATIBLE_MODIFIERS!>override<!>
+<!WRONG_MODIFIER_TARGET!>override<!>
-<!INCOMPATIBLE_MODIFIERS!>out<!>
+<!WRONG_MODIFIER_TARGET!>out<!>
 <!INCOMPATIBLE_MODIFIERS!>in<!>
 <!INCOMPATIBLE_MODIFIERS!>final<!>
-vararg
+<!WRONG_MODIFIER_TARGET!>vararg<!>
-reified
+<!WRONG_MODIFIER_TARGET!>reified<!>
 <!INCOMPATIBLE_MODIFIERS!>const<!> constructor()
 
 class IllegalModifiers11 <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>protected<!> constructor()

compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.fir.kt

@@ -1,6 +0,0 @@
-fun foo() {
-    public class A
-    private class B
-    protected class C
-    internal class D
-}

compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun foo() {
     <!WRONG_MODIFIER_TARGET!>public<!> class A
     <!WRONG_MODIFIER_TARGET!>private<!> class B

compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt

@@ -48,7 +48,7 @@ const val withExplicitDefaultGetter: Int = 1
     <!CONST_VAL_WITH_GETTER!>get<!>
 
 fun foo(): Int {
-    const val local: Int = 14
+    <!WRONG_MODIFIER_TARGET!>const<!> val local: Int = 14
     return 15
 }
 

compiler/testData/diagnostics/tests/modifiers/defaultModifier.fir.kt

@@ -1,55 +0,0 @@
-companion class A {
-    companion object {
-
-    }
-}
-
-class B {
-    companion object
-
-    val c: Int = 1
-}
-
-class C {
-    companion object A {
-
-    }
-}
-
-class D {
-    companion object A {
-        companion object {
-        }
-    }
-}
-
-companion object G {
-    companion object
-}
-
-companion interface H {
-    companion object
-}
-
-class J {
-    companion object C {
-        companion object
-    }
-}
-
-companion enum class Enum {
-    E1,
-    E2;
-
-    companion object
-}
-
-companion fun main() {
-
-}
-
-companion var prop: Int = 1
-    companion get
-    companion set
-
-class Z(companion val c: Int)

compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 <!WRONG_MODIFIER_TARGET!>companion<!> class A {
     companion object {
 

compiler/testData/diagnostics/tests/modifiers/modifierOnParameterInFunctionType.fir.kt

@@ -19,34 +19,34 @@ class A : (vararg Int)->Unit {
         get(): (vararg x: Int)->Unit = {}
 }
 
-val allProhibited: (<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>abstract<!>
+val allProhibited: (<!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>abstract<!>
-                    annotation
+                    <!WRONG_MODIFIER_TARGET!>annotation<!>
-                    companion
+                    <!WRONG_MODIFIER_TARGET!>companion<!>
                     <!INCOMPATIBLE_MODIFIERS!>const<!>
                     <!INCOMPATIBLE_MODIFIERS!>crossinline<!>
                     <!INCOMPATIBLE_MODIFIERS!>data<!>
-                    enum
+                    <!WRONG_MODIFIER_TARGET!>enum<!>
-                    external
+                    <!WRONG_MODIFIER_TARGET!>external<!>
                     <!INCOMPATIBLE_MODIFIERS!>final<!>
-                    <!INCOMPATIBLE_MODIFIERS!>in<!>
+                    <!WRONG_MODIFIER_TARGET!>in<!>
                     <!INCOMPATIBLE_MODIFIERS!>inline<!>
                     <!INCOMPATIBLE_MODIFIERS!>inner<!>
-                    <!INCOMPATIBLE_MODIFIERS!>internal<!>
+                    <!WRONG_MODIFIER_TARGET!>internal<!>
-                    lateinit
+                    <!WRONG_MODIFIER_TARGET!>lateinit<!>
                     <!INCOMPATIBLE_MODIFIERS!>noinline<!>
                     <!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
-                    operator
+                    <!WRONG_MODIFIER_TARGET!>operator<!>
                     <!INCOMPATIBLE_MODIFIERS!>out<!>
                     <!INCOMPATIBLE_MODIFIERS!>override<!>
                     <!INCOMPATIBLE_MODIFIERS!>private<!>
                     <!INCOMPATIBLE_MODIFIERS!>protected<!>
                     <!INCOMPATIBLE_MODIFIERS!>public<!>
-                    reified
+                    <!WRONG_MODIFIER_TARGET!>reified<!>
                     <!INCOMPATIBLE_MODIFIERS!>sealed<!>
-                    tailrec
+                    <!WRONG_MODIFIER_TARGET!>tailrec<!>
                     vararg
 
                     x: Int)->Unit = {}
 
 val valProhibited: (val x: Int)->Unit = {}
-val varProhibited: (var x: Int)->Unit = {}
+val varProhibited: (var x: Int)->Unit = {}

compiler/testData/diagnostics/tests/modifiers/redundantTargets.fir.kt

@@ -1,10 +0,0 @@
-open interface First
-// Now inspection
-abstract interface Second
-// Now inspection
-final enum class Third {
-    FOURTH, 
-    FIFTH
-}
-// Now inspection
-final object Sixth

compiler/testData/diagnostics/tests/modifiers/redundantTargets.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 <!REDUNDANT_MODIFIER_FOR_TARGET!>open<!> interface First
 // Now inspection
 abstract interface Second

compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.fir.kt

@@ -11,7 +11,7 @@ class Bzz(public <!REPEATED_MODIFIER!>public<!> val q: Int = 1) {
         public <!REPEATED_MODIFIER!>public<!> get() = 3
 
     val z: Int
-        <!INCOMPATIBLE_MODIFIERS!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> get() = 4
+        <!WRONG_MODIFIER_TARGET!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> get() = 4
 
     public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
         public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
@@ -31,7 +31,7 @@ public <!REPEATED_MODIFIER!>public<!> val bar: Int = 1
 public <!REPEATED_MODIFIER!>public<!> fun foo(): Int = 1
 
 fun test() {
-    public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
+    <!WRONG_MODIFIER_TARGET!>public<!> <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
         public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
 
         public val x: Int

compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt

@@ -2,29 +2,29 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-header class My
+<!DEPRECATED_MODIFIER!>header<!> class My
 
-header fun foo(): Int
+<!DEPRECATED_MODIFIER!>header<!> fun foo(): Int
 
-header val x: String
+<!DEPRECATED_MODIFIER!>header<!> val x: String
 
-header object O
+<!DEPRECATED_MODIFIER!>header<!> object O
 
-header enum class E {
+<!DEPRECATED_MODIFIER!>header<!> enum class E {
     FIRST
 }
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
 
-impl class My
+<!DEPRECATED_MODIFIER!>impl<!> class My
 
-impl fun foo() = 42
+<!DEPRECATED_MODIFIER!>impl<!> fun foo() = 42
 
-impl val x get() = "Hello"
+<!DEPRECATED_MODIFIER!>impl<!> val x get() = "Hello"
 
-impl object O
+<!DEPRECATED_MODIFIER!>impl<!> object O
 
-impl enum class E {
+<!DEPRECATED_MODIFIER!>impl<!> enum class E {
     FIRST
 }

compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.fir.kt

@@ -3,7 +3,7 @@
 // FILE: common.kt
 
 expect class H {
-    expect fun foo()
+    <!WRONG_MODIFIER_TARGET!>expect<!> fun foo()
 }
 
 // MODULE: m1-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.fir.kt

@@ -5,14 +5,14 @@
 expect class B {
     class N {
         <!EXPECTED_DECLARATION_WITH_BODY!>fun body()<!> {}
-        expect fun extraHeader()
+        <!WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
     }
 }
 
 expect class C {
-    expect class N
+    <!WRONG_MODIFIER_TARGET!>expect<!> class N
-    expect enum class E
+    <!WRONG_MODIFIER_TARGET!>expect<!> enum class E
-    expect inner class I
+    <!WRONG_MODIFIER_TARGET!>expect<!> inner class I
 }
 
 expect class D {

compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.fir.kt

@@ -3,7 +3,7 @@
 // FILE: common.kt
 
 class Foo {
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>expect fun bar(): String<!>
+    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
 }
 
 // MODULE: m1-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/incompatibles.fir.kt

@@ -1,13 +1,13 @@
 // !LANGUAGE: +MultiPlatformProjects
 
-<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class First
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class First
 
-<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second
 
-<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Third
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Third
 
-<!INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Fourth
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Fourth
 
-<!INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Fifth
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Fifth
 
-<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Sixth
+<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Sixth

compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt

@@ -2,21 +2,21 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-expect typealias Foo = String
+<!WRONG_MODIFIER_TARGET!>expect<!> typealias Foo = String
 
-class Outer expect constructor() {
+class Outer <!WRONG_MODIFIER_TARGET!>expect<!> constructor() {
-    expect class Nested
+    <!WRONG_MODIFIER_TARGET!>expect<!> class Nested
 
-    expect init {}
+    <!WRONG_MODIFIER_TARGET!>expect<!> init {}
 
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>expect fun foo()<!>
+    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET!>expect<!> fun foo()<!>
-    expect val bar: Int
+    <!WRONG_MODIFIER_TARGET!>expect<!> val bar: Int
 }
 
 fun foo() {
-    expect fun localFun()
+    <!WRONG_MODIFIER_TARGET!>expect<!> fun localFun()
-    expect var x = 42
+    <!WRONG_MODIFIER_TARGET!>expect<!> var x = 42
-    expect class Bar
+    <!WRONG_MODIFIER_TARGET!>expect<!> class Bar
 }
 
 // MODULE: m2-jvm
@@ -25,11 +25,11 @@ fun foo() {
 class Outer <!ACTUAL_WITHOUT_EXPECT!>actual constructor()<!> {
     actual class Nested
 
-    actual init {}
+    <!WRONG_MODIFIER_TARGET!>actual<!> init {}
 }
 
 fun foo() {
-    actual fun localFun() {}
+    <!WRONG_MODIFIER_TARGET!>actual<!> fun localFun() {}
-    actual var x = 42
+    <!WRONG_MODIFIER_TARGET!>actual<!> var x = 42
-    actual class Bar
+    <!WRONG_MODIFIER_TARGET!>actual<!> class Bar
 }

compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.fir.kt

@@ -14,8 +14,8 @@ expect var varWithGetSet: String
     get set
 
 expect var varWithPlatformGetSet: String
-    expect get
+    <!WRONG_MODIFIER_TARGET!>expect<!> get
-    expect set
+    <!WRONG_MODIFIER_TARGET!>expect<!> set
 
 expect val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
 expect var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
@@ -34,7 +34,7 @@ expect val delegated: String by <!EXPECTED_DELEGATED_PROPERTY!>Delegate<!>
 object Delegate { operator fun getValue(x: Any?, y: Any?): String = "" }
 
 fun test(): String {
-    expect val localVariable: String
+    <!WRONG_MODIFIER_TARGET!>expect<!> val localVariable: String
     localVariable = "no"
     return localVariable
 }

compiler/testData/diagnostics/tests/properties/abstarctPropertyInPrimaryConstructor.fir.kt

@@ -1,2 +0,0 @@
-class A(<!ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS!>abstract<!> val i: Int)
-class B(abstract i: Int)

compiler/testData/diagnostics/tests/properties/abstarctPropertyInPrimaryConstructor.kt

@@ -1,2 +1,3 @@
+// FIR_IDENTICAL
 class A(<!ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS!>abstract<!> val i: Int)
 class B(<!WRONG_MODIFIER_TARGET!>abstract<!> i: Int)

compiler/testData/diagnostics/tests/regressions/kt9384.fir.kt

@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 fun main(args: Array<String>) {
     fun f() = run {
-        private class C {
+        <!WRONG_MODIFIER_TARGET!>private<!> class C {
             private fun foo() {
                 f().<!UNRESOLVED_REFERENCE!>foo<!>();
 

compiler/testData/diagnostics/tests/scopes/visibility.fir.kt

@@ -6,8 +6,8 @@ package test_visibility
 protected class ProtectedClass
 protected interface ProtectedTrait
 
-protected val protected_val : Int = 4
+<!WRONG_MODIFIER_TARGET!>protected<!> val protected_val : Int = 4
-protected fun protected_fun() {}
+<!WRONG_MODIFIER_TARGET!>protected<!> fun protected_fun() {}
 
 private val private_val : Int = 4
 private fun private_fun() {}

compiler/testData/diagnostics/tests/sealed/LocalSealed.fir.kt

@@ -1,3 +0,0 @@
-fun foo() {
-    sealed class My
-}

compiler/testData/diagnostics/tests/sealed/LocalSealed.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun foo() {
     <!WRONG_MODIFIER_TARGET!>sealed<!> class My
 }

compiler/testData/diagnostics/tests/sealed/NeverEnum.fir.kt

@@ -1,6 +0,0 @@
-sealed enum class SealedEnum {
-    FIRST, 
-    SECOND;
-
-    class Derived: SealedEnum()
-}