[Tests] Fix .ll.kt KMP tests data added in previous commit

It is expected, that in some complex cases `ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT` reports in .ll.kt disappeared at all. This is because FIR checker doesn't catch comlex cases, which are handled by IR checker. Also add comments about bugs KT-62886 and KT-63382 found by tests. ^KT-62559
2023-10-20 17:57:28 +02:00
parent 29980c6b85
commit c20a5fc650
120 changed files with 386 additions and 378 deletions
@@ -2,13 +2,13 @@
 // FILE: common.kt
 annotation class Ann

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class A {
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>class B {
+expect class A {
+    class B {
        @Ann
        fun foo()
-        <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>
-    }<!>
-}<!>
+        fun missingOnActual()
+    }
+}

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -18,4 +18,4 @@ class AImpl {
    }
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>A<!> = AImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>A<!> = AImpl
@@ -14,9 +14,9 @@ expect fun onType(): @Ann2("") Any?

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual annotation class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("annotation class Ann : Annotation; annotation class Ann : Annotation; Annotation `@Target(allowedTargets = vararg(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS))` is missing on actual declaration")!>Ann<!><!>
+actual annotation class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("annotation class Ann : Annotation; annotation class Ann : Annotation; Annotation `@Target(allowedTargets = vararg(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS))` is missing on actual declaration")!>Ann<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun stringConcat(): Unit; fun stringConcat(): Unit; Annotation `@Ann2(s = String(1).plus(String(2)))` is missing on actual declaration")!>stringConcat<!>() {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun stringConcat(): Unit; fun stringConcat(): Unit; Annotation `@Ann2(s = String(1).plus(String(2)))` is missing on actual declaration")!>stringConcat<!>() {}

 // Not reported in K1, because supported starting from K2
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun onType(): @Ann2(...) Any?; fun onType(): Any?; Annotation `@Ann2(s = String())` is missing on actual declaration")!>onType<!>(): Any? = null<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun onType(): @Ann2(...) Any?; fun onType(): Any?; Annotation `@Ann2(s = String())` is missing on actual declaration")!>onType<!>(): Any? = null
@@ -87,8 +87,8 @@ package test
@ClassArgAnn(ClassForReference::class)
 actual fun getClassExpression() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ClassArgAnn(ClassForReference::class)
-actual fun differentClassesWithSameName() {}<!>
+@ClassArgAnn(ClassForReference::class)
+actual fun differentClassesWithSameName() {}

@StringArgAnn("1.9")
 actual fun stringConstant() {}
@@ -114,8 +114,8 @@ actual fun varargInAnnotationWithArraySpread() {}
@ArrayArgAnn(arrayOf("foo", "bar"))
 actual fun arrayInAnnotation() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ArrayArgAnn(["foo"])
-actual fun arrayInAnnotationNotMatch() {}<!>
+@ArrayArgAnn(["foo"])
+actual fun arrayInAnnotationNotMatch() {}

@NestedAnnArg(
    text = "root",
@@ -127,7 +127,7 @@ actual fun arrayInAnnotationNotMatch() {}<!>
 )
 actual fun complexNestedAnnotations() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@NestedAnnArg(
+@NestedAnnArg(
    text = "root",
    NestedAnnArg("1"),
    NestedAnnArg("2",
@@ -135,4 +135,4 @@ actual fun complexNestedAnnotations() {}
                 NestedAnnArg("DIFFERENT")
    )
 )
-actual fun complexNestedAnnotationsNotMatch() {}<!>
+actual fun complexNestedAnnotationsNotMatch() {}
@@ -7,5 +7,5 @@ expect fun explicitDefaultArgument()
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
 // No special handling for this case
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>explicitDefaultArgument<!>() {}<!>
+@Ann
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>explicitDefaultArgument<!>() {}
@@ -23,8 +23,8 @@ actual annotation class ExpectIsSubsetOfActual
@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.CLASS)
 actual annotation class ExpectIsSubsetOfActualDifferentOrder

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Target(AnnotationTarget.FUNCTION)
-actual annotation class MoreTargetsOnExpect<!>
+@Target(AnnotationTarget.FUNCTION)
+actual annotation class MoreTargetsOnExpect

@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS)
 actual annotation class RepeatedTargetsInExpect
@@ -62,26 +62,26 @@ expect fun explicitVsInfered()
@Ann<A>
 actual fun sameTypeParam() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<A>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentTypeParam<!>() {}<!>
+@Ann<A>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentTypeParam<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<A>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentWithSameName<!>() {}<!>
+@Ann<A>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentWithSameName<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<A>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>nonNullvsNull<!>() {}<!>
+@Ann<A>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>nonNullvsNull<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<Ann<out A>>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentVariance<!>() {}<!>
+@Ann<Ann<out A>>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>differentVariance<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<Ann<A>>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>varianceVsNoVariance<!>() {}<!>
+@Ann<Ann<A>>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>varianceVsNoVariance<!>() {}

@Ann<Ann<in A>>
 actual fun sameVariance() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann<Ann<Any>>
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>startProjection<!>() {}<!>
+@Ann<Ann<Any>>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>startProjection<!>() {}

