Regenerate tests after rebase on master, add FIR tests

compiler/testData/diagnostics/tests/funInterface/basicFunInterface.fir.kt

@@ -0,0 +1,5 @@
+// !LANGUAGE: +FunctionalInterfaceConversion
+
+fun interface Foo {
+    fun invoke()
+}

compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceConversion.fir.kt

@@ -0,0 +1,12 @@
+// !LANGUAGE: +NewInference +FunctionalInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun interface Foo {
+    fun invoke()
+}
+
+fun foo(f: Foo) {}
+
+fun test() {
+    foo {}
+}

compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceDisabled.fir.kt

@@ -0,0 +1,5 @@
+// !LANGUAGE: -FunctionalInterfaceConversion
+
+fun interface Foo {
+    fun invoke()
+}

compiler/testData/diagnostics/tests/funInterface/funInterfaceSyntheticConstructors.fir.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions +SamConversionPerArgument +FunctionalInterfaceConversion
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun interface KRunnable {
+    fun invoke()
+}
+
+typealias KRunnableAlias = KRunnable
+
+fun foo(f: KRunnable) {}
+
+fun test() {
+    foo(KRunnable {})
+    foo(KRunnableAlias {})
+}

compiler/testData/diagnostics/tests/funInterface/genericSubstitutionForFunInterface.fir.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions +SamConversionPerArgument +FunctionalInterfaceConversion
+// !CHECK_TYPE
+
+fun interface F<S> {
+    fun apply(s: S)
+}
+
+interface PR<X, Y> {}
+
+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/funInterface/severalConversionsForFunInterface.fir.kt

@@ -0,0 +1,33 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions +SamConversionPerArgument +FunctionalInterfaceConversion
+
+interface J {
+    fun foo1(r: KRunnable)
+
+    fun foo2(r1: KRunnable, r2: KRunnable)
+
+    fun foo3(r1: KRunnable, r2: KRunnable, r3: KRunnable)
+}
+
+fun interface KRunnable {
+    fun run()
+}
+
+// FILE: 1.kt
+fun test(j: J, r: KRunnable) {
+    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/funInterface/suspendFunInterfaceConversion.fir.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +NewInference +SamConversionForKotlinFunctions +SamConversionPerArgument +FunctionalInterfaceConversion
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NOTHING_TO_INLINE
+
+fun interface SuspendRunnable {
+    suspend fun invoke()
+}
+
+fun run(r: SuspendRunnable) {}
+
+suspend fun bar() {}
+
+fun test() {
+    run(::bar)
+}