When checking overrides, compare methods structurally

Because they may come from different copies of the same class from different modules

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C<X> : B<X> {
+    override fun foo(a: X)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo("")
+    }
+}

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

@@ -0,0 +1,38 @@
+// !DIAGNOSTICS: -BASE_WITH_NULLABLE_UPPER_BOUND -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B<T> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C<X> : B<X> {
+    override fun foo(a: X?)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait Tr
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo(null)
+    }
+}

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -BASE_WITH_NULLABLE_UPPER_BOUND
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B<T, _> {
+    public fun foo(a: T?)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C<X, _> : B<X, _> {
+    override fun foo(a: X?)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait B<_, 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?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(null)
+    }
+}

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B<T> {
+    public fun foo(a: T)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C<X> : B<X> {
+    override fun foo(a: X)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo(y)
+    }
+}

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

@@ -0,0 +1,36 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B<T> {
+    public fun <R> foo(a: T, b : R)
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B<Any?> {
+    override fun <R> foo(a: Any?, b : R)
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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?.<!CANNOT_COMPLETE_RESOLVE!>foo<!>(1, 1)
+    }
+}

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo(1, "")
+    }
+}

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

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m0
+// FILE: a.kt
+package p
+
+public trait G1<T>
+public trait G2<A, B>
+
+// MODULE: m1(m0)
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun foo(a: G1<Int>?, b: G2<B, String>?)
+}
+
+// MODULE: m2(m1, m0)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun foo(a: G1<Int>?, b: G2<B, String>?)
+
+}
+
+// MODULE: m3(m0)
+// FILE: b.kt
+package p
+
+public trait 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?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(null, null)
+    }
+}

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

@@ -0,0 +1,34 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1, "")
+    }
+}

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

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

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait 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 trait 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.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo<String>("")
+    }
+}
+
+fun test1(b: B?) {
+    if (b is C) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo("")
+    }
+}

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

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait Tr
+
+public trait 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?.<!NONE_APPLICABLE!>foo<!>()
+    }
+}

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

@@ -0,0 +1,52 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun <T> foo(a: T): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun <T> foo(a: T): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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
+    <!DEBUG_INFO_AUTOCAST!>b<!>?.foo("")
+}
+
+fun test1(b: B?) {
+    if (b !is C)  return
+    <!DEBUG_INFO_AUTOCAST!>b<!>?.foo<String>("")
+}

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

@@ -0,0 +1,35 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun foo(a: Int, b: String): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun foo(a: Int, b: String): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo(1, "")
+    }
+}

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

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait 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 trait B {
+    public fun getParent(): B?
+}
+
+// MODULE: m4(m3, m2)
+// FILE: c.kt
+import p.*
+
+fun test(b: B?) {
+    if (b is C) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.getParent()
+    }
+}

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

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
+
+// MODULE: m0
+// FILE: a.kt
+package p
+
+public trait G1<T>
+public trait G2<A, B>
+
+// MODULE: m1(m0)
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun foo(a: G1<Int>, b: G2<B, String>): B?
+}
+
+// MODULE: m2(m1, m0)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun foo(a: G1<Int>, b: G2<B, String>): B?
+
+}
+
+// MODULE: m3(m0)
+// FILE: b.kt
+package p
+
+public trait 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) {
+        <!DEBUG_INFO_AUTOCAST!>b<!>?.foo(a, b1)
+    }
+}

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

@@ -0,0 +1,38 @@
+// MODULE: m1
+// FILE: a.kt
+package p
+
+public trait B {
+    public fun getParent(): B?
+}
+
+// MODULE: m2(m1)
+// FILE: b.kt
+package p
+
+public trait C : B {
+    override fun getParent(): B?
+
+}
+
+// MODULE: m3
+// FILE: b.kt
+package p
+
+public trait B {
+    public fun getParent(): B?
+}
+
+public trait 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?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>getParent<!>()
+    }
+}

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

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