[NI] Prototype for SAM-conversion.

Supported:
- conversion in resolution parts. Also sam-with-receiver is supported automatically
- separate flag for kotlin function with java SAM as parameters

TODO:
- fix overload conflict error when function type is the same byte origin types is ordered
- consider case when parameter type is T, T <:> Runnable
- support vararg of Runnable

[NI] Turn off synthetic scope with SAM adapter functions if NI enabled

compiler/testData/codegen/box/sam/partialSam.kt

@@ -0,0 +1,44 @@
+// !LANGUAGE: +NewInference
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// FILE: Fn.java
+public interface Fn<T, R> {
+    R run(String s, int i, T t);
+}
+
+// FILE: J.java
+public class J {
+    public int runConversion(Fn<String, Integer> f1, Fn<Integer, String> f2) {
+        return f1.run("Bar", 1, f2.run("Foo", 42, 239));
+    }
+}
+
+// FILE: 1.kt
+fun box(): String {
+    val j = J()
+    var x = ""
+
+    val fsi = object : Fn<String, Int> {
+        override fun run(s: String, i: Int, t: String): Int {
+            x += "$s$i$t "
+            return i
+        }
+    }
+
+    val fis = object : Fn<Int, String> {
+        override fun run(s: String, i: Int, t: Int): String {
+            x += "$s$i$t "
+            return s
+        }
+    }
+
+    val r1 = j.runConversion(fsi) { s, i, ti -> x += "L$s$i$ti "; "L$s"}
+    val r2 = j.runConversion({ s, i, ts -> x += "L$s$i$ts"; i }, fis)
+
+    if (r1 != 1) return "fail r1: $r1"
+    if (r2 != 1) return "fail r2: $r2"
+
+    if (x != "LFoo42239 Bar1LFoo Foo42239 LBar1Foo") return x
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/partialSamKT.kt

@@ -0,0 +1,41 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// FILE: Fn.java
+public interface Fn<T, R> {
+    R run(String s, int i, T t);
+}
+
+// FILE: 1.kt
+class K {
+    fun runConversion(f1: Fn<String, Int>, f2: Fn<Int, String>) = f1.run("Bar", 1, f2.run("Foo", 42, 239))
+}
+
+fun box(): String {
+    val k = K()
+    var x = ""
+
+    val fsi = object : Fn<String, Int> {
+        override fun run(s: String, i: Int, t: String): Int {
+            x += "$s$i$t "
+            return i
+        }
+    }
+
+    val fis = object : Fn<Int, String> {
+        override fun run(s: String, i: Int, t: Int): String {
+            x += "$s$i$t "
+            return s
+        }
+    }
+
+    val r1 = k.runConversion(fsi) { s, i, ti -> x += "L$s$i$ti "; "L$s"}
+    val r2 = k.runConversion({ s, i, ts -> x += "L$s$i$ts"; i }, fis)
+
+    if (r1 != 1) return "fail r1: $r1"
+    if (r2 != 1) return "fail r2: $r2"
+
+    if (x != "LFoo42239 Bar1LFoo Foo42239 LBar1Foo") return x
+
+    return "OK"
+}

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

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 // FILE: A.java
@@ -15,14 +16,14 @@ fun <T> bar(s: T) {}
 fun <T> complex(t: T, f: (T) -> Unit) {}
 
 fun test1() {
-    foo(1, A::invokeLater)
+    foo(1, <!NI;TYPE_MISMATCH!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
     foo(1, ::bar)
 
     complex(1, ::bar)
 }
 
 fun <R> test2(x: R) {
-    foo(x, A::invokeLater)
+    foo(x, <!NI;TYPE_MISMATCH!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
     foo(x, ::bar)
 
     complex(x, ::bar)

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt

@@ -13,5 +13,5 @@ public class J {
 package test
 
 fun test() {
-    J("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r<!> = <!NI;TYPE_MISMATCH!>{ }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z<!> = false)
+    J("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r<!> = { }, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z<!> = false)
 }

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt

@@ -13,5 +13,5 @@ public class J {
 package test
 
 fun test() {
-    J.foo("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r<!> = <!NI;TYPE_MISMATCH!>{ }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z<!> = false)
+    J.foo("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r<!> = { }, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z<!> = false)
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // FILE: A.java
 
@@ -20,7 +21,7 @@ class B {
 fun main() {
     fun println() {}
     // All parameters in SAM adapter of `foo` have functional types
-    B().foo(<!TYPE_MISMATCH!>{ println() }<!>, B.bar())
+    B().foo(<!OI;TYPE_MISMATCH!>{ println() }<!>, B.bar())
     // So you should use SAM constructors when you want to use mix lambdas and Java objects
     B().foo(Runnable { println() }, B.bar())
     B().foo({ println() }, { it: Any? -> it == null } )

compiler/testData/diagnostics/tests/samConversions/DisabledForKTSimple.kt

@@ -0,0 +1,20 @@
+// !LANGUAGE: +NewInference
+// FILE: Runnable.java
+public interface Runnable {
+    void run();
+}
+
+// FILE: 1.kt
+interface K {
+    fun foo1(r: Runnable)
+    fun foo2(r1: Runnable, r2: Runnable)
+}
+fun test(k: K, r: Runnable) {
+    k.foo1(r)
+    k.foo1(<!TYPE_MISMATCH!>{}<!>)
+
+    k.foo2(r, r)
+    k.foo2(<!TYPE_MISMATCH!>{}<!>, <!TYPE_MISMATCH!>{}<!>)
+    k.foo2(r, <!TYPE_MISMATCH!>{}<!>)
+    k.foo2(<!TYPE_MISMATCH!>{}<!>, r)
+}

compiler/testData/diagnostics/tests/samConversions/DisabledForKTSimple.txt

@@ -0,0 +1,18 @@
+package
+
+public fun test(/*0*/ k: K, /*1*/ r: Runnable): kotlin.Unit
+
+public interface K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo1(/*0*/ r: Runnable): kotlin.Unit
+    public abstract fun foo2(/*0*/ r1: Runnable, /*1*/ r2: Runnable): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Runnable {
+    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 abstract fun run(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/GenericSubstitution.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +NewInference
+// !CHECK_TYPE
+// FILE: J.java
+public interface J<T> {
+    void f_t(F<T> f1, F<T> f2);
+    <R> void f_r(F<R> f1, F<R> f2);
+    <R> void f_pr(F<PR<T, R>> f1, F<PR<T, R>> f2);
+}
+
+// FILE: F.java
+public interface F<S> {
+    void apply(S s);
+}
+
+// FILE: PR.java
+public interface PR<X, Y> {}
+
+// FILE: 1.kt
+
+fun test(
+    j: J<String>,
+    f_string: F<String>,
+    f_int: F<Int>,
+    f_pr: F<PR<String, Int>>
+) {
+    j.f_t(f_string) { it checkType { _<String>() } }
+    j.f_r(f_int) { it checkType { _<Int>() } }
+    j.f_pr(f_pr) { it checkType { _<PR<String, Int>>() } }
+}

compiler/testData/diagnostics/tests/samConversions/GenericSubstitution.txt

@@ -0,0 +1,25 @@
+package
+
+public fun test(/*0*/ j: J<kotlin.String>, /*1*/ f_string: F<kotlin.String>, /*2*/ f_int: F<kotlin.Int>, /*3*/ f_pr: F<PR<kotlin.String, kotlin.Int>>): kotlin.Unit
+
+public interface F</*0*/ S : kotlin.Any!> {
+    public abstract fun apply(/*0*/ s: S!): kotlin.Unit
+    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 J</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun </*0*/ R : kotlin.Any!> f_pr(/*0*/ f1: F<PR<T!, R!>!>!, /*1*/ f2: F<PR<T!, R!>!>!): kotlin.Unit
+    public abstract fun </*0*/ R : kotlin.Any!> f_r(/*0*/ f1: F<R!>!, /*1*/ f2: F<R!>!): kotlin.Unit
+    public abstract fun f_t(/*0*/ f1: F<T!>!, /*1*/ f2: F<T!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface PR</*0*/ X : kotlin.Any!, /*1*/ Y : kotlin.Any!> {
+    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/samConversions/GenericSubstitutionKT.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// !CHECK_TYPE
+// FILE: F.java
+public interface F<S> {
+    void apply(S s);
+}
+
+// FILE: PR.java
+public interface PR<X, Y> {}
+
+// FILE: 1.kt
+interface K<T> {
+    fun f_t(f1: F<T>, f2: F<T>)
+    fun <R> f_r(f1: F<R>, f2: F<R>)
+    fun <R> f_pr(f1: F<PR<T, R>>, f2: F<PR<T, R>>)
+}
+
+fun test(
+    k: K<String>,
+    f_string: F<String>,
+    f_int: F<Int>,
+    f_pr: F<PR<String, Int>>
+) {
+    k.f_t(f_string) { it checkType { _<String>() } }
+    k.f_r(f_int) { it checkType { _<Int>() } }
+    k.f_pr(f_pr) { it checkType { _<PR<String, Int>>() } }
+}

compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.txt

@@ -0,0 +1,25 @@
+package
+
+public fun test(/*0*/ k: K<kotlin.String>, /*1*/ f_string: F<kotlin.String>, /*2*/ f_int: F<kotlin.Int>, /*3*/ f_pr: F<PR<kotlin.String, kotlin.Int>>): kotlin.Unit
+
+public interface F</*0*/ S : kotlin.Any!> {
+    public abstract fun apply(/*0*/ s: S!): kotlin.Unit
+    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 K</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun </*0*/ R> f_pr(/*0*/ f1: F<PR<T, R>>, /*1*/ f2: F<PR<T, R>>): kotlin.Unit
+    public abstract fun </*0*/ R> f_r(/*0*/ f1: F<R>, /*1*/ f2: F<R>): kotlin.Unit
+    public abstract fun f_t(/*0*/ f1: F<T>, /*1*/ f2: F<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface PR</*0*/ X : kotlin.Any!, /*1*/ Y : kotlin.Any!> {
+    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/samConversions/OverloadPriority.kt

@@ -0,0 +1,31 @@
+// !LANGUAGE: +NewInference
+// !CHECK_TYPE
+// FILE: Fn.java
+public interface Fn<T, R> {
+    R apply(T t);
+}
+
+// FILE: Fn2.java
+public interface Fn2<T, R> extends Fn<T, R> {}
+
+// FILE: J.java
+public interface J {
+    String foo(Fn<String, Object> f, Object o);
+    int foo(Fn<Object, Object> f, String s); // (Any) -> Any <: (String) -> Any <=> String <: Any
+
+    String bas(Fn<Object, Object> f, Object o);
+    int bas(Fn<Object, String> f, String s); // (Any) -> String <: (Any) -> Any <=> String <: Any
+
+    String bar(Fn<String, Object> f);
+    int bar(Fn2<String, Object> f); // Fn2 seems more specific one even function type same
+}
+
+// FILE: 1.kt
+fun test(j: J) {
+    j.foo({ it checkType { _<Any>() }; "" }, "") checkType { _<Int>() }
+
+    j.bas({ it checkType { _<Any>() }; "" }, "") checkType { _<Int>() }
+
+    // NI: TODO
+    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> { <!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Any>() }; "" } <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+}

compiler/testData/diagnostics/tests/samConversions/OverloadPriority.txt

@@ -0,0 +1,29 @@
+package
+
+public fun test(/*0*/ j: J): kotlin.Unit
+
+public interface Fn</*0*/ T : kotlin.Any!, /*1*/ R : kotlin.Any!> {
+    public abstract fun apply(/*0*/ t: T!): R!
+    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 Fn2</*0*/ T : kotlin.Any!, /*1*/ R : kotlin.Any!> : Fn<T!, R!> {
+    public abstract override /*1*/ /*fake_override*/ fun apply(/*0*/ t: T!): R!
+    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 J {
+    public abstract fun bar(/*0*/ f: Fn2<kotlin.String!, kotlin.Any!>!): kotlin.Int
+    public abstract fun bar(/*0*/ f: Fn<kotlin.String!, kotlin.Any!>!): kotlin.String!
+    public abstract fun bas(/*0*/ f: Fn<kotlin.Any!, kotlin.Any!>!, /*1*/ o: kotlin.Any!): kotlin.String!
+    public abstract fun bas(/*0*/ f: Fn<kotlin.Any!, kotlin.String!>!, /*1*/ s: kotlin.String!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ f: Fn<kotlin.Any!, kotlin.Any!>!, /*1*/ s: kotlin.String!): kotlin.Int
+    public abstract fun foo(/*0*/ f: Fn<kotlin.String!, kotlin.Any!>!, /*1*/ o: kotlin.Any!): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// !CHECK_TYPE
+// FILE: Fn.java
+public interface Fn<T, R> {
+    R apply(T t);
+}
+
+// FILE: Fn2.java
+public interface Fn2<T, R> extends Fn<T, R> {}
+
+// FILE: 1.kt
+interface K {
+    fun foo(f: Fn<String, Any>): String
+    fun foo(f: Fn<Any, Any>): Int
+
+    fun bas(f: Fn<Any, Any>): String
+    fun bas(f: Fn<Any, String>): Int
+
+    fun bar(f: Fn<String, Any>): String
+    fun bar(f: Fn2<String, Any>): Int
+}
+
+fun test(k: K) {
+    k.foo { it checkType { _<Any>() }; "" } checkType { _<Int>() }
+
+    k.bas { it checkType { _<Any?>() }; "" } checkType { _<Int>() }
+
+    // NI: TODO
+    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> { <!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Any>() }; "" } <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+}

compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.txt

@@ -0,0 +1,29 @@
+package
+
+public fun test(/*0*/ k: K): kotlin.Unit
+
+public interface Fn</*0*/ T : kotlin.Any!, /*1*/ R : kotlin.Any!> {
+    public abstract fun apply(/*0*/ t: T!): R!
+    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 Fn2</*0*/ T : kotlin.Any!, /*1*/ R : kotlin.Any!> : Fn<T!, R!> {
+    public abstract override /*1*/ /*fake_override*/ fun apply(/*0*/ t: T!): R!
+    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 K {
+    public abstract fun bar(/*0*/ f: Fn2<kotlin.String, kotlin.Any>): kotlin.Int
+    public abstract fun bar(/*0*/ f: Fn<kotlin.String, kotlin.Any>): kotlin.String
+    public abstract fun bas(/*0*/ f: Fn<kotlin.Any, kotlin.Any>): kotlin.String
+    public abstract fun bas(/*0*/ f: Fn<kotlin.Any, kotlin.String>): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ f: Fn<kotlin.Any, kotlin.Any>): kotlin.Int
+    public abstract fun foo(/*0*/ f: Fn<kotlin.String, kotlin.Any>): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitution.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +NewInference
+// FILE: J.java
+public interface J<T> {
+    public void foo(T r1, T r2);
+}
+
+// FILE: Runnable.java
+public interface Runnable {
+    void run();
+}
+
+// FILE: 1.kt
+fun test(j: J<Runnable>, r: Runnable) {
+    j.foo(r, r)
+    j.foo(r, <!TYPE_MISMATCH!>{}<!>)
+    j.foo(<!TYPE_MISMATCH!>{}<!>, r)
+    j.foo(<!TYPE_MISMATCH!>{}<!>, <!TYPE_MISMATCH!>{}<!>)
+}

compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitution.txt

@@ -0,0 +1,17 @@
+package
+
+public fun test(/*0*/ j: J<Runnable>, /*1*/ r: Runnable): kotlin.Unit
+
+public interface J</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ r1: T!, /*1*/ r2: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Runnable {
+    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 abstract fun run(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitutionKT.kt

@@ -0,0 +1,17 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// FILE: Runnable.java
+public interface Runnable {
+    void run();
+}
+
+// FILE: 1.kt
+interface K<T> {
+    fun foo(t1: T, t2: T)
+}
+
+fun test(k: K<Runnable>, r: Runnable) {
+    k.foo(r, r)
+    k.foo(r, <!TYPE_MISMATCH!>{}<!>)
+    k.foo(<!TYPE_MISMATCH!>{}<!>, r)
+    k.foo(<!TYPE_MISMATCH!>{}<!>, <!TYPE_MISMATCH!>{}<!>)
+}

compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitutionKT.txt

@@ -0,0 +1,17 @@
+package
+
+public fun test(/*0*/ k: K<Runnable>, /*1*/ r: Runnable): kotlin.Unit
+
+public interface K</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ t1: T, /*1*/ t2: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Runnable {
+    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 abstract fun run(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/SimpleCorrect.kt

@@ -0,0 +1,34 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// FILE: J.java
+public interface J {
+    public void foo1(Runnable r);
+
+    public void foo2(Runnable r1, Runnable r2);
+
+    public void foo3(Runnable r1, Runnable r2, Runnable r3);
+}
+
+// FILE: Runnable.java
+public interface Runnable {
+    void run();
+}
+
+// FILE: 1.kt
+fun test(j: J, r: Runnable) {
+    j.foo1(r)
+    j.foo1({})
+
+    j.foo2(r, r)
+    j.foo2({}, {})
+    j.foo2(r, {})
+    j.foo2({}, r)
+
+    j.foo3(r, r, r)
+    j.foo3(r, r, {})
+    j.foo3(r, {}, r)
+    j.foo3(r, {}, {})
+    j.foo3({}, r, r)
+    j.foo3({}, r, {})
+    j.foo3({}, {}, r)
+    j.foo3({}, {}, {})
+}

compiler/testData/diagnostics/tests/samConversions/SimpleCorrect.txt

@@ -0,0 +1,19 @@
+package
+
+public fun test(/*0*/ j: J, /*1*/ r: Runnable): kotlin.Unit
+
+public interface J {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo1(/*0*/ r: Runnable!): kotlin.Unit
+    public abstract fun foo2(/*0*/ r1: Runnable!, /*1*/ r2: Runnable!): kotlin.Unit
+    public abstract fun foo3(/*0*/ r1: Runnable!, /*1*/ r2: Runnable!, /*2*/ r3: Runnable!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Runnable {
+    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 abstract fun run(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/samConversions/SimpleCorrectKT.kt

@@ -0,0 +1,31 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions
+// FILE: Runnable.java
+public interface Runnable {
+    void run();
+}
+
+// FILE: 1.kt
+
+interface K {
+    fun foo1(r: Runnable)
+    fun foo2(r1: Runnable, r2: Runnable)
+    fun foo3(r1: Runnable, r2: Runnable, r3: Runnable)
+}
+fun test(k: K, r: Runnable) {
+    k.foo1(r)
+    k.foo1({})
+
+    k.foo2(r, r)
+    k.foo2({}, {})
+    k.foo2(r, {})
+    k.foo2({}, r)
+
+    k.foo3(r, r, r)
+    k.foo3(r, r, {})
+    k.foo3(r, {}, r)
+    k.foo3(r, {}, {})
+    k.foo3({}, r, r)
+    k.foo3({}, r, {})
+    k.foo3({}, {}, r)
+    k.foo3({}, {}, {})
+}

compiler/testData/diagnostics/tests/samConversions/SimpleCorrectKT.txt

@@ -0,0 +1,19 @@
+package
+
+public fun test(/*0*/ k: K, /*1*/ r: Runnable): kotlin.Unit
+
+public interface K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo1(/*0*/ r: Runnable): kotlin.Unit
+    public abstract fun foo2(/*0*/ r1: Runnable, /*1*/ r2: Runnable): kotlin.Unit
+    public abstract fun foo3(/*0*/ r1: Runnable, /*1*/ r2: Runnable, /*2*/ r3: Runnable): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Runnable {
+    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 abstract fun run(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt

@@ -21,7 +21,7 @@ class B : A() {
         }
 
         if (d.x is B) {
-            <!SMARTCAST_IMPOSSIBLE!>d.x<!>.<!NI;INVISIBLE_MEMBER!>foo<!> {}
+            <!OI;SMARTCAST_IMPOSSIBLE!>d.x<!>.<!NI;INVISIBLE_MEMBER!>foo<!> {}
         }
     }
 }

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt

@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>): Int {
     val inner = javaClass.createInner<String>()
-    return <!TYPE_MISMATCH!>inner.<!NI;TYPE_MISMATCH!>doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!TYPE_MISMATCH!>{ }<!><!><!>
+    return <!TYPE_MISMATCH!>inner.<!NI;TYPE_MISMATCH!>doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!OI;TYPE_MISMATCH!>{ }<!><!><!>
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt

@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass) {
-    javaClass.doSomething(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p<!> = 1) <!NI;TYPE_MISMATCH!>{
+    javaClass.doSomething(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p<!> = 1) {
         bar()
-    }<!>
+    }
 }
 
 fun bar(){}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.kt

@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaInterface: JavaInterface) {
-    javaInterface.doIt(<!NULL_FOR_NONNULL_TYPE!>null<!>) <!NI;TYPE_MISMATCH!>{ }<!>
+    javaInterface.doIt(<!NULL_FOR_NONNULL_TYPE!>null<!>) { }
     javaInterface.doIt("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
 }
 

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt

@@ -1,6 +1,7 @@
+// !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass) {
-    javaClass.<!INVISIBLE_MEMBER!>doSomething<!> <!TYPE_MISMATCH!>{ }<!>
+    javaClass.<!INVISIBLE_MEMBER!>doSomething<!> <!OI;TYPE_MISMATCH!>{ }<!>
 }
 
 // FILE: JavaClass.java