[FIR] Prevent reporting ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT twice in CLI

It is duplicated because we have two checkers: FIR (for IDE support in simple cases) and IR ("honest" checker supporting all cases). Fix this by running FIR checker only in IDE. FIR checker behavior remains covered by tests in `LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated`. ^KT-62559 Fixed
2023-10-20 18:28:41 +02:00
parent a466b14264
commit fcc6f873c7
33 changed files with 97 additions and 80 deletions
@@ -80,6 +80,7 @@ private object CheckersFactory {
        } else {
            createDeclarationCheckers {
                add(CommonDeclarationCheckers)
+                add(CommonIdeOnlyDeclarationCheckers)
                when {
                    platform.isJvm() -> add(JvmDeclarationCheckers)
                    platform.isJs() -> add(JsDeclarationCheckers)
@@ -29,7 +29,6 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
            FirExposedVisibilityDeclarationChecker,
            FirCyclicTypeBoundsChecker,
            FirExpectActualDeclarationChecker,
-            FirActualAnnotationsMatchExpectChecker,
            FirAmbiguousAnonymousTypeChecker,
            FirExplicitApiDeclarationChecker,
            FirAnnotationChecker,
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers
+
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirActualAnnotationsMatchExpectChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
+
+/**
+ * Checkers, which only run in IDE and don't run in CLI mode.
+ */
+object CommonIdeOnlyDeclarationCheckers : DeclarationCheckers() {
+    override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
+        get() = setOf(FirActualAnnotationsMatchExpectChecker)
+}
@@ -21,7 +21,9 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualAnnotationMatchChecker

-// TODO(Roman.Efremov): KT-62559 prevent reporting ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT twice in CLI mode in K2
+/**
+ * This checker runs only in IDE mode. In CLI IR checker runs instead of it.
+ */
 internal object FirActualAnnotationsMatchExpectChecker : FirBasicDeclarationChecker() {
    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
        if (declaration !is FirMemberDeclaration) return
@@ -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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual annotation class 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun onType(): Any? = null<!>
@@ -8,4 +8,4 @@ expect fun explicitDefaultArgument()
 // FILE: jvm.kt
 // No special handling for this case
 <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>explicitDefaultArgument<!>() {}<!>
+actual fun explicitDefaultArgument() {}<!>
@@ -21,14 +21,14 @@ expect fun withEmptyArguments_positive()
 // MODULE: main()()(common)
 // TARGET_PLATFORM: JVM
 actual fun onType_negative(): @Ann("") Any = Any()
-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onType_positive<!>(): @Ann("incorrect") Any = Any()<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun onType_positive(): @Ann("incorrect") Any = Any()<!>

@Ann("")
 actual fun onFunction_negative() {}
 <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann("incorrect")
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onFunction_positive<!>() {}<!>
+actual fun onFunction_positive() {}<!>

@Ann
 actual fun withEmptyArguments_negative() {}
 <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>@Ann("incorrect")
-actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>withEmptyArguments_positive<!>() {}<!>
+actual fun withEmptyArguments_positive() {}<!>
@@ -63,25 +63,25 @@ expect fun explicitVsInfered()
 actual fun sameTypeParam() {}

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

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

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

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

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

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

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

@ComplexNested<A>(
    ComplexNested<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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class OnClass<!>

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

 class ViaTypealiasImpl

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>ViaTypealias<!> = ViaTypealiasImpl<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias 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!>actual typealias MemberScopeViaTypealias = MemberScopeViaTypealiasImpl<!>

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

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

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>inTypeParam<!>() {}<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val onGetter: String = ""<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onType<!>(param: Any) {}<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun foo() {}<!>
        }
    }
 }
@@ -18,11 +18,10 @@ 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<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!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
+actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>StrongIncompatibility<!> = StrongIncompatibilityImpl
@@ -18,7 +18,6 @@ class WeakIncompatibilityImpl {
    fun foo(differentName: String) {}
 }

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

 class StrongIncompatibilityImpl {
@@ -18,7 +18,6 @@ class WeakIncompatibilityImpl {
    fun foo(differentName: String) {}
 }

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

 class StrongIncompatibilityImpl {
@@ -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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun foo(p: Array<Int>) {}<!>
@@ -10,6 +10,6 @@ annotation class Ann

 // 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!>actual enum class <!ACTUAL_WITHOUT_EXPECT!>E<!> {
    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class FakeOverrideActual : Intermediate(), I<!>
@@ -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!>actual val 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val onGetterImplicit: String = ""<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onGetterWithExplicitTarget<!>: String
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual val 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 val setOnPropertyWithoutTargetNotMatch: String = ""<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual var <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>onSetter<!>: String
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual var onSetter: String
    get() = ""
    <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>set(_) {}<!><!>
@@ -29,7 +29,7 @@ actual fun diffentOrder() {}

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

@AnnWithArg(s = "1")
@AnnWithArg(s = "2")
@@ -20,6 +20,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_ANNOTATIONS_NOT_MATCH_EXPECT, ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias SourceAvailable = SourceAvailableImpl<!>

 actual typealias 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias WithAnn = Impl<!>
 actual typealias WithoutAnn = Impl
@@ -17,11 +17,11 @@ expect class TypealiasParamNotAccepted<@Ann A>

 // 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 <A> inMethod() {}<!>

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

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InClass<!><A><!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias TypealiasParamNotAccepted<@Ann A> = TypealiasParamNotAcceptedImpl<A><!>

 actual fun <A> <!ACTUAL_WITHOUT_EXPECT!>withIncompatibility<!>() {}
@@ -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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun valueParameterType(arg: String) {}<!>

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

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

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassTypeParamBound<!><T : Any><!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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> typeParamBoundInWhere() where T : Any {}<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>severalBounds<!>() where T : I1, T : I2 {}<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> 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 fun Any.onReceiver() {}<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>OnClassSuper<!> : I1<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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 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 class 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 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 starProjection(arg: I4<*, Any>) {}<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>typeArgWithVariance<!>(t: I3<out T>) {}<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <T> 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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 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 funcTypeReceiverType(arg: Any.() -> Unit) {}<!>

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>funcTypeArgType<!>(arg: (arg: Any) -> Unit) {}<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual class 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun foo() = 1<!>
@@ -48,28 +48,28 @@ expect class InnerClassInsideTypealias {
 // FILE: jvm.kt
 class KtTypealiasNotMatchImpl

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

 class AnnotationsNotConsideredOnTypealiasImpl

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

 class MethodsInsideTypealiasImpl {
    fun foo() {}
 }

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

 class ValueInsideTypealiasImpl {
    val value: String = ""
 }

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

 class ConstructorInsideTypealiasImpl

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

 class MethodWithComplexAnnInsideTypealiasImpl {
    @ComplexAnn("13")
@@ -84,4 +84,4 @@ class InnerClassInsideTypealiasImpl {
    }
 }

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>InnerClassInsideTypealias<!> = InnerClassInsideTypealiasImpl<!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias InnerClassInsideTypealias = InnerClassInsideTypealiasImpl<!>
@@ -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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias Foo = FooImpl<!>

 // FILE: FooImpl.java
@Ann(p = 2)
@@ -40,4 +40,4 @@ expect abstract class MyAbstractIterator<T> {

 actual typealias MyDeprecatedMatch = kotlin.Deprecated

-<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias <!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>MyAbstractIterator<!><T> = AbstractIterator<T><!>
+<!ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT!>actual typealias MyAbstractIterator<T> = AbstractIterator<T><!>
@@ -11,8 +11,8 @@ expect class InConstructor(@Ann arg: 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun 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) {}
@@ -12,7 +12,7 @@ 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_ANNOTATIONS_NOT_MATCH_EXPECT!>actual fun <!ACTUAL_WITHOUT_EXPECT!>hasWeakIncompatibility<!>() {}<!>

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