[Tests] Run KMP tests in Analysis API LL FIR test suites

New tests are red in current commit! All `.ll.kt` files are just copies of `.fir.kt` or `.kt`. This will be fixed in the next commit to clearly show difference between LL and FIR. The original purpose of this change was to test `ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT` diagnostic, for which FIR checker will be run only in IDE (to be changed in next MR), so its reports a lost from usual KMP tests. But this looks like a useful change for all KMP tests, not only this diagnostic. ^KT-62559
2023-10-25 11:16:21 +02:00
parent 026ad1cebc
commit 29980c6b85
120 changed files with 7775 additions and 618 deletions
@@ -59,7 +59,13 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() {

        useMetaTestConfigurators(::LLFirMetaTestConfigurator)
        useAfterAnalysisCheckers(::LLFirIdenticalChecker)
-        useAfterAnalysisCheckers(::LLFirDivergenceCommentChecker)
+
+        // For multiplatform tests it's expected that LL and FIR diverge,
+        // because IR actualizer doesn't run in IDE mode tests.
+        forTestsNotMatching("compiler/testData/diagnostics/tests/multiplatform/*") {
+            useAfterAnalysisCheckers(::LLFirDivergenceCommentChecker)
+        }
+
        useAfterAnalysisCheckers(::LLFirTestSuppressor)
    }

@@ -21,7 +21,7 @@ fun String.removeLlFirDivergenceDirective(trimLines: Boolean): String {
    return if (findDirectiveInLines(iterator)) {
        // `trimStart` ensures that the `LL_FIR_DIVERGENCE` directive can be separated from the rest of the file by blank lines.
        iterator.asSequence().concatLines(trimLines).trimStart()
-    } else this
+    } else this.trim() // Trim start and end newlines in file if directive not found
 }

 private fun Sequence<String>.concatLines(trimLines: Boolean): String =
