[IR] Use common expect/actual matching algorithm in IR actualizer

^KT-58578 Fixed
2023-06-06 17:27:03 +03:00
parent 62534f43c9
commit ba41e8ec38
52 changed files with 1130 additions and 440 deletions
@@ -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)
+}
+
+<!INCOMPATIBLE_MATCHING{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 A = AImpl<!>
+
+class BImpl {
+    fun foo(s: String = "impl") {}
+}
+
+actual typealias 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<!>
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
 // MODULE: m1-common
 // FILE: common.kt
@@ -0,0 +1,34 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect enum class Foo {
+    ENTRY
+}<!>
+
+expect enum class _TimeUnit
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual typealias Foo = FooImpl
+
+actual typealias _TimeUnit = java.util.concurrent.TimeUnit
+
+// FILE: FooImpl.java
+
+public enum FooImpl {
+    ENTRY("OK") {
+        @Override
+        public String getResult() {
+            return value;
+        }
+    };
+
+    protected final String value;
+
+    public FooImpl(String value) {
+        this.value = value;
+    }
+
+    public abstract String getResult();
+}
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt

@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect enum class Foo {
+    ENTRY1,
+    ENTRY2,
+    ENTRY3;
+}<!>
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual enum class Foo(val x: String) {
+    ENTRY1("1"),
+    ENTRY2("2"),
+    ENTRY3("3");
+}
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt

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

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

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

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

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

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

-expect class Bar1()
-expect class Bar2()
-expect class Bar3()
+<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar1<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar2<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar3<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
 expect class Bar4()
 expect class Bar5()
 expect class Bar6()
@@ -3,12 +3,12 @@
 // FILE: common.kt

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

 expect class NoArgConstructor()

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

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

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

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

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

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

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

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class C1
+<!INCOMPATIBLE_MATCHING{JVM}!>expect interface C2<A><!>
+<!INCOMPATIBLE_MATCHING{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><!>
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
 // MODULE: m1-common
 // FILE: common.kt
@@ -2,20 +2,20 @@
 // MODULE: m1-common
 // FILE: common.kt

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

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

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

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

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

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

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

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

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

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

 expect class Foo : I, C, J

-<!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>expect class Bar : C()<!>
+<!INCOMPATIBLE_MATCHING{JVM}, SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>expect class Bar : C()<!>

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

 class Foo {
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY, NO_ACTUAL_FOR_EXPECT{JVM}!><!WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
+    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
 }

 // MODULE: m1-jvm()()(m1-common)
@@ -26,7 +26,7 @@ interface KotlinXStringDemoInterface {
    val value: String
 }

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

 // MODULE: js()()(common, intermediate)
 // TARGET_PLATFORM: JS
@@ -34,7 +34,7 @@ expect fun StringDemoInterface.plusK(): String
 // FILE: StringDemoInterface.kt
 actual typealias StringDemoInterface = KotlinXStringDemoInterface

-<!ACTUAL_WITHOUT_EXPECT("actual  fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>actual fun StringDemoInterface.plusK() = <!RESOLUTION_TO_CLASSIFIER!>StringValue<!>(value).plus("K").<!UNRESOLVED_REFERENCE!>value<!><!>
+<!ACTUAL_WITHOUT_EXPECT("actual  fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.plusK() = <!RESOLUTION_TO_CLASSIFIER!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!><!>

 // FILE: main.kt
 class StringDemo(override val value: String) : StringDemoInterface
@@ -3,10 +3,10 @@
 // TARGET_PLATFORM: Common

 <!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class CommonClass {
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun memberFun()<!>
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>val memberProp: Int<!>
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>class Nested<!>
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>inner class Inner<!>
+    fun memberFun()
+    val memberProp: Int
+    class Nested
+    inner class Inner
 }<!>
 <!ACTUAL_WITHOUT_EXPECT!>actual class CommonClass {
    <!ACTUAL_WITHOUT_EXPECT!>actual fun memberFun() {}<!>
@@ -13,8 +13,8 @@ val callableKind: Int = 1
 expect fun <T> typeParameterCount()
 fun typeParameterCount() {}

-<!NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class EnumEntries {
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>ONE,<!> <!NO_ACTUAL_FOR_EXPECT{JVM}!>TWO;<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class EnumEntries {
+    ONE, TWO;
 }<!>
 <!ACTUAL_WITHOUT_EXPECT!>actual enum class EnumEntries {
    ONE;
@@ -1,31 +0,0 @@
-// MODULE: m1-common
-// FILE: common.kt
-
-expect class Foo {
-    constructor(p: Any)
-
-    fun f1(s: String): Int
-
-    <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun f2(s: List<String>?): MutableMap<Boolean?, Foo><!>
-
-    fun <T : Set<Number>> f3(t: T): T?
-}
-
-// MODULE: m2-jvm()()(m1-common)
-// FILE: FooImpl.java
-
-import java.util.*;
-
-public class FooImpl {
-    public FooImpl(Object p) {}
-
-    public final int f1(String s) { return 0; }
-
-    public final Map<Boolean, FooImpl> f2(List<String> s) { return null; }
-
-    public final <T extends Set<Number>> T f3(T t) { return null; }
-}
-
-// FILE: jvm.kt
-
-actual typealias Foo = FooImpl
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt

@@ -1,8 +1,8 @@
 // MODULE: m1-common
 // FILE: common.kt
-expect class SomeClass<T> {
+<!INCOMPATIBLE_MATCHING{JVM}!>expect class SomeClass<T> {
    fun foo()
-}
+}<!>

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

-inline expect fun inlineFun()
+<!INCOMPATIBLE_MATCHING{JVM}!>inline expect fun inlineFun()<!>
 expect fun nonInlineFun()

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

 expect fun f1(s: () -> String)
-expect inline fun f2(s: () -> String)
+<!INCOMPATIBLE_MATCHING{JVM}!>expect inline fun f2(s: () -> String)<!>
 expect inline fun f3(noinline s: () -> String)

 expect fun f4(s: () -> String)
-expect inline fun f5(s: () -> String)
+<!INCOMPATIBLE_MATCHING{JVM}!>expect inline fun f5(s: () -> String)<!>
 expect inline fun f6(crossinline s: () -> String)

-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun f7(x: Any)<!>
-<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun f8(vararg x: Any)<!>
+<!INCOMPATIBLE_MATCHING{JVM}!>expect fun f7(x: Any)<!>
+<!INCOMPATIBLE_MATCHING{JVM}!>expect fun f8(vararg x: Any)<!>

 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt
@@ -1,20 +1,20 @@
 // MODULE: m1-common
 // FILE: common.kt
-expect var v1: Boolean
+<!INCOMPATIBLE_MATCHING{JVM}!>expect var v1: Boolean<!>

 expect var v2: Boolean
    internal set

-expect var v3: Boolean
-    internal set
+<!INCOMPATIBLE_MATCHING{JVM}!>expect var v3: Boolean
+    internal set<!>

-expect open class C {
-    var foo: Boolean
-}
+<!INCOMPATIBLE_MATCHING{JVM}!>expect open class C {
+    <!INCOMPATIBLE_MATCHING{JVM}!>var foo: Boolean<!>
+}<!>

-expect open class C2 {
-    var foo: Boolean
-}
+<!INCOMPATIBLE_MATCHING{JVM}!>expect open class C2 {
+    <!INCOMPATIBLE_MATCHING{JVM}!>var foo: Boolean<!>
+}<!>

 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt