[FIR-TEST] Add new testdata generated after changes in previous commit

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C<X> : B<X> {
+    override fun foo(a: X)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B<String>?) {
+    if (b is C) {
+        b?.foo("")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.fir.kt

@@ -0,0 +1,38 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C<X> : B<X> {
+    override fun foo(a: X?)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface Tr
+
+public interface B<T: Tr?> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B<Tr>?) {
+    if (b is C) {
+        b?.<!AMBIGUITY!>foo<!>(null)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.fir.kt

@@ -0,0 +1,34 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T, Z> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C<X, Z> : B<X, Z> {
+    override fun foo(a: X?)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B<Z, T> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun <Y, Z> test(b: B<Y, Z>?) {
+    if (b is C<Y, Z>) {
+        b?.foo(null)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C<X> : B<X> {
+    override fun foo(a: X)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B<T1> {
+    public fun foo(a: T1)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun <Y> test(b: B<Y>?, y: Y) {
+    if (b is C) {
+        b?.foo(y)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun foo(): T
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C<X> : B<X> {
+    override fun foo(): X
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B<T> {
+    public fun foo(): T
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B<String>?) {
+    if (b is C) {
+        b?.<!AMBIGUITY!>foo<!>()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt

@@ -0,0 +1,37 @@
+// !WITH_NEW_INFERENCE
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun <R> foo(a: T, b : R)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B<Any?> {
+    override fun <R> foo(a: Any?, b : R)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun <T, R> foo(a: T, b: R)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?, c: C) {
+    b?.foo(1, 1)
+    c.foo(1, 1)
+    if (b is C) {
+        b?.foo(1, 1)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun getParent(): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun getParent(): Any?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.getParent()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a1: Int, b1: String): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo(1, "")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.fir.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m0
+// FILE: a.kt
+package p
+
+public interface G1<T>
+public interface G2<A, B>
+
+// MODULE: m1(m0)
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun foo(a: G1<Int>?, b: G2<B, String>?)
+}
+
+// MODULE: m2(m1, m0)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun foo(a: G1<Int>?, b: G2<B, String>?)
+
+}
+
+// MODULE: m3(m0)
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a: G1<out Any?>?, b: G2<Int, out Any?>?)
+}
+
+// MODULE: m4(m3, m2, m0)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo(null, null)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.fir.kt

@@ -0,0 +1,34 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a: Int, b: String, c: Int = 0): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo(1, "")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun getParent(): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun getParent(): Int
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.getParent()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun String.getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public class C : B {
+    override fun String.getParent(): B? = null
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun String.getParent(): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun B.test() {
+    if (this is C) {
+        "".getParent()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.fir.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo<String>("")
+    }
+}
+
+fun test1(b: B?) {
+    if (b is C) {
+        b?.foo("")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.fir.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface Tr
+
+public interface B {
+    public fun <T: Tr?> foo(a: T): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        // hard to find parameters for an ambiguous call, so we rely on NONE_APPLICABLE here
+        // as opposed to diagnostics for a single unmatched candidate
+        b?.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.fir.kt

@@ -0,0 +1,52 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b == null) return
+    b?.foo<String>("")
+}
+
+fun test1(b: B?) {
+    if (b != null) {
+        b?.foo<String>("")
+    }
+}
+
+fun test2(b: B?) {
+    if (b == null) return
+    b?.foo("")
+}
+
+fun test3(b: B?) {
+    if (b != null) {
+        b?.foo("")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.fir.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b !is C)  return
+    b?.foo("")
+}
+
+fun test1(b: B?) {
+    if (b !is C)  return
+    b?.foo<String>("")
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.fir.kt

@@ -0,0 +1,44 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface Foo<T>
+
+public interface B {
+    public fun <T> foo(a: T): Foo<T>
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): Foo<T>
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface Foo<T>
+
+public interface B {
+    public fun <T> foo(a: T): Foo<T>
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b !is C)  return
+    b?.foo("")
+}
+
+fun test1(b: B?) {
+    if (b !is C)  return
+    b?.foo<String>("")
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.fir.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): T
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun <T> foo(a: T): T
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun <T> foo(a: T): T
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b !is C)  return
+    b?.foo("")
+}
+
+fun test1(b: B?) {
+    if (b !is C)  return
+    b?.foo<String>("")
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.fir.kt

@@ -0,0 +1,20 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+fun f(s: String, t: String) = s + t
+
+// MODULE: m2
+// FILE: b.kt
+package p
+
+fun f(s: String, t: String) = t + s
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+import p.f
+
+fun test() {
+    // There should be no "none applicable" error here
+    <!INAPPLICABLE_CANDIDATE!>f<!>(
+<!SYNTAX!><!>}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.fir.kt

@@ -0,0 +1,35 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo(1, "")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public class C : B {
+    override fun getParent(): B? = null
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.getParent()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.fir.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m0
+// FILE: a.kt
+package p
+
+public interface G1<T>
+public interface G2<A, B>
+
+// MODULE: m1(m0)
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun foo(a: G1<Int>, b: G2<B, String>): B?
+}
+
+// MODULE: m2(m1, m0)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun foo(a: G1<Int>, b: G2<B, String>): B?
+
+}
+
+// MODULE: m3(m0)
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a: G1<Int>, b: G2<B, String>): B?
+}
+
+// MODULE: m4(m3, m2, m0)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?, a: G1<Int>, b1: G2<B, String>) {
+    if (b is C) {
+        b?.foo(a, b1)
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.fir.kt

@@ -0,0 +1,38 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B {
+    override fun getParent(): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun getParent(): B?
+}
+
+public interface D : B {
+    override fun getParent(): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C && b is D) {
+        b?.<!AMBIGUITY!>getParent<!>()
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.fir.kt

@@ -0,0 +1,34 @@
+// !API_VERSION: 1.0
+// MODULE: m1
+// FILE: a.kt
+
+package p1
+
+@SinceKotlin("1.1")
+fun foo(s: Int): String = s.toString()
+
+// MODULE: m2
+// FILE: b.kt
+
+package p2
+
+fun foo(s: Int): Int = s
+
+// MODULE: m3(m1, m2)
+// FILE: severalStarImports.kt
+import p1.*
+import p2.*
+
+fun test1(): Int {
+    val r = <!AMBIGUITY!>foo<!>(42)
+    return r
+}
+
+// FILE: explicitlyImportP1.kt
+import p1.foo  // TODO: consider reporting API_NOT_AVAILABLE here
+import p2.*
+
+fun test2(): Int {
+    val r = foo(42)
+    return r
+}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.fir.kt

@@ -0,0 +1,34 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public interface B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public interface C : B<String> {
+    override fun foo(a: String)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public interface B {
+    public fun foo(a: String)
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        b?.foo("")
+    }
+}