[FIR] Only mark declaration name with ACTUAL_WITHOUT_EXPECT

#KT-58827 Fixed

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

@@ -1146,7 +1146,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<Map<ExpectActualCompatibility<Symbol>, Collection<Symbol>>>("compatibility")
         }
 
-        val ACTUAL_WITHOUT_EXPECT by error<KtNamedDeclaration> {
+        val ACTUAL_WITHOUT_EXPECT by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME_ONLY) {
             parameter<Symbol>("declaration")
             parameter<Map<ExpectActualCompatibility<Symbol>, Collection<Symbol>>>("compatibility")
         }

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

@@ -45,6 +45,7 @@ enum class PositioningStrategy(private val strategy: String? = null) {
     VAL_OR_VAR_NODE,
     SECONDARY_CONSTRUCTOR_DELEGATION_CALL,
     DECLARATION_NAME,
+    DECLARATION_NAME_ONLY,
     DECLARATION_SIGNATURE,
     DECLARATION_SIGNATURE_OR_DEFAULT,
     VISIBILITY_MODIFIER,

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

@@ -616,7 +616,7 @@ object FirErrors {
     val ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE by error1<PsiElement, FirVariableSymbol<*>>()
     val EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND by error0<PsiElement>()
     val NO_ACTUAL_FOR_EXPECT by error3<KtNamedDeclaration, FirBasedSymbol<*>, FirModuleData, Map<ExpectActualCompatibility<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION)
-    val ACTUAL_WITHOUT_EXPECT by error2<KtNamedDeclaration, FirBasedSymbol<*>, Map<ExpectActualCompatibility<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>()
+    val ACTUAL_WITHOUT_EXPECT by error2<KtNamedDeclaration, FirBasedSymbol<*>, Map<ExpectActualCompatibility<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>(SourceElementPositioningStrategies.DECLARATION_NAME_ONLY)
     val AMBIGUOUS_ACTUALS by error2<KtNamedDeclaration, FirBasedSymbol<*>, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION)
     val AMBIGUOUS_EXPECTS by error2<KtNamedDeclaration, FirBasedSymbol<*>, Collection<FirModuleData>>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION)
     val NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS by error2<KtNamedDeclaration, FirBasedSymbol<*>, List<Pair<FirBasedSymbol<*>, Map<Incompatible<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>>>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME)

compiler/frontend.common-psi/src/org/jetbrains/kotlin/diagnostics/LightTreePositioningStrategies.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.diagnostics
 import com.intellij.lang.LighterASTNode
 import com.intellij.openapi.util.Ref
 import com.intellij.openapi.util.TextRange
-import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import com.intellij.util.diff.FlyweightCapableTreeStructure
@@ -18,7 +17,6 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
-import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtStringTemplateExpressionElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtTokenSets
@@ -189,7 +187,7 @@ object LightTreePositioningStrategies {
         }
     }
 
