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

compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun <T1> foo(x: T1, f: (T1) -> T1) = X1
+fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2
+
+val test: X2 = <!AMBIGUITY!>foo<!>({ 0 }, { it -> it + 1 })

compiler/testData/diagnostics/tests/resolve/overloadConflicts/extensionReceiverAndVarargs.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+interface IA
+interface IB : IA
+fun IA.foo(vararg x: Int) = Wrong
+fun IB.foo(vararg x: Int) = Right
+class CC : IB
+
+val test7 = CC().foo(1, 2, 3)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+interface A<T> {
+    fun foo(x: T)
+    fun foo(x: String)
+
+    fun <E> baz(x: E, y: String)
+    fun <E> baz(x: String, y: E)
+}
+
+fun <E> baz(x: E, y: String) {}
+fun <E> baz(x: String, y: E) {}
+
+fun bar(x: A<String>) {
+    x.<!AMBIGUITY!>foo<!>("")
+
+    x.<!AMBIGUITY!>baz<!>("", "")
+    <!AMBIGUITY!>baz<!>("", "")
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -REDUNDANT_PROJECTION
+
+class In<in T>() {
+    fun f(t : T) {}
+    fun f(t : Int) = t
+}
+
+fun test1(x: In<String>): Unit = x.f("1")
+fun test2(x: In<in String>): Unit = x.f("1")
+fun test3(x: In<out String>): Unit = x.f("1")
+fun test4(x: In<*>): Unit = x.f("1")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.fir.kt

@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+interface A<T>
+interface B<T> : A<T>
+
+fun <T> foo(vararg t: T) = Wrong
+fun <T> foo(t: A<T>) = Wrong
+fun <T> foo(t: B<T>) = Right
+
+fun test(b: B<Int>): Right = foo(b)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+interface AutoCloseable
+interface Closeable : AutoCloseable
+
+fun <T1 : AutoCloseable, R1> T1.myUse(f: (T1) -> R1): R1 = f(this)
+fun <T2 : Closeable, R2> T2.myUse(f: (T2) -> R2): R2 = f(this)
+
+fun test1(x: Closeable) = x.myUse { 42 }
+fun test2(x: Closeable) = x.myUse<Closeable, Int> { 42 }
+fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt

@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+
+open class A<T>(val value: T)
+class B<T>(value: T) : A<T>(value)
+
+fun <T> A<T>.foo(block: (T?) -> Unit) {
+    block(value)
+}
+fun <T> B<T>.foo(block: (T) -> Unit) {
+    block(value)
+}
+
+fun main() {
+    B("string").<!AMBIGUITY!>foo<!> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670_compat.fir.kt

@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+
+open class A<T>(val value: T)
+class B<T>(value: T) : A<T>(value)
+
+fun <T> A<T>.foo(block: (T?) -> Unit) {
+    block(value)
+}
+fun <T> B<T>.foo(block: (T) -> Unit) {
+    block(value)
+}
+
+fun main() {
+    B("string").<!AMBIGUITY!>foo<!> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt

@@ -0,0 +1,26 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+enum class A { A1 }
+
+fun <T : Enum<T>> foo(arg: T.() -> Unit) = 1
+
+// FILE: b.kt
+
+package b
+
+fun <T : Any> foo(arg: T.() -> Unit) = 2
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun test() {
+    <!AMBIGUITY!>foo<!><A> { }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758_compat.fir.kt

@@ -0,0 +1,26 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+enum class A { A1 }
+
+fun <T : Enum<T>> foo(arg: T.() -> Unit) = 1
+
+// FILE: b.kt
+
+package b
+
+fun <T : Any> foo(arg: T.() -> Unit) = 2
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun test() {
+    <!AMBIGUITY!>foo<!><A> { }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun(c: Any = "", b: String = "", f: Any = "") = Right
+fun overloadedFun(b: Any = "", c: Any = "", e: String = "", x: String = "", y: String = "") = Wrong
+
+val test: Right = overloadedFun(b = "")
+

compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.fir.kt

@@ -0,0 +1,21 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
+fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong
+
+val test1: Right = overloadedFun1(b = "")
+val test1a: Wrong = overloadedFun1(b = "")
+
+fun overloadedFun2(a: String, b: Any = "") = Right
+fun overloadedFun2(a: Any, b: String = "") = Wrong
+
+val test2: Right = overloadedFun2("")
+
+fun overloadedFun2a(a: Any, b: String = "") = Wrong
+fun overloadedFun2a(a: String, b: Any = "") = Right
+
+val test2a: Right = overloadedFun2a("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt

@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+fun <T> foo(block: (T?) -> Unit) {}
+
+// FILE: b.kt
+
+package b
+
+fun <K> foo(block: (K) -> Unit) {}
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun main() {
+    foo<String> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter_compat.fir.kt

@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+fun <T> foo(block: (T?) -> Unit) {}
+
+// FILE: b.kt
+
+package b
+
+fun <K> foo(block: (K) -> Unit) {}
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun main() {
+    foo<String> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargWithMoreSpecificSignature.fir.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Foo1
+object Foo2
+
+fun foo(vararg ss: String) = Foo1
+fun foo(x: Any) = Foo2
+
+val test1: Foo1 = foo("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargs.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun6(s1: String) = Right
+fun overloadedFun6(s1: String, s2: String) = Wrong
+fun overloadedFun6(s1: String, s2: String, s3: String) = Wrong
+fun overloadedFun6(s: String, vararg ss: String) = Wrong
+
+val test6: Right = overloadedFun6("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsInDifferentPositions.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun overloadedFun(arg: String, vararg args: String) = X1
+fun overloadedFun(arg: String, vararg args: String, flag: Boolean = true) = X2
+
+val test1a: X1 = overloadedFun("", "")
+val test1b: X1 = overloadedFun("", args = "")
+val test1c: X2 = overloadedFun("", "", "", flag = true)
+

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun overloadedFun5(vararg ss: String) = X1
+fun overloadedFun5(s: String, vararg ss: String) = X2
+
+val test1 = overloadedFun5("")
+val test2 = overloadedFun5("", "")
+val test3: X2 = overloadedFun5(s = "", ss = "")
+val test4: X1 = overloadedFun5(ss = "")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.fir.kt

@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: J.java
+import java.util.*;
+
+public class J {
+    public static <E1 extends Enum<E1>> String foo(E1 e) { return ""; }
+    public static <E2 extends Enum<E2>> String foo(E2 e1, E2 e2) { return ""; }
+    public static <E3 extends Enum<E3>> String foo(E3 s1, E3 s2, E3 s3) { return ""; }
+    public static <E4 extends Enum<E4>> int foo(E4... ss) { return 0; }
+}
+
+// FILE: test.kt
+enum class X { A }
+val a = X.A
+
+val test0: Int = J.foo<X>()
+val test1: String = J.foo(a)
+val test2: String = J.foo(a, a)
+val test3: String = J.foo(a, a, a)
+val test4: Int = J.foo(a, a, a, a)
+val test5: Int = J.foo(a, a, a, a, a)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+object X1
+object X2
+
+class A<T>
+
+fun <T1> A<T1>.foo() = X1
+fun <T2> A<out T2>.foo() = X2
+
+fun <T> A<out T>.test() = foo() // TODO fix constraint system