@@ -0,0 +1,21 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class A {
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>class B {
+        @Ann
+        fun foo()
+        <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>
+    }<!>
+}<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+class AImpl {
+    class B {
+        fun foo() {}
+    }
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>A<!> = AImpl<!>
@@ -0,0 +1,22 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)
+expect annotation class Ann
+
+@Target(AnnotationTarget.TYPE, AnnotationTarget.FUNCTION)
+annotation class Ann2(val s: String)
+
+@Ann2("1" + "2")
+expect fun stringConcat()
+
+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_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<!>() {}<!>
+
+// 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<!>
@@ -0,0 +1,138 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+package test
+
+import kotlin.reflect.KClass
+
+annotation class ClassArgAnn(val clazz: KClass<*>)
+
+class ClassForReference {
+    class ClassForReference
+}
+
+@ClassArgAnn(ClassForReference::class)
+expect fun getClassExpression()
+
+@ClassArgAnn(ClassForReference.ClassForReference::class)
+expect fun differentClassesWithSameName()
+
+annotation class StringArgAnn(val s: String)
+
+@StringArgAnn("1.9")
+expect fun stringConstant()
+
+@StringArgAnn("1" + ".9")
+expect fun stringConcatentation()
+
+object Constants {
+    const val STR = "1"
+}
+
+@StringArgAnn(Constants.STR)
+expect fun constantFromInsideObject()
+
+@StringArgAnn(Constants.STR + ".9")
+expect fun stringConcatentationWithProperty()
+
+enum class MyEnum { FOO, BAR }
+
+annotation class EnumArgAnn(val e: MyEnum)
+
+@EnumArgAnn(MyEnum.FOO)
+expect fun enumArg()
+
+annotation class VarargAnn(vararg val strings: String)
+
+@VarargAnn("foo", "bar")
+expect fun varargInAnnotation()
+
+@VarargAnn(*["foo", "bar"])
+expect fun varargInAnnotationWithArraySpread()
+
+annotation class ArrayArgAnn(val strings: Array<String>)
+
+@ArrayArgAnn(["foo", "bar"])
+expect fun arrayInAnnotation()
+
+@ArrayArgAnn(["foo", "bar"])
+expect fun arrayInAnnotationNotMatch()
+
+annotation class NestedAnnArg(val text: String, vararg val children: NestedAnnArg)
+
+@NestedAnnArg(
+    text = "root",
+    NestedAnnArg("1"),
+    NestedAnnArg("2",
+                 NestedAnnArg("2.1"),
+                 NestedAnnArg("2.2")
+    )
+)
+expect fun complexNestedAnnotations()
+
+@NestedAnnArg(
+    text = "root",
+    NestedAnnArg("1"),
+    NestedAnnArg("2",
+                 NestedAnnArg("2.1"),
+                 NestedAnnArg("2.2")
+    )
+)
+expect fun complexNestedAnnotationsNotMatch()
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+package test
+
+@ClassArgAnn(ClassForReference::class)
+actual fun getClassExpression() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ClassArgAnn(ClassForReference::class)
+actual fun differentClassesWithSameName() {}<!>
+
+@StringArgAnn("1.9")
+actual fun stringConstant() {}
+
+@StringArgAnn("1.9")
+actual fun stringConcatentation() {}
+
+@StringArgAnn("1")
+actual fun constantFromInsideObject() {}
+
+@StringArgAnn("1.9")
+actual fun stringConcatentationWithProperty() {}
+
+@EnumArgAnn(MyEnum.FOO)
+actual fun enumArg() {}
+
+@VarargAnn("foo", "bar")
+actual fun varargInAnnotation() {}
+
+@VarargAnn("foo", "bar")
+actual fun varargInAnnotationWithArraySpread() {}
+
+@ArrayArgAnn(arrayOf("foo", "bar"))
+actual fun arrayInAnnotation() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ArrayArgAnn(["foo"])
+actual fun arrayInAnnotationNotMatch() {}<!>
+
+@NestedAnnArg(
+    text = "root",
+    NestedAnnArg("1"),
+    NestedAnnArg("2",
+                 NestedAnnArg("2.1"),
+                 NestedAnnArg("2.2")
+    )
+)
+actual fun complexNestedAnnotations() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@NestedAnnArg(
+    text = "root",
+    NestedAnnArg("1"),
+    NestedAnnArg("2",
+                 NestedAnnArg("2.1"),
+                 NestedAnnArg("DIFFERENT")
+    )
+)
+actual fun complexNestedAnnotationsNotMatch() {}<!>
@@ -0,0 +1,11 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann(val p: String = "")
+@Ann("")
+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<!>() {}<!>
@@ -0,0 +1,33 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)
+expect annotation class ExpectIsSubsetOfActual
+
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+expect annotation class ExpectIsSubsetOfActualDifferentOrder
+
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)
+expect annotation class MoreTargetsOnExpect
+
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+expect annotation class RepeatedTargetsInExpect
+
+@Target(allowedTargets = [])
+expect annotation class EmptyTargetsActual
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.CLASS)
+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, AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS)
+actual annotation class RepeatedTargetsInExpect
+
+@Target(AnnotationTarget.FUNCTION)
+actual annotation class EmptyTargetsActual
@@ -0,0 +1,101 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann<T>
+
+class A
+class B
+private object FakeA {
+    class A
+}
+
+@Ann<A>
+expect fun sameTypeParam()
+
+@Ann<B>
+expect fun differentTypeParam()
+
+@Ann<FakeA.A>
+expect fun differentWithSameName()
+
+@Ann<A?>
+expect fun nonNullvsNull()
+
+@Ann<Ann<in A>>
+expect fun differentVariance()
+
+@Ann<Ann<in A>>
+expect fun varianceVsNoVariance()
+
+@Ann<Ann<in A>>
+expect fun sameVariance()
+
+@Ann<Ann<*>>
+expect fun startProjection()
+
+annotation class ComplexNested<T>(
+    vararg val anns: ComplexNested<*>,
+)
+
+@ComplexNested<A>(
+    ComplexNested<A>(),
+    ComplexNested<A>(),
+)
+expect fun complexSame()
+
+@ComplexNested<A>(
+    ComplexNested<A>(),
+    ComplexNested<B>(),
+)
+expect fun complexDiffer()
+
+annotation class NestedWithSameTypeArgument<T>(
+    vararg val anns: NestedWithSameTypeArgument<T>
+)
+
+@NestedWithSameTypeArgument<A>(
+    NestedWithSameTypeArgument()
+)
+expect fun explicitVsInfered()
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+@Ann<A>
+actual fun sameTypeParam() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@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<!>() {}<!>
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@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<!>() {}<!>
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@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<!>() {}<!>
+
+@ComplexNested<A>(
+    ComplexNested<A>(),
+    ComplexNested<A>(),
+)
+actual fun complexSame() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@ComplexNested<A>(
+    ComplexNested<A>(),
+    ComplexNested<A>(),
+)
+actual fun complexDiffer() {}<!>
+
+@NestedWithSameTypeArgument<A>(
+    NestedWithSameTypeArgument<A>()
+)
+actual fun explicitVsInfered() {}
@@ -0,0 +1,41 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+@Ann
+expect class AnnotationMatching
+
+@Ann
+expect class AnnotationOnExpectOnly
+
+expect class AnnotationOnActualOnly
+
+expect class AnnotationInside {
+    @Ann
+    fun matches()
+
+    @Ann
+    fun onlyOnExpect()
+
+    fun onlyOnActual()
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+@Ann
+actual class AnnotationMatching
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>AnnotationOnExpectOnly<!><!>
+
+@Ann
+actual class AnnotationOnActualOnly
+
+actual class AnnotationInside {
+    @Ann
+    actual fun matches() {}
+
+    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onlyOnExpect<!>() {}<!>
+
+    @Ann
+    actual fun onlyOnActual() {}
+}
@@ -0,0 +1,26 @@
+/jvm.kt:(106,113): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'class OnClass : Any' must be present with the same arguments on actual 'class OnClass : Any', otherwise they might behave incorrectly.
+
+/jvm.kt:(154,162): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'fun onMember(): Unit' must be present with the same arguments on actual 'fun onMember(): Unit', otherwise they might behave incorrectly.
+
+/jvm.kt:(212,224): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'class ViaTypealias : Any' must be present with the same arguments on actual 'class ViaTypealiasImpl : Any', otherwise they might behave incorrectly.
+
+/jvm.kt:(317,340): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'fun foo(): Unit' must be present with the same arguments on actual 'fun foo(): Unit', otherwise they might behave incorrectly.
+
+/jvm.kt:(405,421): warning: Annotation `@WithArg(s = String(str))` has different arguments on actual declaration: `@WithArg(s = String(other str))`.
+All annotations from expect 'fun withDifferentArg(): Unit' must be present with the same arguments on actual 'fun withDifferentArg(): Unit', otherwise they might behave incorrectly.
+
+/jvm.kt:(439,451): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'fun inValueParam(arg: String): Unit' must be present with the same arguments on actual 'fun inValueParam(arg: String): Unit', otherwise they might behave incorrectly.
+
+/jvm.kt:(484,495): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'fun <T> inTypeParam(): Unit' must be present with the same arguments on actual 'fun <T> inTypeParam(): Unit', otherwise they might behave incorrectly.
+
+/jvm.kt:(513,521): warning: Annotation `@PROPERTY_GETTER:Ann()` is missing on actual declaration.
+All annotations from expect 'val onGetter: String    get(): String' must be present with the same arguments on actual 'val onGetter: String    get(): String', otherwise they might behave incorrectly.
+
+/jvm.kt:(547,553): warning: Annotation `@Ann()` is missing on actual declaration.
+All annotations from expect 'fun onType(param: @Ann() Any): Unit' must be present with the same arguments on actual 'fun onType(param: Any): Unit', otherwise they might behave incorrectly.
@@ -0,0 +1,71 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+// MODULE: m1-common
+// FILE: common.kt
+@Target(
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.VALUE_PARAMETER,
+    AnnotationTarget.TYPE_PARAMETER,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.TYPE,
+)
+annotation class Ann
+
+@Ann
+expect class OnClass
+
+expect class OnMember {
+    @Ann
+    fun onMember()
+}
+
+@Ann
+expect class ViaTypealias
+
+expect class MemberScopeViaTypealias {
+    @Ann
+    fun foo()
+}
+
+annotation class WithArg(val s: String)
+
+@WithArg("str")
+expect fun withDifferentArg()
+
+expect fun inValueParam(@Ann arg: String)
+
+expect fun <@Ann T> inTypeParam()
+
+@get:Ann
+expect val onGetter: String
+
+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 OnMember {
+    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onMember<!>() {}<!>
+}
+
+class ViaTypealiasImpl
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>@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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onType<!>(param: Any) {}<!>
@@ -0,0 +1,22 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+expect class A {
+    class B {
+        class C {
+            @Ann
+            fun foo()
+        }
+    }
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual class A {
+    actual class B {
+        actual class C {
+            <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>() {}<!>
+        }
+    }
+}
@@ -0,0 +1,28 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class WeakIncompatibility {
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
+    fun foo(p: String)<!>
+}<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class StrongIncompatibility {
+    <!EXPECT_ACTUAL_MISMATCH{JVM}!>@Ann
+    fun foo(p: Int)<!>
+}<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+class WeakIncompatibilityImpl {
+    fun foo(differentName: String) {}
+}
+
+// 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<!>
+
+class StrongIncompatibilityImpl {
+    fun foo(p: String) {} // Different param type
+}
+
+actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>StrongIncompatibility<!> = StrongIncompatibilityImpl
@@ -0,0 +1,18 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+expect class CompatibleOverrides {
+    fun foo()
+
+    @Ann
+    fun foo(withArg: Any)
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual class CompatibleOverrides {
+    actual fun foo() {}
+
+    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>foo<!>(withArg: Any) {}<!>
+}
@@ -0,0 +1,10 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+@Ann
+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>) {}<!>
@@ -0,0 +1,31 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann1
+annotation class Ann2
+
+@Ann1
+@Ann2
+expect class AnnotationOrder
+
+annotation class Ann3(vararg val numbers: Int)
+
+@Ann3(1, 2)
+expect class ValuesOrderInsideAnnotationArgument
+
+annotation class Ann4(val arg1: String, val arg2: String)
+
+@Ann4(arg1 = "1", arg2 = "2")
+expect fun differentArgumentsOrder()
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+@Ann2
+@Ann1
+actual class AnnotationOrder
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann3(2, 1)
+actual class ValuesOrderInsideAnnotationArgument<!>
+
+@Ann4(arg2 = "2", arg1 = "1")
+actual fun differentArgumentsOrder() {}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class E {
+    @Ann
+    FOO,
+    <!NO_ACTUAL_FOR_EXPECT{JVM}!>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<!>
+}<!>
@@ -0,0 +1,31 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+abstract class A {
+    @Ann
+    open fun noAnnotationOnActual() {}
+}
+
+expect class FakeOverrideExpect : A
+
+interface I {
+    fun noAnnotationOnActual()
+}
+
+expect class FakeOverrideActual : I {
+    @Ann
+    override fun noAnnotationOnActual()
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual class FakeOverrideExpect : A() {
+    override fun noAnnotationOnActual() {}
+}
+
+abstract class Intermediate : I {
+    override fun noAnnotationOnActual() {}
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>FakeOverrideActual<!> : Intermediate(), I<!>
@@ -0,0 +1,11 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann(val p: Double)
+
+@Ann(0.3)
+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() {}<!>
@@ -0,0 +1,42 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.PROPERTY, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+annotation class Ann
+
+expect val onGetter: String
+    @Ann get
+
+expect val onGetterImplicit: String
+    @Ann get
+
+@get:Ann
+expect val onGetterWithExplicitTarget: String
+
+@get:Ann
+expect val explicitTargetMatchesWithoutTarget: String
+
+@get:Ann
+expect val setOnPropertyWithoutTargetNotMatch: String
+
+expect var onSetter: String
+    @Ann set
+
+// 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_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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 explicitTargetMatchesWithoutTarget: String
+    @Ann get() = ""
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann
+actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>setOnPropertyWithoutTargetNotMatch<!>: String = ""<!>
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual var <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onSetter<!>: String
+    get() = ""
+    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>set(_) {}<!><!>
@@ -0,0 +1,22 @@
+// !LANGUAGE: +IntrinsicConstEvaluation
+// MODULE: m1-common
+// FILE: common.kt
+enum class MyEnum {
+    FOO
+}
+
+annotation class Ann(val p: String)
+
+@Ann("FOO")
+expect fun matching()
+
+@Ann("not FOO")
+expect fun nonMatching()
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+@Ann(MyEnum.FOO.name)
+actual fun matching() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann(MyEnum.FOO.name)
+actual fun nonMatching() {}<!>
@@ -0,0 +1,40 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+@Repeatable
+annotation class AnnWithArg(val s: String)
+
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "2")
+expect fun diffentOrder()
+
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "2")
+@AnnWithArg(s = "3")
+expect fun withDifferentArgLessOnActual()
+
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "3")
+expect fun withDifferentArgLessOnExpect()
+
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "1")
+expect fun withSameArgLessOnActual()
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "2")
+actual fun diffentOrder() {}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@AnnWithArg(s = "1")
+@AnnWithArg(s = "3")
+actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withDifferentArgLessOnActual<!>() {}<!>
+
+@AnnWithArg(s = "1")
+@AnnWithArg(s = "2")
+@AnnWithArg(s = "3")
+actual fun withDifferentArgLessOnExpect() {}
+
+@AnnWithArg(s = "1")
+actual fun withSameArgLessOnActual() {}
@@ -0,0 +1,36 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+package kotlin
+
+@OptIn(ExperimentalMultiplatform::class)
+@OptionalExpectation
+expect annotation class OptionalExpectationOnExpectOnly
+
+@RequiresOptIn
+annotation class MyOptIn
+
+@SinceKotlin("1.8")
+@Deprecated(message = "Some text")
+@DeprecatedSinceKotlin("1.8")
+@Suppress(<!ERROR_SUPPRESSION!>"INVISIBLE_REFERENCE"<!>, "INVISIBLE_MEMBER")
+@MyOptIn
+@WasExperimental(MyOptIn::class)
+@kotlin.internal.RequireKotlin(version = "1.8")
+@OptIn(MyOptIn::class)
+expect fun skippedAnnotationsOnExpectOnly()
+
+@OptIn(ExperimentalMultiplatform::class)
+@kotlin.jvm.ImplicitlyActualizedByJvmDeclaration
+expect class ImplicitlyActualizedByJvmDeclarationOnExpectOnly
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+package kotlin
+
+@OptIn(ExperimentalMultiplatform::class)
+actual annotation class OptionalExpectationOnExpectOnly
+
+actual fun skippedAnnotationsOnExpectOnly() {}
+
+actual class ImplicitlyActualizedByJvmDeclarationOnExpectOnly
@@ -0,0 +1,25 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION
+// MODULE: m1-common
+// FILE: common.kt
+@Retention(AnnotationRetention.SOURCE)
+annotation class Ann
+
+@Ann
+expect class SourceAvailable {
+    @Ann
+    fun foo()
+}
+
+@Ann
+expect annotation class FromLib
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+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 FromLib = kotlin.SinceKotlin
@@ -0,0 +1,24 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+expect class WithAnn {
+    @Ann
+    fun foo(p: String)
+}
+
+expect class WithoutAnn {
+    fun foo(p: String)
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+abstract class Parent<T> {
+    open fun foo(p: T) {}
+}
+
+abstract class Intermediate : Parent<String>()
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> : Intermediate()<!>
+
+actual class WithoutAnn : Intermediate()
@@ -0,0 +1,21 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+expect class WithAnn {
+    @Ann
+    fun foo()
+}
+
+expect class WithoutAnn {
+    fun foo()
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+class Impl {
+    fun foo() {}
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>WithAnn<!> = Impl<!>
+actual typealias WithoutAnn = Impl
@@ -0,0 +1,34 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.TYPE_PARAMETER)
+annotation class Ann
+
+expect fun <@Ann A> inMethod()
+
+expect fun <A, @Ann B> inMethodTwoParams()
+
+expect class InClass<@Ann A>
+
+expect class ViaTypealias<@Ann A>
+
+expect class TypealiasParamNotAccepted<@Ann A>
+
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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><!>
+
+class ViaTypealiasImpl<@Ann A>
+
+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 fun <A> <!ACTUAL_WITHOUT_EXPECT!>withIncompatibility<!>() {}
@@ -0,0 +1,106 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+expect fun valueParameterType(arg: @Ann String)
+
+expect fun returnType(): @Ann String
+
+expect fun <T : @Ann Any> methodTypeParamBound()
+
+expect class OnClassTypeParamBound<T : @Ann Any>
+
+expect fun <T> typeParamBoundInWhere() where T : @Ann Any
+
+interface I1
+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_ACTUAL_MISMATCH{JVM}!>expect fun <T> lessTypeParamBoundsOnActual() where T : I1, T : @Ann I2<!>
+
+expect fun @Ann Any.onReceiver()
+
+expect class OnClassSuper : @Ann I1
+
+expect class OnClassSuperDifferentOrder : I1, @Ann I2
+
+expect class OnClassSuperMoreOnActual : @Ann I2
+
+interface I3<T>
+
+expect class OnClassSuperTypeParams<T> : I3<@Ann T>
+
+expect fun deepInParamsTypes(arg: I3<I3<@Ann Any>>)
+
+interface I4<T, U>
+
+expect fun starProjection(arg: I4<*, @Ann Any>)
+
+expect fun <T> typeArgWithVariance(t: I3<out @Ann T>)
+
+class WithNested<T> {
+    inner class Nested<U>
+}
+
+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 funcTypeReturnType(arg: () -> @Ann Any)
+
+expect fun funcTypeReceiverType(arg: @Ann Any.() -> Unit)
+
+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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>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 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_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_ANNOTATIONS_NOT_MATCH_EXPECT!>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) {}<!>
@@ -0,0 +1,14 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+interface I
+
+expect class Foo: @Ann I
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+typealias ITypealias = I
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>Foo<!> : ITypealias<!>
@@ -0,0 +1,10 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+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<!>
@@ -0,0 +1,10 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T : @Ann Any> foo()<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual fun <T : <!UNRESOLVED_REFERENCE!>Unresolved<!>> <!ACTUAL_WITHOUT_EXPECT!>foo<!>() {}
@@ -0,0 +1,87 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+@Target(
+    AnnotationTarget.TYPEALIAS,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.CONSTRUCTOR,
+)
+annotation class Ann
+
+@Ann
+expect class KtTypealiasNotMatch
+
+@Ann
+expect class AnnotationsNotConsideredOnTypealias
+
+annotation class ComplexAnn(val s: String)
+
+expect class MethodsInsideTypealias {
+    @Ann
+    fun foo()
+}
+
+expect class ValueInsideTypealias {
+    @Ann
+    val value: String
+}
+
+expect class ConstructorInsideTypealias @Ann constructor()
+
+expect class MethodWithComplexAnnInsideTypealias {
+    @ComplexAnn("1" + "2")
+    fun withComplexAnn()
+}
+
+expect class InnerClassInsideTypealias {
+    class Foo {
+        @Ann
+        fun foo()
+    }
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+class KtTypealiasNotMatchImpl
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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<!>
+
+class MethodsInsideTypealiasImpl {
+    fun foo() {}
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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<!>
+
+class ConstructorInsideTypealiasImpl
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ConstructorInsideTypealias<!> = ConstructorInsideTypealiasImpl<!>
+
+class MethodWithComplexAnnInsideTypealiasImpl {
+    @ComplexAnn("13")
+    fun withComplexAnn() {}
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias MethodWithComplexAnnInsideTypealias = MethodWithComplexAnnInsideTypealiasImpl<!>
+
+class InnerClassInsideTypealiasImpl {
+    class Foo {
+        fun foo() {}
+    }
+}
+
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InnerClassInsideTypealias<!> = InnerClassInsideTypealiasImpl<!>
@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+@Retention(AnnotationRetention.SOURCE)
+expect annotation class MyDeprecatedNotMatch
+
+@Retention(AnnotationRetention.RUNTIME)
+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 MyDeprecatedMatch = java.lang.Deprecated
@@ -0,0 +1,43 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_MEMBERS_AS_NON_FINAL_EXPECT_CLASSIFIER_WARNING, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_SUPERTYPES_AS_NON_FINAL_EXPECT_CLASSIFIER_WARNING
+// MODULE: m1-common
+// FILE: common.kt
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.ANNOTATION_CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.TYPEALIAS,
+    AnnotationTarget.TYPE, // added target
+)
+expect annotation class MyDeprecatedNotMatch
+
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.ANNOTATION_CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.TYPEALIAS
+)
+expect annotation class MyDeprecatedMatch
+
+annotation class Ann(val s: String)
+
+expect abstract class MyAbstractIterator<T> {
+    @Ann("something" + "complex")
+    fun hasNext(): Boolean
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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><!>
@@ -0,0 +1,18 @@
+// MODULE: m1-common
+// FILE: common.kt
+@Target(AnnotationTarget.VALUE_PARAMETER)
+annotation class Ann
+
+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)<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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 fun <!ACTUAL_WITHOUT_EXPECT!>withIncopatibility<!>(p1: String) {}
@@ -0,0 +1,19 @@
+// MODULE: m1-common
+// FILE: common.kt
+annotation class Ann
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
+expect inline fun hasWeakIncompatibility()<!>
+
+<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>@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_WITHOUT_EXPECT!>hasStrongIncompatibility<!>(arg: Any?) {}
+
+actual fun hasStrongIncompatibility(arg: Double) {}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open fun <T> foo(t: T) {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override fun <R> foo(t: R) {}
+}
@@ -0,0 +1,20 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open var red1: String = ""
+    open lateinit var red2: String
+    open lateinit var green: String
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override lateinit var red1: String
+    override var red2: String = ""
+    override lateinit var green: String
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface Base {
+    fun foo()
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!> : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base {
+    final override fun foo() {}
+}
@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+interface Base {
+    fun foo()
+}
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!>() : Base<!>
+
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+// Mismatched scope must be reported here. But it's false negative checker in K1.
+// For some reason, K1 says that modality of `exect_Foo.foo` is `abstract`.
+// https://youtrack.jetbrains.com/issue/KT-59739
+actual open class Foo : Base {
+    override fun foo() {}
+}
@@ -0,0 +1,14 @@
+// MODULE: m1-common
+// FILE: common.kt
+interface Base {
+    fun foo() {}
+}
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect abstract class Foo() : Base<!>
+
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual abstract class Foo : Base {
+    abstract override fun foo()
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open fun foo() {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    final override fun foo() {}
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base<T> {
+    open fun foo(t: T) {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<String><!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base<String>() {
+    final override fun foo(t: String) {}
+}
@@ -0,0 +1,11 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo {
+    final override fun toString() = "Foo"
+}
@@ -0,0 +1,34 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open fun foo(param: Int) {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo1 : Base<!>
+expect open class Foo2 : Base
+expect open class Foo3 {
+    open fun foo(param: Int)
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo1 : Base() {
+    override fun foo(paramNameChanged: Int) {}
+}
+
+actual typealias Foo2 = Foo2Java
+actual typealias Foo3 = Foo3Java
+
+// FILE: Foo2Java.java
+
+public class Foo2Java extends Base {
+    @Override
+    public void foo(int paramNameChanged) {}
+}
+
+// FILE: Foo3Java.java
+public class Foo3Java {
+    public void foo(int paramNameChanged) {}
+}
@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open var foo: String = ""
+        protected set
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override var foo: String = ""
+        public set
+}
@@ -0,0 +1,16 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open fun foo(vararg bar: Int) {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override fun foo(bar: IntArray) {}
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    protected open fun foo() {}
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    public override fun foo() {}
+}
@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open val foo: String = ""
+    open fun foo(): Any = ""
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override fun foo(): String = ""
+}
@@ -0,0 +1,18 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface I
+
+open class Base {
+    open fun foo(): I = null!!
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<T : I> : Base {
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo<T : I> : Base() {
+    override fun foo(): T = null!!
+}
@@ -0,0 +1,16 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+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> {
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo<E, F : E> : Base<E>() {
+    override fun foo(): F = null!!
+}
@@ -0,0 +1,16 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open val foo: Any = ""
+    open fun foo(): String = ""
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override val foo: String = ""
+}
@@ -0,0 +1,33 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect open class Base {
+    open fun foo(): MutableList<String>
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
+
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual typealias Base = BaseJava
+
+actual open class Foo : Base() {
+    // K1 doesn't report a diagnostic here because when it compares scopes it sees flexible type
+    // K2 will likely report a diagnostic here
+    // I don't think we can fix this 'K1 green -> K2 red'. It must be a rare case anyway.
+    override fun foo(): List<String> {
+        return super.foo()
+    }
+}
+
+// FILE: BaseJava.java
+import java.util.List;
+
+public class BaseJava {
+    public List<String> foo() {
+        return null;
+    }
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base {
+    open val foo: Int = 1
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    override var foo: Int = 1
+}
@@ -0,0 +1,29 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+open class Base() {
+    open fun overrideReturnType(): Any = ""
+    open fun overrideModality1(): Any = ""
+    open fun overrideModality2(): Any = ""
+    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 {
+    fun existingMethod()
+    val existingParam: Int
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual open class Foo : Base() {
+    actual fun existingMethod() {}
+    actual val existingParam: Int = 904
+
+    fun injectedMethod() {}
+    val injectedProperty: Int = 42
+    override fun overrideReturnType(): String = ""
+    final override fun overrideModality1(): Any = ""
+    final override fun overrideModality2(): Any = ""
+    public override fun overrideVisibility(): Any = ""
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class A<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>(vararg val x: String)<!><!>
+
+@A("abc", "foo", "bar")
+fun test() {}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual annotation class A(val x: Array<String>)
+
+@A(<!ARGUMENT_TYPE_MISMATCH!>"abc"<!>, <!TOO_MANY_ARGUMENTS!>"foo"<!>, <!TOO_MANY_ARGUMENTS!>"bar"<!>)
+fun test2() {}
@@ -0,0 +1,35 @@
+// ISSUES: KT-61100, KT-59561
+// WITH_STDLIB
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class Mode {
+    Throughput, AverageTime
+}<!>
+
+expect annotation class BenchmarkMode(vararg val value: Mode)
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS("actual typealias Mode = Mode;     expect constructor(): Mode")!>Mode<!> = mypackage.Mode
+
+
+actual typealias BenchmarkMode = mypackage.BenchmarkMode
+
+// FILE: mypackage/Mode.java
+
+package mypackage;
+
+public enum Mode {
+    Throughput, AverageTime
+}
+
+// FILE: mypackage/BenchmarkMode.java
+
+package mypackage;
+
+public @interface BenchmarkMode {
+
+    Mode[] value();
+}
@@ -0,0 +1,4 @@
+// ISSUE: KT-58483
+// MODULE: jvm
+// FILE: jvm.kt
+<!NO_ACTUAL_FOR_EXPECT!>expect class A<!>
@@ -0,0 +1,47 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class E01
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
+    constructor()
+}<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
+    constructor(e: E02)
+}<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
+
+expect class M01 {
+    fun foo()
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual object E01
+actual object <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E02<!>
+actual object <!ACTUAL_WITHOUT_EXPECT!>E03<!>
+
+actual object <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E04<!>
+
+actual object <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E05<!>
+actual object <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E06<!>
+
+actual object <!ACTUAL_WITHOUT_EXPECT!>I01<!>
+
+actual object M01 {
+    actual fun foo() {}
+}
+
+actual object <!ACTUAL_WITHOUT_EXPECT!>ENUM01<!>
+
+actual object <!ACTUAL_WITHOUT_EXPECT!>ANNO01<!>
@@ -0,0 +1,49 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class E01
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
+    constructor()
+}<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
+    constructor(e: E02)
+}<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
+
+expect class M01 {
+    fun foo()
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+object ActualObject {
+    fun foo() {}
+}
+
+actual typealias E01 = ActualObject
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E02<!> = ActualObject
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>E03<!> = ActualObject
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E04<!> = ActualObject
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E05<!> = ActualObject
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>E06<!> = ActualObject
+
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>I01<!> = ActualObject
+
+actual typealias M01 = ActualObject
+
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>ENUM01<!> = ActualObject
+
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>ANNO01<!> = ActualObject
@@ -0,0 +1,33 @@
+// FIR_IDENTICAL
+// MODULE: m1-common
+// FILE: common.kt
+
+expect annotation class A1(val x: Int, val y: String = "OK")
+
+expect annotation class A2(val x: Int = 42, val y: String = "OK")
+
+expect annotation class A3(val x: Int, val y: String)
+
+expect annotation class A4(val x: Int = 42, val y: String)
+
+expect annotation class A5(val x: Int = 42, val y: String)
+
+@A1(0)
+@A2
+@A3(0, "")
+@A4(0, "")
+@A5(0, "")
+fun test() {}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual annotation class A1(actual val x: Int, actual val y: String)
+
+actual annotation class A2(actual val x: Int, actual val y: String = "OK")
+
+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")
@@ -0,0 +1,63 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect annotation class A1(val x: Int, val y: String = "OK")
+
+expect annotation class A2(val x: Int = 42, val y: String = "OK")
+
+expect annotation class A3(val x: Int, val y: String)
+
+expect annotation class A4(val x: Int = 42, val y: String)
+
+expect annotation class A5(val x: Int = 42, val y: String)
+
+@A1(0)
+@A2
+@A3(0, "")
+@A4(0, "")
+@A5(0, "")
+fun test() {}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+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<!>
+
+// FILE: J1.java
+
+public @interface J1 {
+    int x();
+    String y();
+}
+
+// FILE: J2.java
+
+public @interface J2 {
+    int x();
+    String y() default "OK";
+}
+
+// FILE: J3.java
+
+public @interface J3 {
+    int x() default 42;
+    String y() default "OK";
+}
+
+// FILE: J4.java
+
+public @interface J4 {
+    int x();
+    String y() default "OK";
+}
+
+// FILE: J5.java
+
+public @interface J5 {
+    int x() default 239;
+    String y() default "OK";
+}
@@ -0,0 +1,27 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect enum class E {
+    FOO, BAR
+}
+
+expect annotation class Matching(val e: E = E.FOO)
+
+expect annotation class NonMatching(val e: E = E.BAR)
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+actual typealias E = EJava
+actual typealias Matching = AJava
+<!ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE!>actual typealias NonMatching = AJava<!>
+
+// FILE: EJava.java
+public enum EJava {
+    FOO, BAR;
+
+    EJava() {}
+}
+
+// FILE: AJava.java
+public @interface AJava {
+    EJava e() default EJava.FOO;
+}
@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun foo(param: Int = 1)<!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+interface Base {
+    fun foo(p: Int)
+}
+
+object BaseImpl : Base {
+    override fun foo(p: Int) {}
+}
+
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base by BaseImpl<!>
@@ -0,0 +1,14 @@
+// MODULE: m1-common
+// FILE: common.kt
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
+    fun foo(param: Int = 1)
+    <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+open class Base {
+    fun foo(param: Int) {}
+}
+
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base()<!>
@@ -0,0 +1,49 @@
+// !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
+// MODULE: m1-common
+// FILE: common.kt
+expect class A {
+    fun foo(p1: String = "common", p2: String = "common", p3: String)
+}
+
+expect class B {
+    fun foo(s: String)
+}
+
+interface I {
+    fun methodWithDefaultArg(s: String = "common")
+}
+
+expect class WithDefaultArgFromSuper : I {
+    override fun methodWithDefaultArg(s: String)
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class WithIncompatibility {
+    fun foo(p: String = "common")
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+class AImpl {
+    fun foo(p1: String = "impl", p2: String = "impl", p3: String) {}
+}
+
+<!DEFAULT_ARGUMENTS_IN_EXPECT_WITH_ACTUAL_TYPEALIAS!>actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>A<!> = AImpl<!>
+
+class BImpl {
+    fun foo(s: String = "impl") {}
+}
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>B<!> = BImpl
+
+class WithDefaultArgFromSuperImpl : I {
+    override fun methodWithDefaultArg(s: String) {}
+}
+
+actual typealias WithDefaultArgFromSuper = WithDefaultArgFromSuperImpl
+
+class WithIncompatibilityImpl {
+    fun foo(p: String) {}
+}
+
+<!DEFAULT_ARGUMENTS_IN_EXPECT_WITH_ACTUAL_TYPEALIAS!>actual typealias WithIncompatibility = WithIncompatibilityImpl<!>
@@ -0,0 +1,14 @@
+// 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 = "")<!><!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+class DefaultArgsInNestedClassImpl {
+    annotation class Nested(val p: String = "")
+}
+
+// Incompatible because of bug KT-31636
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>DefaultArgsInNestedClass<!> = DefaultArgsInNestedClassImpl
@@ -0,0 +1,14 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!NO_ACTUAL_FOR_EXPECT!>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 {
+    E1<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
+}<!>
@@ -0,0 +1,10 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!NO_ACTUAL_FOR_EXPECT!>expect enum class En {
+    E1,
+    <!EXPECTED_ENUM_ENTRY_WITH_BODY!>E2 {
+        <!EXPECTED_DECLARATION_WITH_BODY!>fun foo()<!> = ""
+    },<!>
+    <!EXPECTED_ENUM_ENTRY_WITH_BODY!>E3 { };<!>
+}<!>
@@ -0,0 +1,38 @@
+// 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 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<!> get
+
+expect <!EXPECTED_EXTERNAL_DECLARATION, WRONG_MODIFIER_TARGET!>external<!> class A {
+    <!EXPECTED_EXTERNAL_DECLARATION!>external<!> fun foo()
+    fun bar()
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual external fun foo()
+actual external fun bar()
+
+actual <!WRONG_MODIFIER_TARGET!>external<!> var prop: String
+
+actual var getAndSet: String
+    external get
+    external set
+
+actual <!WRONG_MODIFIER_TARGET!>external<!> val explicitGetter: String
+    external get
+
+actual class A {
+    actual external fun foo()
+    actual external fun bar()
+}
@@ -0,0 +1,24 @@
+// MODULE: m1-common
+// FILE: common.kt
+// TODO: .fir.kt version is just a stub.
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface My {
+    open fun openFunPositive()
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openFunNegative()<!>
+    abstract fun abstractFun()
+
+    open val openValPositive: Int
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open val openValNegative: Int<!>
+    abstract val abstractVal: Int
+}<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+actual interface My {
+    actual fun openFunPositive() = Unit
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>openFunNegative<!>()
+    actual fun abstractFun()
+
+    actual val openValPositive: Int get() = 0
+    actual val <!ACTUAL_WITHOUT_EXPECT!>openValNegative<!>: Int
+    actual val abstractVal: Int
+}
@@ -0,0 +1,12 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface A
+interface B
+
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> List<T>.foo() where T : A, T : B<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+fun <T> List<T>.foo() where T : B, T : A {}
@@ -0,0 +1,47 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect annotation class Foo1
+expect annotation class Foo2
+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}!>()<!><!>
+
+@<!UNRESOLVED_REFERENCE!>Foo1<!>
+fun foo() {}
+
+@Foo5
+fun bar() {}
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: Bar1.java
+
+public @interface Bar1 {
+    String value() default "";
+}
+
+// FILE: Bar2.java
+
+public @interface Bar2 {
+    String value() default "";
+    String path();
+}
+
+// FILE: jvm.kt
+
+actual typealias Foo1 = Bar1
+
+actual typealias Foo4 = Bar2
+
+actual annotation class Foo2(val p: String = "default")
+
+actual annotation class Foo3(val a: String = "a", val b: String = "b")
+
+actual annotation class Foo5
+
+actual annotation class Foo6(val s: String = "value")
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo7<!> = Bar2
@@ -0,0 +1,54 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+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 Bar4()
+expect class Bar5()
+expect class Bar6()
+expect class Bar7(s: String)
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: JavaFoo.java
+
+public class JavaFoo {
+    public JavaFoo(int i) {}
+}
+
+// FILE: JavaBar.java
+
+public class JavaBar {
+    public JavaBar(int i) {}
+}
+
+// FILE: jvm.kt
+
+actual class Foo1(val s: String)
+actual class Foo2(val p: String = "value", i: Int)
+actual typealias Foo3 = JavaFoo
+
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Bar1<!>(val s: String)
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Bar2<!>(val p: String = "value", i: Int)
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Bar3<!> = JavaBar
+actual class Bar4(val s: String) {
+    constructor() : this("")
+}
+
+actual class Bar5 {
+    actual constructor()
+    constructor(s: String)
+}
+
+class Bar6 {
+    actual constructor()
+}
+
+actual class Bar7 actual constructor(s: String) {
+    constructor() : this("")
+}
@@ -0,0 +1,7 @@
+// MODULE: m1-common
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface Base<!>
+
+// MODULE: m1-jvm()()(m1-common)
+actual interface Base {
+    override fun equals(other: Any?): Boolean
+}
@@ -0,0 +1,22 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface Foo {
+    fun foo()
+}
+
+<!NO_ACTUAL_FOR_EXPECT!>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 {
+    abstract fun bar()
+
+    abstract val baz: Int
+
+    abstract override fun foo()
+}<!>
@@ -0,0 +1,32 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// MODULE: m1-common
+// FILE: common.kt
+
+expect fun foo1(x: Int)
+<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo2(x: Int)<!>
+
+expect class NoArgConstructor()
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun foo3(): Int<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo4(): Int<!>
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: jvm.kt
+
+actual fun foo1(x: Int) {}
+
+fun foo1(x: Int, y: Int) {}
+fun foo1(x: String) {}
+
+fun foo2(x: Int, y: Int) {}
+fun foo2(x: String) {}
+
+actual fun <!ACTUAL_WITHOUT_EXPECT!>foo3<!>(): String = ""
+fun foo4(x: Int): String = ""
+
+actual class NoArgConstructor {
+    actual constructor()
+    <!ACTUAL_WITHOUT_EXPECT!>actual constructor(x: Int)<!>
+    constructor(x: String)
+}
@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo1<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo2<!>
+
+expect fun foo2(): Int
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect val s: String<!>
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo3<!>
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: jvm.kt
+
+interface Foo1
+actual interface <!ACTUAL_WITHOUT_EXPECT!>Foo2<!>
+
+actual var <!ACTUAL_WITHOUT_EXPECT!>s<!>: String = "value"
+
+fun foo2(): Int = 0
+
+actual class <!ACTUAL_WITHOUT_EXPECT, PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>
+
+class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>
@@ -0,0 +1,67 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect fun interface F1 {
+    fun run()
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F2 {
+    fun run()
+}<!>
+
+expect fun interface F3 {
+    fun run()
+}
+
+expect interface F4 {
+    fun run()
+}
+
+expect fun interface F5 {
+    fun run()
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F6 {
+    fun run()
+}<!>
+
+expect fun interface F7 {
+    fun run()
+}
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: NotSam.java
+public interface NotSam {
+    void run();
+    void somehtingElse();
+}
+
+// FILE: main.kt
+actual fun interface F1 {
+    actual fun run()
+}
+
+actual interface <!ACTUAL_WITHOUT_EXPECT!>F2<!> {
+    actual fun run()
+}
+
+actual typealias F3 = java.lang.Runnable
+
+actual fun interface F4 {
+    actual fun run()
+}
+
+fun interface F5Typealias {
+    fun run()
+}
+
+actual typealias F5 = F5Typealias
+
+interface F6Typealias {
+    fun run()
+}
+
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>F6<!> = F6Typealias
+
+actual typealias <!ACTUAL_WITHOUT_EXPECT!>F7<!> = NotSam
@@ -0,0 +1,13 @@
+// MODULE: m1-common
+// FILE: common.kt
+<!NO_ACTUAL_FOR_EXPECT!>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 {
+    constructor(i: Int)
+
+    constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>super<!>("B")
+}<!>
@@ -0,0 +1,71 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseA() {
+    abstract fun foo()
+}<!>
+<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA<!>
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class DerivedA1<!> : BaseAImpl()
+class DerivedA2 : BaseAImpl() {
+    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+}
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseB {
+    fun foo()
+}<!>
+<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB<!>
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedB1<!> : BaseBImpl()
+class DerivedB2 : BaseBImpl() {
+    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+}
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseC {
+    fun foo()
+}<!>
+<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseCImpl() : BaseC<!>
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedC1<!> : BaseCImpl()
+class DerivedC2 : BaseCImpl() {
+    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+}
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseD {
+    fun foo()
+}<!>
+abstract class BaseDImpl() : BaseD {
+    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+}
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseE {
+    fun foo()
+}<!>
+sealed class BaseEImpl() : BaseE {
+    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+}
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseF {
+    fun foo()
+}<!>
+<!NO_ACTUAL_FOR_EXPECT!>expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF<!>
+
+
+
+<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseG() {
+    abstract fun foo()
+}<!>
+<!NO_ACTUAL_FOR_EXPECT!>expect open class BaseGImpl() : BaseG {
+    override fun foo()
+}<!>
+class DerivedG1 : BaseGImpl()
@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class C1
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C2<A><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C3<B><!>
+expect interface C4<D, E>
+expect interface C5<F, G>
+expect interface C6<H>
+expect interface C7<I>
+expect interface C8<J>
+expect interface C9<K>
+expect interface C10<L>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+class A<T : A<T>>
+class B<T>
+
+actual typealias C1 = String
+<!ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C2<A> = List<String><!>
+<!ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C3<B> = List<B><!>
+actual typealias C4<D, E> = MutableMap<D, E>
+<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C5<F, G> = MutableMap<G, F><!>
+<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C51 = MutableMap<String, String><!>
+<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C52<F> = MutableMap<F, String><!>
+<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C53<T> = A<A<T>><!>
+<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C54<T> = B<List<String>><!>
+actual typealias C6<H> = MutableList<H>
+<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C7<I> = MutableList<out I><!>
+<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C8<J> = MutableList<*><!>
+<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C9<K> = MutableList<in K><!>
+
+typealias Tmp<K> = MutableList<K>
+<!ACTUAL_TYPE_ALIAS_NOT_TO_CLASS!>actual typealias C10<L> = Tmp<L><!>
@@ -0,0 +1,24 @@
+// IGNORE_REVERSED_RESOLVE
+// MODULE: m1-common
+// FILE: common.kt
+<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+    <!EXPECTED_DECLARATION_WITH_BODY!>init<!> {
+        "no"
+    }
+
+    <!EXPECTED_DECLARATION_WITH_BODY!>constructor(s: String)<!> {
+        "no"
+    }
+
+    constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("no")
+
+    val prop: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
+
+    var getSet: String
+        <!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
+        <!EXPECTED_DECLARATION_WITH_BODY!>set(value)<!> {}
+
+    <!EXPECTED_DECLARATION_WITH_BODY!>fun functionWithBody(x: Int): Int<!> {
+        return x + 1
+    }
+}<!>
@@ -0,0 +1,9 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface A
+
+class B : A
+<!NO_ACTUAL_FOR_EXPECT!>expect class Foo(b: B) : A by b<!>
+
+<!NO_ACTUAL_FOR_EXPECT!>expect class Bar : A by B()<!>
@@ -0,0 +1,30 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+    val justVal: String
+    var justVar: String
+
+    val String.extensionVal: Unit
+    var <T> T.genericExtensionVar: T
+
+    val valWithGet: String
+        get
+    var varWithGetSet: String
+        get set
+
+    val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
+    var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
+
+    val customAccessorVal: String
+    <!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
+    var customAccessorVar: String
+    <!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
+    <!EXPECTED_DECLARATION_WITH_BODY!>set(value)<!> {}
+
+    <!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 = "" }
@@ -0,0 +1,38 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
+    fun publicFun()
+
+    internal fun internalFun1()
+    internal fun internalFun2()
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal fun internalFun3()<!>
+
+    protected fun protectedFun1()
+    protected fun protectedFun2()
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>protected fun protectedFun3()<!>
+
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open internal fun openInternalFun()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openPublicFun()<!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: jvm.kt
+
+actual open class Container {
+    actual fun publicFun() {}               // OK: public -> public
+
+    actual fun internalFun1() {}            // OK: internal -> public
+    actual internal fun internalFun2() {}   // OK: internal -> internal
+
+    actual fun protectedFun1() {}           // OK: protected -> public
+    actual protected fun protectedFun2() {} // OK: protected -> protected
+
+    actual internal fun <!ACTUAL_WITHOUT_EXPECT!>protectedFun3<!>() {}  // BAD: protected -> internal
+    actual protected fun <!ACTUAL_WITHOUT_EXPECT!>internalFun3<!>() {}  // BAD: internal -> protected
+
+    actual open fun <!ACTUAL_WITHOUT_EXPECT!>openInternalFun<!>() {}    // BAD: internal+open -> public
+    actual internal fun <!ACTUAL_WITHOUT_EXPECT!>openPublicFun<!>() {}  // BAD: open+public -> internal
+}
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal open fun internalFun()<!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+
+// FILE: foo/Foo.java
+
+package foo;
+
+public class Foo {
+    public void internalFun() {}
+}
+
+// FILE: jvm.kt
+
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Container<!> = foo.Foo
@@ -0,0 +1,45 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class B {
+    class N {
+        <!EXPECTED_DECLARATION_WITH_BODY!>fun body()<!> {}
+        <!WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
+    }
+}
+
+expect class C {
+    <!WRONG_MODIFIER_TARGET!>expect<!> class N
+    <!WRONG_MODIFIER_TARGET!>expect<!> enum class E
+    <!WRONG_MODIFIER_TARGET!>expect<!> inner class I
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class D {
+    <!NO_ACTUAL_FOR_EXPECT{JVM}!>class N<!>
+}<!>
+
+expect class E {
+    class N
+}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual class B {
+    actual class N {
+        actual fun body() {}
+        actual fun extraHeader() {}
+    }
+}
+
+actual class C {
+    actual class N
+    actual enum class E
+    actual inner class I
+}
+
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>D<!>
+
+actual class E {
+    class N
+}
@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
+    fun bar(): String
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun bas(f: Int)<!>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> {
+    fun bar(): String = "bar"
+    fun bas(g: Int) {}
+}
@@ -0,0 +1,12 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!NO_ACTUAL_FOR_EXPECT!>expect class Foo { // also, it's important that Foo doesn't override equals
+    fun foo()
+}<!>
+
+fun check(x1: Foo, x: Any) {
+    if (x1 == x) {
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
+    }
+}
@@ -0,0 +1,28 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+interface I
+open class C
+interface J
+
+expect class Foo : I, C, J
+
+<!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>expect class Bar : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!><!>
+
+expect class WithExplicitPrimaryConstructor() : C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+actual class Foo : I, C(), J
+
+actual class <!ACTUAL_WITHOUT_EXPECT!>Bar<!>
+
+actual class WithExplicitPrimaryConstructor : C()
+
+// MODULE: m3-js()()(m1-common)
+// FILE: js.kt
+actual class Foo : I, J, C()
+
+actual class Bar : C()
+
+actual class WithExplicitPrimaryConstructor : C()
@@ -0,0 +1,30 @@
+// ISSUE: KT-57369
+
+// MODULE: common
+// TARGET_PLATFORM: Common
+interface CompletionHandler {
+    fun foo()
+}
+
+expect class CompletionHandlerBase()
+
+fun invokeOnCompletion(handler: CompletionHandler) {}
+
+// MODULE: intermediate()()(common)
+// TARGET_PLATFORM: Common
+// actual has an additional super type
+actual class CompletionHandlerBase : CompletionHandler {
+    override fun foo() {}
+}
+
+fun cancelFutureOnCompletionAlt(handlerBase: CompletionHandlerBase) {
+    invokeOnCompletion(handlerBase)
+    handlerBase.foo()
+}
+
+// MODULE: main()()(common, intermediate)
+// the order of dependencies is important to reproduce KT-57369
+fun cancelFutureOnCompletion(handlerBase: CompletionHandlerBase) {
+    invokeOnCompletion(handlerBase)
+    handlerBase.foo()
+}
@@ -0,0 +1,42 @@
+// !LANGUAGE: +MultiPlatformProjects
+
+// MODULE: common
+// TARGET_PLATFORM: Common
+
+// FILE: StringValue.kt
+<!NO_ACTUAL_FOR_EXPECT{JS}!>expect class StringValue<!>
+
+<!NO_ACTUAL_FOR_EXPECT{JS}!>expect fun StringValue.plus(other: String): StringValue<!>
+
+// MODULE: commonJS()()(common)
+// TARGET_PLATFORM: JS
+
+// FILE: StringValueJs.kt
+actual class StringValue(val value: String)
+
+actual fun StringValue.plus(other: String) = StringValue(this.value + other)
+
+// MODULE: intermediate()()(common)
+// TARGET_PLATFORM: Common
+
+// FILE: StringDemoInterface.kt
+expect interface StringDemoInterface
+
+interface KotlinXStringDemoInterface {
+    val value: String
+}
+
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JS}!>expect fun StringDemoInterface.plusK(): String<!>
+
+// MODULE: js()()(common, intermediate)
+// TARGET_PLATFORM: JS
+
+// FILE: StringDemoInterfaceJs.kt
+actual typealias StringDemoInterface = KotlinXStringDemoInterface
+
+actual fun StringDemoInterface.<!ACTUAL_WITHOUT_EXPECT("actual fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible because return type is different:    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
+
+fun box() = StringDemo("O").plusK()
@@ -0,0 +1,15 @@
+// FIR_IDENTICAL
+// WITH_STDLIB
+// MODULE: common
+// TARGET_PLATFORM: Common
+expect annotation class Ann() // No @Retention SOURCE set
+
+@Ann
+expect annotation class CommonVolatile
+
+// MODULE: main()()(common)
+// TARGET_PLATFORM: JVM
+@Retention(AnnotationRetention.SOURCE)
+actual annotation class Ann
+
+actual typealias CommonVolatile = kotlin.jvm.Volatile
@@ -0,0 +1,19 @@
+// This test is for the case when expect annotation is FirAnnotationCall and actual annotation is not FirAnnotationCall
+// MODULE: common
+// TARGET_PLATFORM: Common
+expect annotation class Ann(val p: Int)
+
+@Ann(p = 1)
+expect class Foo
+
+// MODULE: main()()(common)
+// TARGET_PLATFORM: JVM
+// 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<!>
+
+// FILE: FooImpl.java
+@Ann(p = 2)
+public class FooImpl {
+}
@@ -0,0 +1,68 @@
+// IGNORE_REVERSED_RESOLVE
+// MODULE: common
+// TARGET_PLATFORM: Common
+
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>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
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
+}
+
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun commonFun()<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>commonFun<!>() {}
+
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val commonProperty: String<!>
+actual val <!ACTUAL_WITHOUT_EXPECT!>commonProperty<!>: String
+    get() = "hello"
+
+// MODULE: intermediate()()(common)
+// TARGET_PLATFORM: Common
+
+expect class IntermediateClass {
+    fun memberFun()
+    val memberProp: Int
+    class Nested
+    inner class Inner
+}
+actual class <!ACTUAL_WITHOUT_EXPECT!>IntermediateClass<!> {
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
+    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
+}
+
+expect fun intermediateFun()
+actual fun <!ACTUAL_WITHOUT_EXPECT!>intermediateFun<!>() {}
+
+expect val intermediateProperty: String
+actual val <!ACTUAL_WITHOUT_EXPECT!>intermediateProperty<!>: String
+    get() = "hello"
+
+// MODULE: main()()(intermediate)
+
+expect class PlatformClass {
+    fun memberFun()
+    val memberProp: Int
+    class Nested
+    inner class Inner
+}
+actual class <!ACTUAL_WITHOUT_EXPECT!>PlatformClass<!> {
+    actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
+    actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
+    actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
+    actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
+}
+
+expect fun platformFun()
+actual fun <!ACTUAL_WITHOUT_EXPECT!>platformFun<!>() {}
+
+expect val platformProperty: String
+actual val <!ACTUAL_WITHOUT_EXPECT!>platformProperty<!>: String
+    get() = "hello"
@@ -0,0 +1,31 @@
+// MODULE: common
+// TARGET_PLATFORM: Common
+
+expect fun parameterCount()
+fun parameterCount(p: String) {}
+
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun parameterCount2()<!>
+actual fun <!ACTUAL_WITHOUT_EXPECT!>parameterCount2<!>(p: String) {}
+
+expect fun callableKind(): Int
+val callableKind: Int = 1
+
+expect fun <T> typeParameterCount()
+fun typeParameterCount() {}
+
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class EnumEntries {
+    ONE, TWO;
+}<!>
+actual enum class <!ACTUAL_WITHOUT_EXPECT!>EnumEntries<!> {
+    ONE;
+}
+
+expect fun vararg(bar: Int)
+fun vararg(vararg bar: Int) = Unit
+
+// MODULE: main()()(common)
+
+actual fun parameterCount() {}
+actual fun <T> typeParameterCount() {}
+actual fun callableKind(): Int = 1
+actual fun vararg(bar: Int) = Unit
@@ -0,0 +1,15 @@
+// WITH_STDLIB
+// MODULE: m1-common
+// 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> {
+    override val values: MutableCollection<V>
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+import java.util.AbstractMap
+
+public actual abstract class AbstractMutableMap<K, V>() : MutableMap<K, V>, AbstractMap<K, V>()
--- a/Show More
+++ b/Show More