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

compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.fir.kt

@@ -0,0 +1,21 @@
+// FILE: f1.kt
+// SKIP_TXT
+
+package kotlin
+
+class Unit
+
+// FILE: f2.kt
+
+class C: MutableIterator<Int> {
+    override fun remove(): Unit {
+        throw UnsupportedOperationException()
+    }
+    override fun next(): Int {
+        throw UnsupportedOperationException()
+    }
+    override fun hasNext(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.fir.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A
+public class M1 {
+    public val a: A = A()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A<T>
+
+public fun foo(a: A<Int>) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    foo(M1().a)
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.fir.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A<T>
+public class M1 {
+    public val a: A<Int> = A<Int>()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A
+
+public fun foo(a: A) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(M1().a)
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.fir.kt

@@ -0,0 +1,32 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A
+public class B {
+    public val a: A = A()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A {
+    val x = 1
+}
+
+public fun foo(a: A) {
+    a.x + 1
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    foo(B().a)
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.fir.kt

@@ -0,0 +1,68 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A {
+    public class B
+    public object C
+    companion object {
+        public class D {
+            public object E
+        }
+        public class G
+    }
+
+    public inner class F
+}
+
+public class M1 {
+    public val a: A = A()
+    public val b: A.B = A.B()
+    public val c: A.C = A.C
+    public val d: A.Companion.D = A.Companion.D()
+    public val e: A.Companion.D.E = A.Companion.D.E
+    public val f: A.F = A().F()
+    public val g: A.Companion.G = A.Companion.G()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A {
+    public class B
+    public class C
+    companion object {
+        public class D {
+            public class E
+        }
+    }
+    public class G
+    public inner class F
+}
+
+public fun a(p: A) {}
+public fun b(p: A.B) {}
+public fun c(p: A.C) {}
+public fun d(p: A.Companion.D) {}
+public fun e(p: A.Companion.D.E) {}
+public fun f(p: A.F) {}
+public fun g(p: A.G) {}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test(m1: M1) {
+    a(m1.a)
+    b(m1.b)
+    c(m1.c)
+    d(m1.d)
+    e(m1.e)
+    f(m1.f)
+    <!INAPPLICABLE_CANDIDATE!>g<!>(m1.g)
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.fir.kt

@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public interface A
+public class B : A
+public class M1 {
+    public val b: B = B()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public interface A
+
+public fun foo(a: A) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    foo(M1().b)
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt

@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A<X, Y>
+public class M1 {
+    public val a: A<Int> = A<Int, Int>()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A<X, Y>
+
+public fun foo(a: A<Int>) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    foo(M1().a)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1) // error type on the declaration site
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.fir.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public interface A<T>
+public interface C
+public interface D<T>
+public class B : A<Int>, C, D<Int>
+public class M1 {
+    public val b: B = B()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public interface A
+public interface C<T>
+public interface D<T>
+
+public fun a(a: A) {
+}
+
+public fun c(c: C<Int>) {
+}
+
+public fun d(d: D<Int>) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>a<!>(M1().b) // Type arguments do not match
+    c(M1().b) // Type arguments do not match
+    d(M1().b) // Type arguments do match
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.fir.kt

@@ -0,0 +1,23 @@
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A
+public class B {
+    public val a: A = A()
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+package p
+
+class A {
+    fun foo() {}
+}
+
+fun test() {
+    val a: A = B().a
+    a.foo()
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.fir.kt

@@ -0,0 +1,23 @@
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A
+public class B {
+    public val a: A = A()
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+package p
+
+class A {
+    fun foo() {}
+}
+
+fun test() {
+    val a = B().a
+    a.foo()
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.fir.kt

@@ -0,0 +1,38 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A {
+    public fun m1() {}
+}
+public class M1 {
+    public val a: A = A()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A {
+    public fun m2() {}
+}
+
+public class M2 {
+    public val a: A = A()
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test(a: A) {
+    a.m1()
+
+    M1().a.m1()
+
+    M2().a.<!UNRESOLVED_REFERENCE!>m2<!>()
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.fir.kt

@@ -0,0 +1,22 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A
+public class B {
+    public val a: A = A()
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+import p.*
+
+class A
+
+fun test() {
+    val a: A = B().a
+}

compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.fir.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A<T>
+public class M1 {
+    public val a: A<Int> = A()
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public class A<T>
+
+public fun foo(a: A<Int>) {
+}
+
+// MODULE: m3(m1, m2)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    foo(M1().a)
+}

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("")
+    }
+}

compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.fir.kt

@@ -0,0 +1,31 @@
+// MODULE: m1
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun foo() {}
+}
+
+public interface A : Base {
+    override fun foo() {}
+}
+
+public interface C : A
+
+
+// MODULE: m2
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun foo() {}
+}
+
+public interface B : Base
+
+// MODULE: m3(m1, m2)
+// FILE: x.kt
+
+import p.*
+
+class Foo: C, B

compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.fir.kt

@@ -0,0 +1,26 @@
+// MODULE: m1
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun foo() {}
+}
+
+public interface A : Base
+
+// MODULE: m2
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun foo() {}
+}
+
+public interface B : Base
+
+// MODULE: m3(m1, m2)
+// FILE: x.kt
+
+import p.*
+
+class Foo: A, B

compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.fir.kt

@@ -0,0 +1,29 @@
+// MODULE: m1
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun <T> foo(t: Array<T>) {}
+}
+
+public interface A : Base
+
+// MODULE: m2
+// FILE: x.kt
+package p
+
+public interface Base {
+    public fun <T: Base> foo(t: Array<T>) {}
+}
+
+public interface B : Base
+
+// MODULE: m3(m1, m2)
+// FILE: x.kt
+
+import p.*
+
+class Foo: A, B {
+    override fun <T> foo(t: Array<T>) {}
+    override fun <T: Base> foo(t: Array<T>) {}
+}

compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.fir.kt

@@ -0,0 +1,26 @@
+// MODULE: m1
+// FILE: x.kt
+package p
+
+public interface Base<T> {
+    public fun foo(t: T) {}
+}
+
+public interface A<T> : Base<T>
+
+// MODULE: m2
+// FILE: x.kt
+package p
+
+public interface Base<T> {
+    public fun foo(t: T) {}
+}
+
+public interface B : Base<String>
+
+// MODULE: m3(m1, m2)
+// FILE: x.kt
+
+import p.*
+
+class Foo: A<String>, B

compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.fir.kt

@@ -0,0 +1,37 @@
+// MODULE: m1
+// FILE: a.kt
+
+package p1
+
+@Deprecated("Use p2.A instead", level = DeprecationLevel.HIDDEN)
+class A {
+    fun m1() {}
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p2
+
+class A {
+    fun m2() {}
+}
+
+// MODULE: m3(m1, m2)
+// FILE: severalStarImports.kt
+import p1.*
+import p2.*
+
+fun test(a: A) {
+    a.m1()
+    a.<!UNRESOLVED_REFERENCE!>m2<!>()
+}
+
+// FILE: explicitlyImportP1.kt
+import p1.A
+import p2.*
+
+fun test(a: A) {
+    a.m1()
+    a.<!UNRESOLVED_REFERENCE!>m2<!>()
+}

compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.fir.kt

@@ -0,0 +1,46 @@
+// MODULE: m1
+// FILE: a.kt
+
+package p1
+
+@Deprecated("1", level = DeprecationLevel.HIDDEN)
+class A(val v1: Unit)
+
+// MODULE: m2
+// FILE: b.kt
+
+package p2
+
+@Deprecated("2", level = DeprecationLevel.HIDDEN)
+class A(val v2: Unit)
+
+// MODULE: m3
+// FILE: c.kt
+
+package p3
+
+@Deprecated("3", level = DeprecationLevel.HIDDEN)
+class A(val v3: Unit)
+
+// MODULE: m4(m1, m2, m3)
+// FILE: oneExplicitImportOtherStars.kt
+import p1.*
+import p2.A
+import p3.*
+
+fun test(a: A) {
+    a.<!UNRESOLVED_REFERENCE!>v1<!>
+    a.v2
+    a.<!UNRESOLVED_REFERENCE!>v3<!>
+}
+
+// FILE: severalStarImports.kt
+import p1.*
+import p2.*
+import p3.*
+
+fun test(a: A) {
+    a.v1
+    a.<!UNRESOLVED_REFERENCE!>v2<!>
+    a.<!UNRESOLVED_REFERENCE!>v3<!>
+}

compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.fir.kt

@@ -0,0 +1,38 @@
+// !API_VERSION: 1.0
+// MODULE: m1
+// FILE: a.kt
+
+package p1
+
+@SinceKotlin("1.1")
+class A {
+    fun m1() {}
+}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p2
+
+class A {
+    fun m2() {}
+}
+
+// MODULE: m3(m1, m2)
+// FILE: severalStarImports.kt
+import p1.*
+import p2.*
+
+fun test(a: A) {
+    a.m1()
+    a.<!UNRESOLVED_REFERENCE!>m2<!>()
+}
+
+// FILE: explicitlyImportP1.kt
+import p1.A
+import p2.*
+
+fun test(a: A) {
+    a.m1()
+    a.<!UNRESOLVED_REFERENCE!>m2<!>()
+}

compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.fir.kt

@@ -0,0 +1,47 @@
+// !API_VERSION: 1.0
+// MODULE: m1
+// FILE: a.kt
+
+package p1
+
+@SinceKotlin("1.1")
+class A(val v1: Unit)
+
+// MODULE: m2
+// FILE: b.kt
+
+package p2
+
+@SinceKotlin("1.1")
+class A(val v2: Unit)
+
+// MODULE: m3
+// FILE: c.kt
+
+package p3
+
+@SinceKotlin("1.1")
+class A(val v3: Unit)
+
+// MODULE: m4(m1, m2, m3)
+// FILE: oneExplicitImportOtherStars.kt
+import p1.*
+import p2.A
+import p3.*
+
+fun test(a: A) {
+    a.<!UNRESOLVED_REFERENCE!>v1<!>
+    a.v2
+    a.<!UNRESOLVED_REFERENCE!>v3<!>
+}
+
+// FILE: severalStarImports.kt
+import p1.*
+import p2.*
+import p3.*
+
+fun test(a: A) {
+    a.v1
+    a.<!UNRESOLVED_REFERENCE!>v2<!>
+    a.<!UNRESOLVED_REFERENCE!>v3<!>
+}

compiler/testData/diagnostics/tests/multimodule/internal.fir.kt

@@ -0,0 +1,35 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A {
+    internal val a = A()
+    internal var v = A()
+    internal fun a() = A()
+    internal inner class B
+}
+
+internal val a = A()
+internal var v = A()
+internal fun a() = A()
+internal class B
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
+    val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
+    <!INAPPLICABLE_CANDIDATE!>a<!>()
+    <!INAPPLICABLE_CANDIDATE!>B<!>()
+
+    val inst = A()
+    val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
+    val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
+    inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
+    inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
+}

compiler/testData/diagnostics/tests/multimodule/kt14249.fir.kt

@@ -0,0 +1,20 @@
+// MODULE: m1
+// FILE: test/Foo.java
+
+package test;
+
+class Foo {
+    static Foo create() { return Foo(); }
+    void takeFoo(Foo f) {}
+}
+
+// MODULE: m2(m1)
+// FILE: test.kt
+
+package test
+
+fun test() {
+    Foo()
+    val a: Foo = Foo.create()
+    Foo().takeFoo(a)
+}

compiler/testData/diagnostics/tests/multimodule/packagePrivate.fir.kt

@@ -0,0 +1,19 @@
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+private val a = 1
+
+// FILE: b.kt
+
+package p
+
+val b = <!INAPPLICABLE_CANDIDATE!>a<!> // same package, same module
+
+// MODULE: m2(m1)
+// FILE: c.kt
+
+package p
+
+val c = <!INAPPLICABLE_CANDIDATE!>a<!> // same package, another module

compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.fir.kt

@@ -0,0 +1,56 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public class A {
+    @PublishedApi
+    internal val a = A()
+    @PublishedApi
+    internal var v = A()
+    @PublishedApi
+    internal fun a() = A()
+    @PublishedApi
+    internal inner class B
+}
+
+@PublishedApi
+internal val a = A()
+@PublishedApi
+internal var v = A()
+@PublishedApi
+internal fun a() = A()
+@PublishedApi
+internal class B
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+import p.*
+
+fun test() {
+    val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
+    val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
+    <!INAPPLICABLE_CANDIDATE!>a<!>()
+    <!INAPPLICABLE_CANDIDATE!>B<!>()
+
+    val inst = A()
+    val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
+    val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
+    inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
+    inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
+}
+
+inline fun testInline() {
+    val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
+    val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
+    <!INAPPLICABLE_CANDIDATE!>a<!>()
+    <!INAPPLICABLE_CANDIDATE!>B<!>()
+
+    val inst = A()
+    val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
+    val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
+    inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
+    inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
+}

compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.fir.kt

@@ -0,0 +1,45 @@
+// MODULE: m1
+// FILE: a.kt
+
+package test
+
+enum class E {
+    FIRST
+}
+
+sealed class S
+
+class Derived : S()
+
+// MODULE: m2(m1)
+// FILE: b.kt
+
+package other
+
+import test.*
+
+fun foo(e: E) = when (e) {
+    E.FIRST -> 42
+    else -> -42
+}
+
+fun bar(s: S?) = when (s) {
+    is Derived -> "Derived"
+    null -> ""
+    else -> TODO("What?!?!")
+}
+
+fun baz(b: Boolean?) = when (b) {
+    true -> 1
+    false -> 0
+    null -> -1
+    // Still warning
+    else -> TODO()
+}
+
+fun baz(b: Boolean) = when (b) {
+    true -> 1
+    false -> 0
+    // Still warning
+    else -> TODO()
+}

compiler/testData/diagnostics/tests/multimodule/varargConflict.fir.kt

@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public fun foo(a: Int) {}
+public fun foo(vararg values: Int) {}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public fun foo(a: Int) {}
+public fun foo(vararg values: Int) {}
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+package m
+
+import p.foo
+
+fun main() {
+    foo(12)
+}