@ComplexNested<A>(
    ComplexNested<A>(),
@@ -89,11 +89,11 @@ actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>startProjection<!>() {}<!>
 )
 actual fun complexSame() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ComplexNested<A>(
+@ComplexNested<A>(
    ComplexNested<A>(),
    ComplexNested<A>(),
 )
-actual fun complexDiffer() {}<!>
+actual fun complexDiffer() {}

@NestedWithSameTypeArgument<A>(
    NestedWithSameTypeArgument<A>()
@@ -25,7 +25,7 @@ expect class AnnotationInside {
@Ann
 actual class AnnotationMatching

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>AnnotationOnExpectOnly<!><!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>AnnotationOnExpectOnly<!>

@Ann
 actual class AnnotationOnActualOnly
@@ -34,7 +34,7 @@ actual class AnnotationInside {
    @Ann
    actual fun matches() {}

-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onlyOnExpect<!>() {}<!>
+    actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onlyOnExpect<!>() {}

    @Ann
    actual fun onlyOnActual() {}
@@ -44,28 +44,28 @@ expect fun onType(param: @Ann Any)

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClass<!><!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClass<!>

 actual class OnMember {
-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onMember<!>() {}<!>
+    actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onMember<!>() {}
 }

 class ViaTypealiasImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ViaTypealias<!> = ViaTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ViaTypealias<!> = ViaTypealiasImpl

 class MemberScopeViaTypealiasImpl {
    fun foo() {}
 }
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MemberScopeViaTypealias<!> = MemberScopeViaTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MemberScopeViaTypealias<!> = MemberScopeViaTypealiasImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@WithArg("other str")
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withDifferentArg<!>() {}<!>
+@WithArg("other str")
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withDifferentArg<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inValueParam<!>(arg: String) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inValueParam<!>(arg: String) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inTypeParam<!>() {}<!>
+actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inTypeParam<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetter<!>: String = ""<!>
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetter<!>: String = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onType<!>(param: Any) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onType<!>(param: Any) {}
@@ -16,7 +16,7 @@ expect class A {
 actual class A {
    actual class B {
        actual class C {
-            <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>() {}<!>
+            actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>() {}
        }
    }
 }
@@ -2,15 +2,15 @@
 // FILE: common.kt
 annotation class Ann

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class WeakIncompatibility {
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
-    fun foo(p: String)<!>
-}<!>
+expect class WeakIncompatibility {
+    @Ann
+    fun foo(p: String)
+}

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class StrongIncompatibility {
-    <!EXPECT_ACTUAL_MISMATCH{JVM}!>@Ann
-    fun foo(p: Int)<!>
-}<!>
+expect class StrongIncompatibility {
+    @Ann
+    fun foo(p: Int)
+}

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -19,7 +19,7 @@ class WeakIncompatibilityImpl {
 }

 // TODO: Duplicated diagnostic will be fixed in KT-62559
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>WeakIncompatibility<!> = WeakIncompatibilityImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>WeakIncompatibility<!> = WeakIncompatibilityImpl

 class StrongIncompatibilityImpl {
    fun foo(p: String) {} // Different param type
@@ -14,5 +14,5 @@ expect class CompatibleOverrides {
 actual class CompatibleOverrides {
    actual fun foo() {}

-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>(withArg: Any) {}<!>
+    actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>(withArg: Any) {}
 }
@@ -7,4 +7,4 @@ expect fun foo(p: Array<Int> = arrayOf())

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun foo(p: Array<Int> = ...): Unit; fun foo(p: Array<Int>): Unit; Annotation `@Ann()` is missing on actual declaration")!>foo<!>(p: Array<Int>) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT("fun foo(p: Array<Int> = ...): Unit; fun foo(p: Array<Int>): Unit; Annotation `@Ann()` is missing on actual declaration")!>foo<!>(p: Array<Int>) {}
@@ -24,8 +24,8 @@ expect fun differentArgumentsOrder()
@Ann1
 actual class AnnotationOrder

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann3(2, 1)
-actual class ValuesOrderInsideAnnotationArgument<!>
+@Ann3(2, 1)
+actual class ValuesOrderInsideAnnotationArgument

@Ann4(arg2 = "2", arg1 = "1")
 actual fun differentArgumentsOrder() {}
@@ -2,14 +2,14 @@
 // FILE: common.kt
 annotation class Ann

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class E {
+expect enum class E {
    @Ann
    FOO,
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>MISSING_ON_ACTUAL<!>
-}<!>
+    MISSING_ON_ACTUAL
+}

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual enum class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_WITHOUT_EXPECT!>E<!> {
-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>FOO<!>
-}<!>
+actual enum class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_WITHOUT_EXPECT!>E<!> {
+    FOO
+}
@@ -28,4 +28,4 @@ abstract class Intermediate : I {
    override fun noAnnotationOnActual() {}
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>FakeOverrideActual<!> : Intermediate(), I<!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>FakeOverrideActual<!> : Intermediate(), I
@@ -7,5 +7,5 @@ expect fun floatNumbersComparison()

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann(0.1 + 0.1 + 0.1)
-actual fun floatNumbersComparison() {}<!>
+@Ann(0.1 + 0.1 + 0.1)
+actual fun floatNumbersComparison() {}
@@ -23,20 +23,20 @@ expect var onSetter: String

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetter<!>: String
-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>get() = ""<!><!>
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetter<!>: String
+    get() = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetterImplicit<!>: String = ""<!>
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetterImplicit<!>: String = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetterWithExplicitTarget<!>: String
-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>get() = ""<!><!>
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetterWithExplicitTarget<!>: String
+    get() = ""

 actual val explicitTargetMatchesWithoutTarget: String
    @Ann get() = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann
-actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>setOnPropertyWithoutTargetNotMatch<!>: String = ""<!>
+@Ann
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>setOnPropertyWithoutTargetNotMatch<!>: String = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual var <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onSetter<!>: String
+actual var <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onSetter<!>: String
    get() = ""
-    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>set(_) {}<!><!>
+    set(_) {}
@@ -18,5 +18,5 @@ expect fun nonMatching()
@Ann(MyEnum.FOO.name)
 actual fun matching() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann(MyEnum.FOO.name)
-actual fun nonMatching() {}<!>
+@Ann(MyEnum.FOO.name)
+actual fun nonMatching() {}
@@ -27,9 +27,9 @@ expect fun withSameArgLessOnActual()
@AnnWithArg(s = "2")
 actual fun diffentOrder() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@AnnWithArg(s = "1")
+@AnnWithArg(s = "1")
@AnnWithArg(s = "3")
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withDifferentArgLessOnActual<!>() {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withDifferentArgLessOnActual<!>() {}

@AnnWithArg(s = "1")
@AnnWithArg(s = "2")
@@ -1,3 +1,6 @@
+// LL_FIR_DIVERGENCE
+// UNRESOLVED_REFERENCE on MyOptIn is due to bug KT-61757
+// LL_FIR_DIVERGENCE
 // WITH_STDLIB
 // MODULE: m1-common
 // FILE: common.kt
@@ -14,10 +17,10 @@ annotation class MyOptIn
@Deprecated(message = "Some text")
@DeprecatedSinceKotlin("1.8")
@Suppress(<!ERROR_SUPPRESSION!>"INVISIBLE_REFERENCE"<!>, "INVISIBLE_MEMBER")
-@MyOptIn
-@WasExperimental(MyOptIn::class)
+@<!UNRESOLVED_REFERENCE!>MyOptIn<!>
+@WasExperimental(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>MyOptIn<!>::class<!>)
@kotlin.internal.RequireKotlin(version = "1.8")
-@OptIn(MyOptIn::class)
+@OptIn(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!><!UNRESOLVED_REFERENCE!>MyOptIn<!>::class<!>)
 expect fun skippedAnnotationsOnExpectOnly()

@OptIn(ExperimentalMultiplatform::class)
@@ -29,8 +32,8 @@ expect class ImplicitlyActualizedByJvmDeclarationOnExpectOnly
 package kotlin

@OptIn(ExperimentalMultiplatform::class)
-actual annotation class OptionalExpectationOnExpectOnly
+actual annotation class <!ACTUAL_WITHOUT_EXPECT, ACTUAL_WITHOUT_EXPECT!>OptionalExpectationOnExpectOnly<!>

-actual fun skippedAnnotationsOnExpectOnly() {}
+actual fun <!ACTUAL_WITHOUT_EXPECT!>skippedAnnotationsOnExpectOnly<!>() {}

-actual class ImplicitlyActualizedByJvmDeclarationOnExpectOnly
+actual class <!ACTUAL_WITHOUT_EXPECT!>ImplicitlyActualizedByJvmDeclarationOnExpectOnly<!>
@@ -1,3 +1,6 @@
+// LL_FIR_DIVERGENCE
+// Bug KT-62886
+// LL_FIR_DIVERGENCE
 // WITH_STDLIB
 // DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION
 // MODULE: m1-common
@@ -20,6 +23,6 @@ class SourceAvailableImpl {
    fun foo() {}
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>SourceAvailable<!> = SourceAvailableImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>SourceAvailable<!> = SourceAvailableImpl

-actual typealias FromLib = kotlin.SinceKotlin
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>FromLib<!> = kotlin.SinceKotlin
@@ -19,6 +19,6 @@ abstract class Parent<T> {

 abstract class Intermediate : Parent<String>()

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> : Intermediate()<!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> : Intermediate()

 actual class WithoutAnn : Intermediate()
@@ -17,5 +17,5 @@ class Impl {
    fun foo() {}
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> = Impl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> = Impl
 actual typealias WithoutAnn = Impl
@@ -13,15 +13,15 @@ expect class ViaTypealias<@Ann A>

 expect class TypealiasParamNotAccepted<@Ann A>

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <@Ann A, @Ann B> withIncompatibility()<!>
+expect fun <@Ann A, @Ann B> withIncompatibility()

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <A> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethod<!>() {}<!>
+actual fun <A> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethod<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <@Ann A, B> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethodTwoParams<!>() {}<!>
+actual fun <@Ann A, B> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethodTwoParams<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InClass<!><A><!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InClass<!><A>

 class ViaTypealiasImpl<@Ann A>

@@ -29,6 +29,6 @@ actual typealias ViaTypealias<A> = ViaTypealiasImpl<A>

 class TypealiasParamNotAcceptedImpl<A>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>TypealiasParamNotAccepted<!><@Ann A> = TypealiasParamNotAcceptedImpl<A><!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>TypealiasParamNotAccepted<!><@Ann A> = TypealiasParamNotAcceptedImpl<A>

 actual fun <A> <!ACTUAL_WITHOUT_EXPECT!>withIncompatibility<!>() {}
@@ -19,9 +19,9 @@ interface I2

 expect fun <T> severalBounds() where T : I1, T : @Ann I2

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> severalBoundsDifferentOrder() where T : I2, T : @Ann I1<!>
+expect fun <T> severalBoundsDifferentOrder() where T : I2, T : @Ann I1

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> lessTypeParamBoundsOnActual() where T : I1, T : @Ann I2<!>
+expect fun <T> lessTypeParamBoundsOnActual() where T : I1, T : @Ann I2

 expect fun @Ann Any.onReceiver()

@@ -51,7 +51,7 @@ expect fun qualifierPartsMatching(arg: WithNested<String>.Nested<@Ann String>)

 expect fun qualifierPartsNonMatching(arg: WithNested<String>.Nested<@Ann String>)

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun funTypeVsUserType(arg: () -> @Ann String)<!>
+expect fun funTypeVsUserType(arg: () -> @Ann String)

 expect fun funcTypeReturnType(arg: () -> @Ann Any)

@@ -61,46 +61,46 @@ expect fun funcTypeArgType(arg: (arg: @Ann Any) -> Unit)

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>valueParameterType<!>(arg: String) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>valueParameterType<!>(arg: String) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>returnType<!>(): String = ""<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>returnType<!>(): String = ""

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T : Any> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>methodTypeParamBound<!>() {}<!>
+actual fun <T : Any> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>methodTypeParamBound<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassTypeParamBound<!><T : Any><!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassTypeParamBound<!><T : Any>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>typeParamBoundInWhere<!>() where T : Any {}<!>
+actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>typeParamBoundInWhere<!>() where T : Any {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>severalBounds<!>() where T : I1, T : I2 {}<!>
+actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>severalBounds<!>() where T : I1, T : I2 {}

 actual fun <T> <!ACTUAL_WITHOUT_EXPECT!>severalBoundsDifferentOrder<!>() where T : @Ann I1, T : I2 {}

 actual fun <T> <!ACTUAL_WITHOUT_EXPECT!>lessTypeParamBoundsOnActual<!>() where T : @Ann I2 {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun Any.<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onReceiver<!>() {}<!>
+actual fun Any.<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onReceiver<!>() {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuper<!> : I1<!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuper<!> : I1

 actual class OnClassSuperDifferentOrder : @Ann I2, I1

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuperMoreOnActual<!> : I1, I2<!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuperMoreOnActual<!> : I1, I2

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuperTypeParams<!><T> : I3<T><!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuperTypeParams<!><T> : I3<T>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>deepInParamsTypes<!>(arg: I3<I3<Any>>) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>deepInParamsTypes<!>(arg: I3<I3<Any>>) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>starProjection<!>(arg: I4<*, Any>) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>starProjection<!>(arg: I4<*, Any>) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>typeArgWithVariance<!>(t: I3<out T>) {}<!>
+actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>typeArgWithVariance<!>(t: I3<out T>) {}

 actual fun qualifierPartsMatching(arg: WithNested<String>.Nested<@Ann String>) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>qualifierPartsNonMatching<!>(arg: WithNested<@Ann String>.Nested<String>) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>qualifierPartsNonMatching<!>(arg: WithNested<@Ann String>.Nested<String>) {}

 actual fun <!ACTUAL_WITHOUT_EXPECT!>funTypeVsUserType<!>(arg: kotlin.jvm.functions.Function0<String>) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeReturnType<!>(arg: () -> Any) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeReturnType<!>(arg: () -> Any) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeReceiverType<!>(arg: Any.() -> Unit) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeReceiverType<!>(arg: Any.() -> Unit) {}

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeArgType<!>(arg: (arg: Any) -> Unit) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeArgType<!>(arg: (arg: Any) -> Unit) {}
@@ -11,4 +11,4 @@ expect class Foo: @Ann I
 // FILE: jvm.kt
 typealias ITypealias = I

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>Foo<!> : ITypealias<!>
+actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>Foo<!> : ITypealias
@@ -7,4 +7,4 @@ expect fun foo(): @Ann Int

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>() = 1<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>() = 1
@@ -3,7 +3,7 @@
@Target(AnnotationTarget.TYPE)
 annotation class Ann

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T : @Ann Any> foo()<!>
+expect fun <T : @Ann Any> foo()

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -48,35 +48,35 @@ expect class InnerClassInsideTypealias {
 // FILE: jvm.kt
 class KtTypealiasNotMatchImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>KtTypealiasNotMatch<!> = KtTypealiasNotMatchImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>KtTypealiasNotMatch<!> = KtTypealiasNotMatchImpl

 class AnnotationsNotConsideredOnTypealiasImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann
-actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>AnnotationsNotConsideredOnTypealias<!> = AnnotationsNotConsideredOnTypealiasImpl<!>
+@Ann
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>AnnotationsNotConsideredOnTypealias<!> = AnnotationsNotConsideredOnTypealiasImpl

 class MethodsInsideTypealiasImpl {
    fun foo() {}
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MethodsInsideTypealias<!> = MethodsInsideTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MethodsInsideTypealias<!> = MethodsInsideTypealiasImpl

 class ValueInsideTypealiasImpl {
    val value: String = ""
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ValueInsideTypealias<!> = ValueInsideTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ValueInsideTypealias<!> = ValueInsideTypealiasImpl

 class ConstructorInsideTypealiasImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ConstructorInsideTypealias<!> = ConstructorInsideTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ConstructorInsideTypealias<!> = ConstructorInsideTypealiasImpl

 class MethodWithComplexAnnInsideTypealiasImpl {
    @ComplexAnn("13")
    fun withComplexAnn() {}
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias MethodWithComplexAnnInsideTypealias = MethodWithComplexAnnInsideTypealiasImpl<!>
+actual typealias MethodWithComplexAnnInsideTypealias = MethodWithComplexAnnInsideTypealiasImpl

 class InnerClassInsideTypealiasImpl {
    class Foo {
@@ -84,4 +84,4 @@ class InnerClassInsideTypealiasImpl {
    }
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InnerClassInsideTypealias<!> = InnerClassInsideTypealiasImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InnerClassInsideTypealias<!> = InnerClassInsideTypealiasImpl
@@ -9,6 +9,6 @@ expect annotation class MyDeprecatedMatch

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias MyDeprecatedNotMatch = java.lang.Deprecated<!>
+actual typealias MyDeprecatedNotMatch = java.lang.Deprecated

 actual typealias MyDeprecatedMatch = java.lang.Deprecated
@@ -36,8 +36,8 @@ expect abstract class MyAbstractIterator<T> {

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias MyDeprecatedNotMatch = kotlin.Deprecated<!>
+actual typealias MyDeprecatedNotMatch = kotlin.Deprecated

 actual typealias MyDeprecatedMatch = kotlin.Deprecated

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MyAbstractIterator<!><T> = AbstractIterator<T><!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MyAbstractIterator<!><T> = AbstractIterator<T>
@@ -7,12 +7,12 @@ expect fun inMethod(@Ann arg: String)

 expect class InConstructor(@Ann arg: String)

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun withIncopatibility(@Ann p1: String, @Ann p2: String)<!>
+expect fun withIncopatibility(@Ann p1: String, @Ann p2: String)

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethod<!>(arg: String) {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inMethod<!>(arg: String) {}

-actual class InConstructor <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual constructor(arg: String)<!> {}
+actual class InConstructor <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual constructor(arg: String)<!> {}

 actual fun <!ACTUAL_WITHOUT_EXPECT!>withIncopatibility<!>(p1: String) {}
@@ -2,17 +2,17 @@
 // FILE: common.kt
 annotation class Ann

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
-expect inline fun hasWeakIncompatibility()<!>
+@Ann
+expect inline fun hasWeakIncompatibility()

-<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>@Ann
-expect fun hasStrongIncompatibility(arg: Int)<!>
+@Ann
+expect fun hasStrongIncompatibility(arg: Int)

 expect fun hasStrongIncompatibility(arg: Double)

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_WITHOUT_EXPECT!>hasWeakIncompatibility<!>() {}<!>
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_WITHOUT_EXPECT!>hasWeakIncompatibility<!>() {}

 actual fun <!ACTUAL_WITHOUT_EXPECT!>hasStrongIncompatibility<!>(arg: Any?) {}

@@ -5,7 +5,7 @@ open class Base {
    open fun <T> foo(t: T) {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -7,8 +7,8 @@ open class Base {
    open lateinit var green: String
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
-}<!>
+expect open class Foo : Base {
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,7 +5,7 @@ interface Base {
    fun foo()
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!> : Base<!>
+expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!> : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -3,7 +3,7 @@
 interface Base {
    fun foo()
 }
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!>() : Base<!>
+expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!>() : Base


 // MODULE: m2-jvm()()(m1-common)
@@ -3,7 +3,7 @@
 interface Base {
    fun foo() {}
 }
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect abstract class Foo() : Base<!>
+expect abstract class Foo() : Base


 // MODULE: m2-jvm()()(m1-common)
@@ -5,7 +5,7 @@ open class Base {
    open fun foo() {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,7 +5,7 @@ open class Base<T> {
    open fun foo(t: T) {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<String><!>
+expect open class Foo : Base<String>

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<!>
+expect open class Foo

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,7 +5,7 @@ open class Base {
    open fun foo(param: Int) {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo1 : Base<!>
+expect open class Foo1 : Base
 expect open class Foo2 : Base
 expect open class Foo3 {
    open fun foo(param: Int)
@@ -6,7 +6,7 @@ open class Base {
        protected set
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,8 +5,8 @@ open class Base {
    open fun foo(vararg bar: Int) {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
-}<!>
+expect open class Foo : Base {
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,7 +5,7 @@ open class Base {
    protected open fun foo() {}
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -6,8 +6,8 @@ open class Base {
    open fun foo(): Any = ""
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
-}<!>
+expect open class Foo : Base {
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -7,8 +7,8 @@ open class Base {
    open fun foo(): I = null!!
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<T : I> : Base {
-}<!>
+expect open class Foo<T : I> : Base {
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,8 +5,8 @@ open class Base<R> {
    open fun foo(): R = null!!
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<R, T : R> : Base<R> {
-}<!>
+expect open class Foo<R, T : R> : Base<R> {
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -6,7 +6,7 @@ open class Base {
    open fun foo(): String = ""
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,9 +5,9 @@ expect open class Base {
    open fun foo(): MutableList<String>
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+expect open class Foo : Base {

-}<!>
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -5,7 +5,7 @@ open class Base {
    open val foo: Int = 1
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+expect open class Foo : Base

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -8,10 +8,10 @@ open class Base() {
    protected open fun overrideVisibility(): Any = ""
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+expect open class Foo : Base {
    fun existingMethod()
    val existingParam: Int
-}<!>
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class A<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>(vararg val x: String)<!><!>
+expect annotation class A(vararg val x: String)

@A("abc", "foo", "bar")
 fun test() {}
@@ -3,9 +3,9 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class Mode {
+expect enum class Mode {
    Throughput, AverageTime
-}<!>
+}

 expect annotation class BenchmarkMode(vararg val value: Mode)

@@ -1,4 +1,4 @@
 // ISSUE: KT-58483
 // MODULE: jvm
 // FILE: jvm.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect class A<!>
+expect class A
@@ -2,27 +2,27 @@
 // FILE: common.kt

 expect class E01
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
+expect class E02()
+expect open class E03

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
+expect class E04 {
    constructor()
-}<!>
+}

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
+expect class E05(e: E01)
+expect class E06 {
    constructor(e: E02)
-}<!>
+}

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
+expect interface I01

 expect class M01 {
    fun foo()
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
+expect enum class ENUM01

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
+expect annotation class ANNO01

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -2,27 +2,27 @@
 // FILE: common.kt

 expect class E01
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
+expect class E02()
+expect open class E03

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
+expect class E04 {
    constructor()
-}<!>
+}

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
+expect class E05(e: E01)
+expect class E06 {
    constructor(e: E02)
-}<!>
+}

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
+expect interface I01

 expect class M01 {
    fun foo()
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
+expect enum class ENUM01

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
+expect annotation class ANNO01

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -30,4 +30,4 @@ actual annotation class A3(actual val x: Int = 42, actual val y: String = "OK")

 actual annotation class A4(actual val x: Int, actual val y: String = "OK")

-actual annotation class A5(actual val x: Int = <!ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE!>239<!>, actual val y: String = "OK")
+actual annotation class A5(actual val x: Int = 239, actual val y: String = "OK")
@@ -25,7 +25,7 @@ actual typealias A1 = J1
 actual typealias A2 = J2
 actual typealias A3 = J3
 actual typealias A4 = J4
-<!ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE!>actual typealias A5 = J5<!>
+actual typealias A5 = J5

 // FILE: J1.java

@@ -12,7 +12,7 @@ expect annotation class NonMatching(val e: E = E.BAR)
 // FILE: jvm.kt
 actual typealias E = EJava
 actual typealias Matching = AJava
-<!ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE!>actual typealias NonMatching = AJava<!>
+actual typealias NonMatching = AJava

 // FILE: EJava.java
 public enum EJava {
@@ -1,8 +1,8 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun foo(param: Int = 1)<!>
-}<!>
+expect class Foo {
+    fun foo(param: Int = 1)
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,9 +1,9 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
+expect class Foo {
    fun foo(param: Int = 1)
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>
-}<!>
+    fun missingOnActual()
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -17,9 +17,9 @@ expect class WithDefaultArgFromSuper : I {
    override fun methodWithDefaultArg(s: String)
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class WithIncompatibility {
+expect open class WithIncompatibility {
    fun foo(p: String = "common")
-}<!>
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,8 +1,8 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class DefaultArgsInNestedClass {
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>annotation class Nested<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>(val p: String = "")<!><!>
-}<!>
+expect class DefaultArgsInNestedClass {
+    annotation class Nested(val p: String = "")
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,14 +1,14 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
+expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
    E1,
    E2<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>(42)<!>,
    ;

    <!EXPECTED_ENUM_CONSTRUCTOR!>constructor(s: String)<!>
-}<!>
+}

-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En2 {
+expect enum class En2 {
    E1<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
-}<!>
+}
@@ -1,10 +1,10 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En {
+expect enum class En {
    E1,
    <!EXPECTED_ENUM_ENTRY_WITH_BODY!>E2 {
        <!EXPECTED_DECLARATION_WITH_BODY!>fun foo()<!> = ""
    },<!>
    <!EXPECTED_ENUM_ENTRY_WITH_BODY!>E3 { };<!>
-}<!>
+}
@@ -1,19 +1,23 @@
+// LL_FIR_DIVERGENCE
+// WRONG_MODIFIER_TARGET not reported in LL and reported in CLI tests in common module,
+// because it is JVM-only checker, and in CLI common module analyzed additionally against JVM target.
+// LL_FIR_DIVERGENCE
 // MODULE: m1-common
 // FILE: common.kt

 expect <!EXPECTED_EXTERNAL_DECLARATION!>external<!> fun foo()
 expect fun bar()

-expect <!EXPECTED_EXTERNAL_DECLARATION, WRONG_MODIFIER_TARGET!>external<!> var prop: String
+expect <!EXPECTED_EXTERNAL_DECLARATION!>external<!> var prop: String

 expect var getAndSet: String
    <!EXPECTED_EXTERNAL_DECLARATION!>external<!> get
    <!EXPECTED_EXTERNAL_DECLARATION!>external<!> set

-<!EXPECTED_EXTERNAL_DECLARATION, WRONG_MODIFIER_TARGET!>external<!> expect val explicitGetter: String
+<!EXPECTED_EXTERNAL_DECLARATION!>external<!> expect val explicitGetter: String
    <!EXPECTED_EXTERNAL_DECLARATION!>external<!> get

-expect <!EXPECTED_EXTERNAL_DECLARATION, WRONG_MODIFIER_TARGET!>external<!> class A {
+expect <!EXPECTED_EXTERNAL_DECLARATION!>external<!> class A {
    <!EXPECTED_EXTERNAL_DECLARATION!>external<!> fun foo()
    fun bar()
 }
@@ -1,15 +1,15 @@
 // MODULE: m1-common
 // FILE: common.kt
 // TODO: .fir.kt version is just a stub.
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface My {
+expect interface My {
    open fun openFunPositive()
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openFunNegative()<!>
+    open fun openFunNegative()
    abstract fun abstractFun()

    open val openValPositive: Int
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open val openValNegative: Int<!>
+    open val openValNegative: Int
    abstract val abstractVal: Int
-}<!>
+}

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -4,7 +4,7 @@
 interface A
 interface B

-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> List<T>.foo() where T : A, T : B<!>
+expect fun <T> List<T>.foo() where T : A, T : B

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -7,7 +7,7 @@ expect annotation class Foo3
 expect annotation class Foo4
 expect annotation class Foo5()
 expect annotation class Foo6()
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class Foo7<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
+expect annotation class Foo7()

@<!UNRESOLVED_REFERENCE!>Foo1<!>
 fun foo() {}
@@ -5,9 +5,9 @@ expect class Foo1
 expect class Foo2
 expect class Foo3

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar1<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar2<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar3<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
+expect class Bar1()
+expect class Bar2()
+expect class Bar3()
 expect class Bar4()
 expect class Bar5()
 expect class Bar6()
@@ -1,5 +1,5 @@
 // MODULE: m1-common
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface Base<!>
+expect interface Base

 // MODULE: m1-jvm()()(m1-common)
 actual interface Base {
@@ -5,18 +5,18 @@ interface Foo {
    fun foo()
 }

-<!NO_ACTUAL_FOR_EXPECT!>expect class NonAbstractClass : Foo {
+expect class NonAbstractClass : Foo {
    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun bar()

    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val baz: Int

    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> override fun foo()
-}<!>
+}

-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class AbstractClass : Foo {
+expect abstract class AbstractClass : Foo {
    abstract fun bar()

    abstract val baz: Int

    abstract override fun foo()
-}<!>
+}
@@ -3,12 +3,12 @@
 // FILE: common.kt

 expect fun foo1(x: Int)
-<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo2(x: Int)<!>
+expect fun foo2(x: Int)

 expect class NoArgConstructor()

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun foo3(): Int<!>
-<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo4(): Int<!>
+expect fun foo3(): Int
+expect fun foo4(): Int

 // MODULE: m2-jvm()()(m1-common)

@@ -2,14 +2,14 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo1<!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo2<!>
+expect class Foo1
+expect class Foo2

 expect fun foo2(): Int

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect val s: String<!>
+expect val s: String

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo3<!>
+expect open class Foo3

 // MODULE: m2-jvm()()(m1-common)

@@ -5,9 +5,9 @@ expect fun interface F1 {
    fun run()
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F2 {
+expect fun interface F2 {
    fun run()
-}<!>
+}

 expect fun interface F3 {
    fun run()
@@ -21,9 +21,9 @@ expect fun interface F5 {
    fun run()
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F6 {
+expect fun interface F6 {
    fun run()
-}<!>
+}

 expect fun interface F7 {
    fun run()
@@ -1,13 +1,13 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect open class A {
+expect open class A {
    constructor(s: String)

    constructor(n: Number) : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("A")
-}<!>
+}

-<!NO_ACTUAL_FOR_EXPECT!>expect class B : A {
+expect class B : A {
    constructor(i: Int)

    constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>super<!>("B")
-}<!>
+}
@@ -1,10 +1,10 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseA() {
+expect abstract class BaseA() {
    abstract fun foo()
-}<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA<!>
+}
+expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA

 <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class DerivedA1<!> : BaseAImpl()
 class DerivedA2 : BaseAImpl() {
@@ -13,10 +13,10 @@ class DerivedA2 : BaseAImpl() {



-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseB {
+expect interface BaseB {
    fun foo()
-}<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB<!>
+}
+expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB

 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedB1<!> : BaseBImpl()
 class DerivedB2 : BaseBImpl() {
@@ -25,10 +25,10 @@ class DerivedB2 : BaseBImpl() {



-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseC {
+expect interface BaseC {
    fun foo()
-}<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseCImpl() : BaseC<!>
+}
+expect abstract class BaseCImpl() : BaseC

 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedC1<!> : BaseCImpl()
 class DerivedC2 : BaseCImpl() {
@@ -37,35 +37,35 @@ class DerivedC2 : BaseCImpl() {



-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseD {
+expect interface BaseD {
    fun foo()
-}<!>
+}
 abstract class BaseDImpl() : BaseD {
    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
 }



-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseE {
+expect interface BaseE {
    fun foo()
-}<!>
+}
 sealed class BaseEImpl() : BaseE {
    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
 }



-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseF {
+expect interface BaseF {
    fun foo()
-}<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF<!>
+}
+expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF



-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseG() {
+expect abstract class BaseG() {
    abstract fun foo()
-}<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect open class BaseGImpl() : BaseG {
+}
+expect open class BaseGImpl() : BaseG {
    override fun foo()
-}<!>
+}
 class DerivedG1 : BaseGImpl()
@@ -3,8 +3,8 @@
 // FILE: common.kt

 expect class C1
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C2<A><!>
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C3<B><!>
+expect interface C2<A>
+expect interface C3<B>
 expect interface C4<D, E>
 expect interface C5<F, G>
 expect interface C6<H>
@@ -1,4 +1,3 @@
-// IGNORE_REVERSED_RESOLVE
 // MODULE: m1-common
 // FILE: common.kt
 <!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
@@ -1,4 +1,3 @@
-// IGNORE_REVERSED_RESOLVE
 // MODULE: m1-common
 // FILE: common.kt
 expect class Foo {
@@ -1,7 +1,6 @@
-// IGNORE_REVERSED_RESOLVE
 // MODULE: m1-common
 // FILE: common.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+expect class Foo {
    <!EXPECTED_DECLARATION_WITH_BODY!>init<!> {
        "no"
    }
@@ -21,4 +20,4 @@
    <!EXPECTED_DECLARATION_WITH_BODY!>fun functionWithBody(x: Int): Int<!> {
        return x + 1
    }
-}<!>
+}
@@ -4,6 +4,6 @@
 interface A

 class B : A
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo(b: B) : A by b<!>
+expect class Foo(b: B) : A by b

-<!NO_ACTUAL_FOR_EXPECT!>expect class Bar : A by B()<!>
+expect class Bar : A by B()
@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+expect class Foo {
    val justVal: String
    var justVar: String

@@ -25,6 +25,6 @@
    <!EXPECTED_LATEINIT_PROPERTY!>lateinit<!> var lateinitVar: String

    val delegated: String by <!EXPECTED_DELEGATED_PROPERTY!>Delegate<!>
-}<!>
+}

 object Delegate { operator fun getValue(x: Any?, y: Any?): String = "" }
@@ -2,20 +2,20 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
+expect open class Container {
    fun publicFun()

    internal fun internalFun1()
    internal fun internalFun2()
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal fun internalFun3()<!>
+    internal fun internalFun3()

    protected fun protectedFun1()
    protected fun protectedFun2()
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>protected fun protectedFun3()<!>
+    protected fun protectedFun3()

-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open internal fun openInternalFun()<!>
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openPublicFun()<!>
-}<!>
+    open internal fun openInternalFun()
+    open fun openPublicFun()
+}

 // MODULE: m2-jvm()()(m1-common)

@@ -2,9 +2,9 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal open fun internalFun()<!>
-}<!>
+expect open class Container {
+    internal open fun internalFun()
+}

 // MODULE: m2-jvm()()(m1-common)

@@ -14,9 +14,9 @@ expect class C {
    <!WRONG_MODIFIER_TARGET!>expect<!> inner class I
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class D {
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>class N<!>
-}<!>
+expect class D {
+    class N
+}

 expect class E {
    class N
@@ -1,10 +1,10 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
+expect class Foo {
    fun bar(): String
-    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun bas(f: Int)<!>
-}<!>
+    fun bas(f: Int)
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,9 +1,9 @@
 // MODULE: m1-common
 // FILE: common.kt

-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo { // also, it's important that Foo doesn't override equals
+expect class Foo { // also, it's important that Foo doesn't override equals
    fun foo()
-}<!>
+}

 fun check(x1: Foo, x: Any) {
    if (x1 == x) {
@@ -7,9 +7,9 @@ interface J

 expect class Foo : I, C, J

-<!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>expect class Bar : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!><!>
+<!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>expect class Bar : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!><!>

-expect class WithExplicitPrimaryConstructor() : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
+expect class WithExplicitPrimaryConstructor() : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,3 +1,6 @@
+// LL_FIR_DIVERGENCE
+// False positive reports of ARGUMENT_TYPE_MISMATCH and UNRESOLVED_REFERENCE are due to bug KT-63382.
+// LL_FIR_DIVERGENCE
 // ISSUE: KT-57369

 // MODULE: common
@@ -25,6 +28,6 @@ fun cancelFutureOnCompletionAlt(handlerBase: CompletionHandlerBase) {
 // MODULE: main()()(common, intermediate)
 // the order of dependencies is important to reproduce KT-57369
 fun cancelFutureOnCompletion(handlerBase: CompletionHandlerBase) {
-    invokeOnCompletion(handlerBase)
-    handlerBase.foo()
+    invokeOnCompletion(<!ARGUMENT_TYPE_MISMATCH!>handlerBase<!>)
+    handlerBase.<!UNRESOLVED_REFERENCE!>foo<!>()
 }
@@ -4,9 +4,9 @@
 // TARGET_PLATFORM: Common

 // FILE: StringValue.kt
-<!NO_ACTUAL_FOR_EXPECT{JS}!>expect class StringValue<!>
+expect class StringValue

-<!NO_ACTUAL_FOR_EXPECT{JS}!>expect fun StringValue.plus(other: String): StringValue<!>
+expect fun StringValue.plus(other: String): StringValue

 // MODULE: commonJS()()(common)
 // TARGET_PLATFORM: JS
@@ -26,7 +26,7 @@ interface KotlinXStringDemoInterface {
    val value: String
 }

-<!EXPECT_ACTUAL_INCOMPATIBILITY{JS}!>expect fun StringDemoInterface.plusK(): String<!>
+expect fun StringDemoInterface.plusK(): String

 // MODULE: js()()(common, intermediate)
 // TARGET_PLATFORM: JS
@@ -1,3 +1,6 @@
+// LL_FIR_DIVERGENCE
+// Bug KT-62886
+// LL_FIR_DIVERGENCE
 // FIR_IDENTICAL
 // WITH_STDLIB
 // MODULE: common
@@ -12,4 +15,4 @@ expect annotation class CommonVolatile
@Retention(AnnotationRetention.SOURCE)
 actual annotation class Ann

-actual typealias CommonVolatile = kotlin.jvm.Volatile
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>CommonVolatile<!> = kotlin.jvm.Volatile
@@ -11,7 +11,7 @@ expect class Foo
 // FILE: Foo.kt
 actual annotation class Ann actual constructor(actual val p: Int)

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>Foo<!> = FooImpl<!>
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>Foo<!> = FooImpl

 // FILE: FooImpl.java
@Ann(p = 2)
@@ -1,4 +1,3 @@
-// IGNORE_REVERSED_RESOLVE
 // MODULE: common
 // TARGET_PLATFORM: Common

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

@@ -1,13 +1,12 @@
-// IGNORE_REVERSED_RESOLVE
 // MODULE: common
 // TARGET_PLATFORM: Common

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class CommonClass {
+expect class CommonClass {
    fun memberFun()
    val memberProp: Int
    class Nested
    inner class Inner
-}<!>
+}
 actual class <!ACTUAL_WITHOUT_EXPECT!>CommonClass<!> {
    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
@@ -15,10 +14,10 @@ actual class <!ACTUAL_WITHOUT_EXPECT!>CommonClass<!> {
    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
 }

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun commonFun()<!>
+expect fun commonFun()
 actual fun <!ACTUAL_WITHOUT_EXPECT!>commonFun<!>() {}

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val commonProperty: String<!>
+expect val commonProperty: String
 actual val <!ACTUAL_WITHOUT_EXPECT!>commonProperty<!>: String
    get() = "hello"

@@ -4,7 +4,7 @@
 expect fun parameterCount()
 fun parameterCount(p: String) {}

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun parameterCount2()<!>
+expect fun parameterCount2()
 actual fun <!ACTUAL_WITHOUT_EXPECT!>parameterCount2<!>(p: String) {}

 expect fun callableKind(): Int
@@ -13,9 +13,9 @@ val callableKind: Int = 1
 expect fun <T> typeParameterCount()
 fun typeParameterCount() {}

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class EnumEntries {
+expect enum class EnumEntries {
    ONE, TWO;
-}<!>
+}
 actual enum class <!ACTUAL_WITHOUT_EXPECT!>EnumEntries<!> {
    ONE;
 }
@@ -3,9 +3,9 @@
 // FILE: common.kt

 // K2: false positve INCOMPATIBLE_MATCHING: KT-60155
-<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>public expect abstract class AbstractMutableMap<K, V> : MutableMap<K, V> {
+public expect abstract class AbstractMutableMap<K, V> : MutableMap<K, V> {
    override val values: MutableCollection<V>
-}<!>
+}

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,12 +1,12 @@

-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class <!ACTUAL_WITHOUT_EXPECT!>First<!><!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class <!ACTUAL_WITHOUT_EXPECT!>First<!>

-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second<!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second

-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Third<!><!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Third<!>

-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class <!ACTUAL_WITHOUT_EXPECT!>Fourth<!><!>
+<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class <!ACTUAL_WITHOUT_EXPECT!>Fourth<!>

 <!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Fifth<!>

-<!NO_ACTUAL_FOR_EXPECT!><!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Sixth<!><!>
+<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Sixth<!>
--- a/Show More
+++ b/Show More