[NI] Resolve callable reference eagerly if there is only one candidate

#KT-30737 Fixed

compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt

@@ -14,7 +14,7 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
 
 fun test() {
     takeFun<String>(::foo)
-    takeFun<String>(<!NI;TYPE_MISMATCH!>::<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>fooInt<!><!>)
+    takeFun<String>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>::<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>fooInt<!><!>)
 
     callFun<String, Wrapper<String>>(::createWrapper)
     callFun<Int, Wrapper<Number>>(::createWrapper)

compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt

@@ -0,0 +1,11 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(x: Int) {}
+fun foo(y: String) {}
+
+fun <T> bar(f: (T) -> Unit) {}
+
+fun test() {
+    bar(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
+}

compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.txt

@@ -0,0 +1,6 @@
+package
+
+public fun </*0*/ T> bar(/*0*/ f: (T) -> kotlin.Unit): kotlin.Unit
+public fun foo(/*0*/ x: kotlin.Int): kotlin.Unit
+public fun foo(/*0*/ y: kotlin.String): kotlin.Unit
+public fun test(): kotlin.Unit

compiler/testData/diagnostics/tests/callableReference/resolve/applicableCallableReferenceFromDistantScope.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+fun foo(s: String) {}
+
+object Scope {
+    fun foo(a: Int) {}
+    fun foo(b: Boolean) {}
+
+    fun <T> bar(f: (T) -> Unit): T = TODO()
+
+    fun test() {
+        val s: String = bar(::foo)
+    }
+}

compiler/testData/diagnostics/tests/callableReference/resolve/applicableCallableReferenceFromDistantScope.txt

@@ -0,0 +1,14 @@
+package
+
+public fun foo(/*0*/ s: kotlin.String): kotlin.Unit
+
+public object Scope {
+    private constructor Scope()
+    public final fun </*0*/ T> bar(/*0*/ f: (T) -> kotlin.Unit): T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ b: kotlin.Boolean): kotlin.Unit
+    public final fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun test(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
+
+class A {
+    fun foo(i: A) {}
+
+    fun baz(i: A) {}
+}
+
+class B {
+    fun foo(s: B) {}
+    fun foo(c: Char) {}
+
+    fun baz(s: B) {}
+}
+
+fun <T> bar(f: (T) -> Unit): T = TODO()
+
+fun test() {
+    myWith(A()) {
+        val t1 = bar(::foo)
+        <!DEBUG_INFO_EXPRESSION_TYPE("A")!>t1<!>
+
+        val t2 = bar(::baz)
+        <!DEBUG_INFO_EXPRESSION_TYPE("A")!>t2<!>
+
+        myWith(B()) {
+            val a: A = bar(::foo)
+            val b: B = bar(::foo)
+
+            val t3 = bar(::baz)
+            <!DEBUG_INFO_EXPRESSION_TYPE("B")!>t3<!>
+
+            <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
+        }
+    }
+}
+
+inline fun <T, R> myWith(receiver: T, block: T.() -> R): R = TODO()

compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.txt

@@ -0,0 +1,24 @@
+package
+
+public fun </*0*/ T> bar(/*0*/ f: (T) -> kotlin.Unit): T
+public inline fun </*0*/ T, /*1*/ R> myWith(/*0*/ receiver: T, /*1*/ block: T.() -> R): R
+public fun test(): kotlin.Unit
+
+public final class A {
+    public constructor A()
+    public final fun baz(/*0*/ i: A): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ i: A): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B {
+    public constructor B()
+    public final fun baz(/*0*/ s: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ s: B): kotlin.Unit
+    public final fun foo(/*0*/ c: kotlin.Char): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt

@@ -0,0 +1,16 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
+
+interface Parent
+interface Child1 : Parent
+interface Child2 : Parent
+
+fun foo(): Child1 = TODO()
+fun bar(): Child2 = TODO()
+
+fun <K> select(x: K, y: K): K = TODO()
+
+fun test() {
+    val a = select(::foo, ::bar)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction0<Parent>")!>a<!>
+}

compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.txt

@@ -0,0 +1,24 @@
+package
+
+public fun bar(): Child2
+public fun foo(): Child1
+public fun </*0*/ K> select(/*0*/ x: K, /*1*/ y: K): K
+public fun test(): kotlin.Unit
+
+public interface Child1 : Parent {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Child2 : Parent {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Parent {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt

@@ -0,0 +1,35 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
+
+interface A
+interface B
+
+fun multiple(a: A) {}
+fun multiple(b: B) {}
+
+fun singleA(a: A) {}
+fun singleB(a: B) {}
+
+fun <T> foo(f: (T) -> Unit, g: (T) -> Unit): T = TODO()
+
+fun test() {
+    val a1 = foo(::singleA, ::multiple)
+    <!DEBUG_INFO_EXPRESSION_TYPE("A")!>a1<!>
+
+    val a2 = foo(::singleB, ::multiple)
+    <!DEBUG_INFO_EXPRESSION_TYPE("B")!>a2<!>
+
+    val a3 = foo(::multiple, ::singleA)
+    <!DEBUG_INFO_EXPRESSION_TYPE("A")!>a3<!>
+
+    val a4 = foo(::multiple, ::singleB)
+    <!DEBUG_INFO_EXPRESSION_TYPE("B")!>a4<!>
+
+    val a5 = foo(::singleA, ::singleA)
+    <!DEBUG_INFO_EXPRESSION_TYPE("A")!>a5<!>
+
+    val a6 = foo(::singleA, ::singleB)
+    <!DEBUG_INFO_EXPRESSION_TYPE("{A & B}")!>a6<!>
+
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>foo<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>)
+}

compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.txt

@@ -0,0 +1,20 @@
+package
+
+public fun </*0*/ T> foo(/*0*/ f: (T) -> kotlin.Unit, /*1*/ g: (T) -> kotlin.Unit): T
+public fun multiple(/*0*/ a: A): kotlin.Unit
+public fun multiple(/*0*/ b: B): kotlin.Unit
+public fun singleA(/*0*/ a: A): kotlin.Unit
+public fun singleB(/*0*/ a: B): kotlin.Unit
+public fun test(): kotlin.Unit
+
+public interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/resolve/eagerResolveOfSingleCallableReference.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: -NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class A
+class B : A()
+
+class Or(left: A, right: A) : A()
+
+class Out<out T>
+
+fun test(ls: Out<B>) {
+    <!DEBUG_INFO_EXPRESSION_TYPE("A")!>ls.reduce(::Or)<!>
+}
+
+fun <S, T : S> Out<T>.reduce(operation: (S, T) -> S): S = TODO()

compiler/testData/diagnostics/tests/callableReference/resolve/eagerResolveOfSingleCallableReference.txt

@@ -0,0 +1,32 @@
+package
+
+public fun test(/*0*/ ls: Out<B>): kotlin.Unit
+public fun </*0*/ S, /*1*/ T : S> Out<T>.reduce(/*0*/ operation: (S, T) -> S): S
+
+public open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B : A {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Or : A {
+    public constructor Or(/*0*/ left: A, /*1*/ right: A)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Out</*0*/ out T> {
+    public constructor Out</*0*/ out T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/callableReference/resolve/postponedResolveOfManyCallableReference.kt

@@ -0,0 +1,19 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+interface A
+interface B
+
+fun foo(i: A) {}
+fun foo(b: B) {}
+
+fun <T> bar1(f: (T) -> Unit): T = TODO()
+fun <T> bar2(f: (T) -> Unit, e: T) {}
+
+fun test(a: A, b: B) {
+    val expectedType1: A = bar1(::foo)
+    val expectedType2: B = bar1(::foo)
+
+    bar2(::foo, a)
+    bar2(::foo, b)
+}

compiler/testData/diagnostics/tests/callableReference/resolve/postponedResolveOfManyCallableReference.txt

@@ -0,0 +1,19 @@
+package
+
+public fun </*0*/ T> bar1(/*0*/ f: (T) -> kotlin.Unit): T
+public fun </*0*/ T> bar2(/*0*/ f: (T) -> kotlin.Unit, /*1*/ e: T): kotlin.Unit
+public fun foo(/*0*/ i: A): kotlin.Unit
+public fun foo(/*0*/ b: B): kotlin.Unit
+public fun test(/*0*/ a: A, /*1*/ b: B): kotlin.Unit
+
+public interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}