-    val DECLARATION_NAME: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
+    private open class BaseDeclarationNameStrategy : LightTreePositioningStrategy() {
         override fun mark(
             node: LighterASTNode,
             startOffset: Int,
@@ -198,15 +196,7 @@ object LightTreePositioningStrategies {
         ): List<TextRange> {
             val nameIdentifier = tree.nameIdentifier(node)
             if (nameIdentifier != null) {
-                if (node.tokenType == KtNodeTypes.CLASS || node.tokenType == KtNodeTypes.OBJECT_DECLARATION) {
+                return markNameIdentifier(nameIdentifier, startOffset, endOffset, tree, node)
-                    val startElement =
-                        tree.modifierList(node)?.let { modifierList -> tree.findChildByType(modifierList, KtTokens.ENUM_KEYWORD) }
-                            ?: tree.findChildByType(node, TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.OBJECT_KEYWORD))
-                            ?: node
-
-                    return markRange(startElement, nameIdentifier, startOffset, endOffset, tree, node)
-                }
-                return markElement(nameIdentifier, startOffset, endOffset, tree, node)
             }
             if (node.tokenType == KtNodeTypes.FUN) {
                 return DECLARATION_SIGNATURE.mark(node, startOffset, endOffset, tree)
@@ -214,6 +204,36 @@ object LightTreePositioningStrategies {
             return DEFAULT.mark(node, startOffset, endOffset, tree)
         }
 
+        protected open fun markNameIdentifier(
+            nameIdentifier: LighterASTNode,
+            startOffset: Int,
+            endOffset: Int,
+            tree: FlyweightCapableTreeStructure<LighterASTNode>,
+            node: LighterASTNode,
+        ): List<TextRange> {
+            return markElement(nameIdentifier, startOffset, endOffset, tree, node)
+        }
+    }
+
+    val DECLARATION_NAME: LightTreePositioningStrategy = object : BaseDeclarationNameStrategy() {
+        override fun markNameIdentifier(
+            nameIdentifier: LighterASTNode,
+            startOffset: Int,
+            endOffset: Int,
+            tree: FlyweightCapableTreeStructure<LighterASTNode>,
+            node: LighterASTNode,
+        ): List<TextRange> {
+            if (node.tokenType == KtNodeTypes.CLASS || node.tokenType == KtNodeTypes.OBJECT_DECLARATION) {
+                val startElement =
+                    tree.modifierList(node)?.let { modifierList -> tree.findChildByType(modifierList, KtTokens.ENUM_KEYWORD) }
+                        ?: tree.findChildByType(node, TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.OBJECT_KEYWORD))
+                        ?: node
+
+                return markRange(startElement, nameIdentifier, startOffset, endOffset, tree, node)
+            }
+            return markElement(nameIdentifier, startOffset, endOffset, tree, node)
+        }
+
         override fun isValid(node: LighterASTNode, tree: FlyweightCapableTreeStructure<LighterASTNode>): Boolean {
             //in FE 1.0 this is part of DeclarationHeader abstract strategy
             if (node.tokenType != KtNodeTypes.OBJECT_DECLARATION
@@ -229,6 +249,8 @@ object LightTreePositioningStrategies {
         }
     }
 
+    val DECLARATION_NAME_ONLY: LightTreePositioningStrategy = BaseDeclarationNameStrategy()
+
     val ACTUAL_DECLARATION_NAME: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
         override fun mark(
             node: LighterASTNode,

compiler/frontend.common-psi/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt

@@ -161,6 +161,20 @@ object PositioningStrategies {
         }
     }
 
+    @JvmField
+    val DECLARATION_NAME_ONLY: PositioningStrategy<KtNamedDeclaration> = object : DeclarationHeader<KtNamedDeclaration>() {
+        override fun mark(element: KtNamedDeclaration): List<TextRange> {
+            val nameIdentifier = element.nameIdentifier
+            if (nameIdentifier != null) {
+                return markElement(nameIdentifier)
+            }
+            if (element is KtNamedFunction) {
+                return DECLARATION_SIGNATURE.mark(element)
+            }
+            return DEFAULT.mark(element)
+        }
+    }
+
     @JvmField
     val DECLARATION_SIGNATURE: PositioningStrategy<KtDeclaration> = object : DeclarationHeader<KtDeclaration>() {
         override fun mark(element: KtDeclaration): List<TextRange> {

compiler/frontend.common-psi/src/org/jetbrains/kotlin/diagnostics/SourceElementPositioningStrategies.kt

@@ -43,6 +43,11 @@ object SourceElementPositioningStrategies {
         PositioningStrategies.DECLARATION_NAME
     )
 
+    val DECLARATION_NAME_ONLY = SourceElementPositioningStrategy(
+        LightTreePositioningStrategies.DECLARATION_NAME_ONLY,
+        PositioningStrategies.DECLARATION_NAME_ONLY
+    )
+
     val DECLARATION_SIGNATURE = SourceElementPositioningStrategy(
         LightTreePositioningStrategies.DECLARATION_SIGNATURE,
         PositioningStrategies.DECLARATION_SIGNATURE

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

@@ -10,4 +10,4 @@ expect class Counter {
     operator fun dec(): Counter
 }
 
-<!ACTUAL_WITHOUT_EXPECT!>actual typealias Counter = Int<!>
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>Counter<!> = Int

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

@@ -15,10 +15,10 @@
 // FILE: jvm.kt
 actual interface My {
     actual fun openFunPositive() = Unit
-    <!ACTUAL_WITHOUT_EXPECT!>actual fun openFunNegative()<!>
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>openFunNegative<!>()
     actual fun abstractFun()
 
     actual val openValPositive: Int get() = 0
-    <!ACTUAL_WITHOUT_EXPECT!>actual val openValNegative: Int<!>
+    actual val <!ACTUAL_WITHOUT_EXPECT!>openValNegative<!>: Int
     actual val abstractVal: Int
 }

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

@@ -2,7 +2,7 @@
 // FILE: common.kt
 
 expect class Foo {
-    <!ACTUAL_WITHOUT_EXPECT!>actual fun bar()<!>
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>bar<!>()
 }
 
 // MODULE: m1-jvm()()(m1-common)

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

@@ -22,7 +22,7 @@ fun foo1(x: String) {}
 fun foo2(x: Int, y: Int) {}
 fun foo2(x: String) {}
 
-<!ACTUAL_WITHOUT_EXPECT!>actual fun foo3(): String = ""<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>foo3<!>(): String = ""
 fun foo4(x: Int): String = ""
 
 actual class NoArgConstructor {

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

@@ -16,12 +16,12 @@ expect open class Foo3
 // FILE: jvm.kt
 
 interface Foo1
-<!ACTUAL_WITHOUT_EXPECT!>actual interface Foo2<!>
+actual interface <!ACTUAL_WITHOUT_EXPECT!>Foo2<!>
 
-<!ACTUAL_WITHOUT_EXPECT!>actual var s: String = "value"<!>
+actual var <!ACTUAL_WITHOUT_EXPECT!>s<!>: String = "value"
 
 fun foo2(): Int = 0
 
-<!ACTUAL_WITHOUT_EXPECT!>actual class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!><!>
+actual class <!ACTUAL_WITHOUT_EXPECT, PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>
 
 class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>

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

@@ -42,9 +42,9 @@ actual fun interface F1 {
     actual fun run()
 }
 
-<!ACTUAL_WITHOUT_EXPECT!>actual interface F2 {
+actual interface <!ACTUAL_WITHOUT_EXPECT!>F2<!> {
     actual fun run()
-}<!>
+}
 
 actual typealias F3 = java.lang.Runnable
 
@@ -62,6 +62,6 @@ interface F6Typealias {
     fun run()
 }
 
-<!ACTUAL_WITHOUT_EXPECT!>actual typealias F6 = F6Typealias<!>
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>F6<!> = F6Typealias
 
-<!ACTUAL_WITHOUT_EXPECT!>actual typealias F7 = NotSam<!>
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>F7<!> = NotSam

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

@@ -30,9 +30,9 @@ actual open class Container {
     actual fun protectedFun1() {}           // OK: protected -> public
     actual protected fun protectedFun2() {} // OK: protected -> protected
 
-    <!ACTUAL_WITHOUT_EXPECT!>actual internal fun protectedFun3() {}<!>  // BAD: protected -> internal
+    actual internal fun <!ACTUAL_WITHOUT_EXPECT!>protectedFun3<!>() {}  // BAD: protected -> internal
-    <!ACTUAL_WITHOUT_EXPECT!>actual protected fun internalFun3() {}<!>  // BAD: internal -> protected
+    actual protected fun <!ACTUAL_WITHOUT_EXPECT!>internalFun3<!>() {}  // BAD: internal -> protected
 
-    <!ACTUAL_WITHOUT_EXPECT!>actual open fun openInternalFun() {}<!>    // BAD: internal+open -> public
+    actual open fun <!ACTUAL_WITHOUT_EXPECT!>openInternalFun<!>() {}    // BAD: internal+open -> public
-    <!ACTUAL_WITHOUT_EXPECT!>actual internal fun openPublicFun() {}<!>  // BAD: open+public -> internal
+    actual internal fun <!ACTUAL_WITHOUT_EXPECT!>openPublicFun<!>() {}  // BAD: open+public -> internal
 }

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

@@ -13,7 +13,7 @@ expect class Foo : I, C, J
 // FILE: jvm.kt
 actual class Foo : I, C(), J
 
-<!ACTUAL_WITHOUT_EXPECT!>actual class Bar<!>
+actual class <!ACTUAL_WITHOUT_EXPECT!>Bar<!>
 
 // MODULE: m3-js()()(m1-common)
 // FILE: js.kt

compiler/testData/diagnostics/tests/multiplatform/hmpp/kt-55570.fir.kt

@@ -1,5 +0,0 @@
-// MODULE: common
-// TARGET_PLATFORM: Common
-
-// MODULE: main()()(common)
-<!ACTUAL_WITHOUT_EXPECT!>actual class A<!>

compiler/testData/diagnostics/tests/multiplatform/hmpp/kt-55570.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // MODULE: common
 // TARGET_PLATFORM: Common
 

compiler/testData/diagnostics/tests/multiplatform/hmpp/kt57320.fir.kt

@@ -34,7 +34,7 @@ interface KotlinXStringDemoInterface {
 // FILE: StringDemoInterface.kt
 actual typealias StringDemoInterface = KotlinXStringDemoInterface
 
-<!ACTUAL_WITHOUT_EXPECT("actual fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.plusK() = <!EXPECT_CLASS_AS_FUNCTION!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!><!>
+actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.<!ACTUAL_WITHOUT_EXPECT("actual fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>plusK<!>() = <!EXPECT_CLASS_AS_FUNCTION!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!>
 
 // FILE: main.kt
 class StringDemo(override val value: String) : StringDemoInterface

compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt

@@ -8,19 +8,19 @@
     class Nested
     inner class Inner
 }<!>
-<!ACTUAL_WITHOUT_EXPECT!>actual class CommonClass {
+actual class <!ACTUAL_WITHOUT_EXPECT!>CommonClass<!> {
-    <!ACTUAL_WITHOUT_EXPECT!>actual fun memberFun() {}<!>
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
-    <!ACTUAL_WITHOUT_EXPECT!>actual val memberProp: Int = 42<!>
+    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
-    <!ACTUAL_WITHOUT_EXPECT!>actual class Nested<!>
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
-    <!ACTUAL_WITHOUT_EXPECT!>actual inner class Inner<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
-}<!>
+}
 
 <!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun commonFun()<!>
-<!ACTUAL_WITHOUT_EXPECT!>actual fun commonFun() {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>commonFun<!>() {}
 
 <!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val commonProperty: String<!>
-<!ACTUAL_WITHOUT_EXPECT!>actual val commonProperty: String
+actual val <!ACTUAL_WITHOUT_EXPECT!>commonProperty<!>: String
-    get() = "hello"<!>
+    get() = "hello"
 
 // MODULE: intermediate()()(common)
 // TARGET_PLATFORM: Common
@@ -31,19 +31,19 @@ expect class IntermediateClass {
     class Nested
     inner class Inner
 }
-<!ACTUAL_WITHOUT_EXPECT!>actual class IntermediateClass {
+actual class <!ACTUAL_WITHOUT_EXPECT!>IntermediateClass<!> {
-    <!ACTUAL_WITHOUT_EXPECT!>actual fun memberFun() {}<!>
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
-    <!ACTUAL_WITHOUT_EXPECT!>actual val memberProp: Int = 42<!>
+    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
-    <!ACTUAL_WITHOUT_EXPECT!>actual class Nested<!>
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
-    <!ACTUAL_WITHOUT_EXPECT!>actual inner class Inner<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
-}<!>
+}
 
 expect fun intermediateFun()
-<!ACTUAL_WITHOUT_EXPECT!>actual fun intermediateFun() {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>intermediateFun<!>() {}
 
 expect val intermediateProperty: String
-<!ACTUAL_WITHOUT_EXPECT!>actual val intermediateProperty: String
+actual val <!ACTUAL_WITHOUT_EXPECT!>intermediateProperty<!>: String
-    get() = "hello"<!>
+    get() = "hello"
 
 // MODULE: main()()(intermediate)
 
@@ -53,16 +53,16 @@ expect class PlatformClass {
     class Nested
     inner class Inner
 }
-<!ACTUAL_WITHOUT_EXPECT!>actual class PlatformClass {
+actual class <!ACTUAL_WITHOUT_EXPECT!>PlatformClass<!> {
-    <!ACTUAL_WITHOUT_EXPECT!>actual fun memberFun() {}<!>
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
-    <!ACTUAL_WITHOUT_EXPECT!>actual val memberProp: Int = 42<!>
+    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
-    <!ACTUAL_WITHOUT_EXPECT!>actual class Nested<!>
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
-    <!ACTUAL_WITHOUT_EXPECT!>actual inner class Inner<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
-}<!>
+}
 
 expect fun platformFun()
-<!ACTUAL_WITHOUT_EXPECT!>actual fun platformFun() {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>platformFun<!>() {}
 
 expect val platformProperty: String
-<!ACTUAL_WITHOUT_EXPECT!>actual val platformProperty: String
+actual val <!ACTUAL_WITHOUT_EXPECT!>platformProperty<!>: String
-    get() = "hello"<!>
+    get() = "hello"

compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModuleIncompatibilities.fir.kt

@@ -5,7 +5,7 @@ expect fun parameterCount()
 fun parameterCount(p: String) {}
 
 <!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun parameterCount2()<!>
-<!ACTUAL_WITHOUT_EXPECT!>actual fun parameterCount2(p: String) {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>parameterCount2<!>(p: String) {}
 
 expect fun callableKind(): Int
 val callableKind: Int = 1
@@ -16,9 +16,9 @@ fun typeParameterCount() {}
 <!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class EnumEntries {
     ONE, TWO;
 }<!>
-<!ACTUAL_WITHOUT_EXPECT!>actual enum class EnumEntries {
+actual enum class <!ACTUAL_WITHOUT_EXPECT!>EnumEntries<!> {
     ONE;
-}<!>
+}
 
 expect fun vararg(bar: Int)
 fun vararg(vararg bar: Int) = Unit

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

@@ -1,12 +1,12 @@
 
-<!ACTUAL_WITHOUT_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class First<!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class <!ACTUAL_WITHOUT_EXPECT!>First<!>
 
 <!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second
 
-<!ACTUAL_WITHOUT_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Third<!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Third<!>
 
-<!ACTUAL_WITHOUT_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Fourth<!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class <!ACTUAL_WITHOUT_EXPECT!>Fourth<!>
 
-<!ACTUAL_WITHOUT_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Fifth<!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Fifth<!>
 
-<!ACTUAL_WITHOUT_EXPECT!><!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Sixth<!>
+<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Sixth<!>

compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.fir.kt

@@ -23,6 +23,6 @@ actual inline class Foo1(val x: Int) {
 actual inline class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo2<!>(val x: String)
 actual <!ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS!>inline<!> class Foo3
 
-<!ACTUAL_WITHOUT_EXPECT!>actual inline class NonInlineExpect(val x: Int)<!>
+actual inline class <!ACTUAL_WITHOUT_EXPECT!>NonInlineExpect<!>(val x: Int)
 
-<!ACTUAL_WITHOUT_EXPECT!>actual class NonInlineActual actual constructor(actual val x: Int)<!>
+actual class <!ACTUAL_WITHOUT_EXPECT!>NonInlineActual<!> actual constructor(actual val x: Int)

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

@@ -6,6 +6,6 @@
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_WITHOUT_EXPECT!>actual class SomeClass {
+actual class <!ACTUAL_WITHOUT_EXPECT!>SomeClass<!> {
     actual fun foo() {}
-}<!>
+}

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

@@ -23,7 +23,7 @@ fun foo() {
 // FILE: jvm.kt
 
 class Outer <!ACTUAL_WITHOUT_EXPECT!>actual constructor()<!> {
-    <!ACTUAL_WITHOUT_EXPECT!>actual class Nested<!>
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
 
     <!WRONG_MODIFIER_TARGET!>actual<!> init {}
 }

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.fir.kt

@@ -8,10 +8,10 @@ package common
 // FILE: jvm.kt
 package jvm
 
-<!ACTUAL_WITHOUT_EXPECT!>actual fun foo() {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>foo<!>() {}
 
 // MODULE: m3-js()()(m1-common)
 // FILE: js.kt
 package js
 
-<!ACTUAL_WITHOUT_EXPECT!>actual fun foo() {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>foo<!>() {}

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.fir.kt

@@ -1,11 +0,0 @@
-// MODULE: m1-common
-// FILE: common.kt
-
-expect fun foo()
-
-// MODULE: m2-jvm()()(m1-common)
-// FILE: jvm.kt
-
-<!NON_MEMBER_FUNCTION_NO_BODY!>actual fun foo()<!>
-
-<!ACTUAL_WITHOUT_EXPECT, NON_MEMBER_FUNCTION_NO_BODY!>actual fun bar()<!>

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implWithoutHeader.fir.kt

@@ -1,4 +0,0 @@
-// MODULE: m1-jvm
-// FILE: jvm.kt
-
-<!ACTUAL_WITHOUT_EXPECT!>actual fun foo() { }<!>

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implWithoutHeader.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // MODULE: m1-jvm
 // FILE: jvm.kt
 

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.fir.kt

@@ -7,7 +7,7 @@ expect fun nonInlineFun()
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
 
-<!ACTUAL_WITHOUT_EXPECT!>actual fun inlineFun() { }<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>inlineFun<!>() { }
 actual fun nonInlineFun() { }
 
 // MODULE: m3-js()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.fir.kt

@@ -17,10 +17,10 @@ expect inline fun f6(crossinline s: () -> String)
 // FILE: jvm.kt
 
 actual inline fun f1(noinline s: () -> String) {}
-<!ACTUAL_WITHOUT_EXPECT!>actual inline fun f2(noinline s: () -> String) {}<!>
+actual inline fun <!ACTUAL_WITHOUT_EXPECT!>f2<!>(noinline s: () -> String) {}
 actual inline fun f3(s: () -> String) {}
 actual inline fun f4(crossinline s: () -> String) {}
-<!ACTUAL_WITHOUT_EXPECT!>actual inline fun f5(crossinline s: () -> String) {}<!>
+actual inline fun <!ACTUAL_WITHOUT_EXPECT!>f5<!>(crossinline s: () -> String) {}
 actual inline fun f6(s: () -> String) {}
-<!ACTUAL_WITHOUT_EXPECT!>actual fun f7(vararg x: Any) {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>f7<!>(vararg x: Any) {}
-<!ACTUAL_WITHOUT_EXPECT!>actual fun f8(x: Any) {}<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>f8<!>(x: Any) {}

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

@@ -18,17 +18,17 @@ expect var v2: Boolean
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_WITHOUT_EXPECT!>actual var v1: Boolean = false
+actual var <!ACTUAL_WITHOUT_EXPECT!>v1<!>: Boolean = false
-    private set<!>
+    private set
 
 actual var v2: Boolean = false
 
-<!ACTUAL_WITHOUT_EXPECT!>actual var v3: Boolean = false
+actual var <!ACTUAL_WITHOUT_EXPECT!>v3<!>: Boolean = false
-    private set<!>
+    private set
 
 actual open class C {
-    <!ACTUAL_WITHOUT_EXPECT!>actual var foo: Boolean = false
+    actual var <!ACTUAL_WITHOUT_EXPECT!>foo<!>: Boolean = false
-        protected set<!>
+        protected set
 }
 
 open class C2Typealias {