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

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Deprecated.fir.kt

@@ -0,0 +1,22 @@
+// FILE: KotlinFile.kt
+public interface I {
+    public fun doIt()
+}
+
+fun foo(javaClass: JavaClass) {
+    javaClass.doSomething1 { bar() }
+    javaClass.doSomething2 { bar() }
+}
+
+fun bar(){}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    @Deprecated
+    public void doSomething1(Runnable runnable) { runnable.run(); }
+
+    /**
+     * @deprecated
+     */
+    public void doSomething2(Runnable runnable) { runnable.run(); }
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt

@@ -0,0 +1,14 @@
+// JAVAC_EXPECTED_FILE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass<String>): String {
+    return javaClass.doSomething("", 1) { s: String -> "" }
+}
+
+// FILE: JavaClass.java
+public class JavaClass<T> {
+    public T doSomething(T t, int anInt, I<T> i) { return t; }
+}
+
+interface I<T> {
+    T doIt(T t);
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt

@@ -0,0 +1,14 @@
+// JAVAC_EXPECTED_FILE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass): String {
+    return javaClass.doSomething("") { <!UNRESOLVED_REFERENCE!>it<!> }
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public <T> T doSomething(T t, I<T> i) { return i.run(t); }
+}
+
+interface I<T> {
+    T run(T t);
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt

@@ -0,0 +1,16 @@
+// JAVAC_EXPECTED_FILE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass<Int>) {
+    val a: String = javaClass.doSomething1("", 1) { p: String -> p }
+    val b: String = javaClass.doSomething2("", 1, true) { p: Int -> p }
+}
+
+// FILE: JavaClass.java
+public class JavaClass<X> {
+    public <T> T doSomething1(T t, X x, I<T> i) { return i.run(t); }
+    public <T> T doSomething2(T t, X x, boolean p, I<X> i) { return i.run(t); }
+}
+
+interface I<T> {
+    T run(T t);
+}

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

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass<Int>): Int {
+    val inner = javaClass.createInner<String>()
+    return inner.doSomething(1, "") { }
+}
+
+// FILE: JavaClass.java
+public class JavaClass<T> {
+    public <X> Inner<X> createInner() {
+        return new Inner<X>();
+    }
+
+    public interface Inner<X>{
+        public T doSomething(T t, X x, Runnable runnable);
+    }
+}

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

@@ -0,0 +1,14 @@
+// !WITH_NEW_INFERENCE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.doSomething(p = 1) {
+        bar()
+    }
+}
+
+fun bar(){}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public void doSomething(int p, Runnable runnable) { runnable.run(); }
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.fir.kt

@@ -0,0 +1,18 @@
+// FILE: KotlinFile1.kt
+package k
+
+import JavaClass
+
+fun foo(javaClass: JavaClass) {
+    javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!> { }
+}
+
+// FILE: KotlinFile2.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.doSomething { }
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    void doSomething(Runnable runnable) { runnable.run(); }
+}

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

@@ -0,0 +1,13 @@
+// !WITH_NEW_INFERENCE
+// FILE: KotlinFile.kt
+fun foo(javaInterface: JavaInterface) {
+    javaInterface.doIt(null) { }
+    javaInterface.doIt("", null)
+}
+
+// FILE: JavaInterface.java
+import org.jetbrains.annotations.*;
+
+public interface JavaInterface {
+    void doIt(@NotNull String s, @NotNull Runnable runnable);
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PassNull.fir.kt

@@ -0,0 +1,10 @@
+// FILE: KotlinFile.kt
+fun foo(javaInterface: JavaInterface) {
+    javaInterface.doIt(null, null) { }
+    javaInterface.doIt("", { }, null)
+}
+
+// FILE: JavaInterface.java
+public interface JavaInterface {
+    void doIt(String s, Runnable runnable1, Runnable runnable2);
+}

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

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!> { }
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    private void doSomething(Runnable runnable) { runnable.run(); }
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Protected.fir.kt

@@ -0,0 +1,24 @@
+// FILE: KotlinFile.kt
+package k
+
+import JavaClass
+
+fun foo(javaClass: JavaClass) {
+    javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!> {
+        bar()
+    }
+}
+
+class X : JavaClass() {
+    fun foo(other: JavaClass) {
+        doSomething { bar() }
+        other.doSomething { bar() }
+    }
+}
+
+fun bar(){}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    protected void doSomething(Runnable runnable) { runnable.run(); }
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ReturnTypeAnnotation.fir.kt

@@ -0,0 +1,18 @@
+// FILE: KotlinFile.kt
+fun foo(javaInterface: JavaInterface) {
+    val value = javaInterface.compute { "" }
+    value.<!INAPPLICABLE_CANDIDATE!>length<!>
+}
+
+// FILE: JavaInterface.java
+import org.jetbrains.annotations.*;
+
+public interface JavaInterface {
+    @Nullable
+    <T> String compute(@NotNull Provider<T> provider);
+}
+
+// FILE: Provider.java
+public interface Provider<T> {
+    public T compute();
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt

@@ -0,0 +1,30 @@
+// FILE: KotlinFile.kt
+class KotlinClass {
+    public fun doSomething(runnable: Runnable) { runnable.run() }
+}
+
+public interface I {
+    public fun doIt()
+}
+
+fun foo(javaClass: JavaClass, kotlinClass: KotlinClass) {
+    javaClass.doSomething {
+        bar()
+    }
+
+    kotlinClass.doSomething {
+        bar()
+    }
+
+    javaClass.doSomething2 {
+        bar()
+    }
+}
+
+fun bar(){}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public void doSomething(Runnable runnable) { runnable.run(); }
+    public void doSomething2(I i) { i.doIt(); }
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.fir.kt

@@ -0,0 +1,36 @@
+// !CHECK_TYPE
+// FILE: A.java
+public class A {
+    public int foo(Runnable r) { return 0; }
+    public String foo(Object r) { return null;}
+
+    public int bar(Runnable r) { return 1; }
+    public String bar(CharSequence r) { return null; }
+}
+
+// FILE: 1.kt
+fun fn() {}
+fun x(a: A, r: Runnable) {
+    a.foo(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.foo {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.foo(null) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.foo(Runnable { }) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.foo(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.foo(123) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.foo("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    a.bar(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.bar {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.bar(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.<!AMBIGUITY!>bar<!>(null)
+
+    a.bar(null as Runnable?) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.bar(null as CharSequence?) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    a.bar("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.<!INAPPLICABLE_CANDIDATE!>bar<!>(123)
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.fir.kt

@@ -0,0 +1,36 @@
+// !CHECK_TYPE
+// FILE: A.java
+public class A {
+    public static int foo(Runnable r) { return 0; }
+    public static String foo(Object r) { return null;}
+
+    public static int bar(Runnable r) { return 1; }
+    public static String bar(CharSequence r) { return null; }
+}
+
+// FILE: 1.kt
+fun fn() {}
+fun x(r: Runnable) {
+    A.foo(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.foo {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.foo(null) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.foo(Runnable { }) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.foo(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.foo(123) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    A.foo("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    A.bar(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.bar {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.bar(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.<!AMBIGUITY!>bar<!>(null)
+
+    A.bar(null as Runnable?) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.bar(null as CharSequence?) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    A.bar("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    A.<!INAPPLICABLE_CANDIDATE!>bar<!>(123)
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStaticWithoutRefinedSams.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: -RefinedSamAdaptersPriority -NewInference
+// !CHECK_TYPE
+// FILE: A.java
+public class A {
+    public static int foo(Runnable r) { return 0; }
+    public static String foo(Object r) { return null;}
+
+    public static int bar(Runnable r) { return 1; }
+    public static String bar(CharSequence r) { return null; }
+}
+
+// FILE: 1.kt
+fun fn() {}
+fun x(r: Runnable) {
+    A.foo(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    A.foo {} checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    A.foo(null) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.foo(Runnable { }) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.foo(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.foo(123) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    A.foo("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    A.bar(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.bar {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.bar(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    A.<!AMBIGUITY!>bar<!>(null)
+
+    A.bar(null as Runnable?) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    A.bar(null as CharSequence?) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    A.bar("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    A.<!INAPPLICABLE_CANDIDATE!>bar<!>(123)
+}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionWithoutRefinedSams.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: -RefinedSamAdaptersPriority -NewInference
+// !CHECK_TYPE
+// FILE: A.java
+public class A {
+    public int foo(Runnable r) { return 0; }
+    public String foo(Object r) { return null;}
+
+    public int bar(Runnable r) { return 1; }
+    public String bar(CharSequence r) { return null; }
+}
+
+// FILE: 1.kt
+fun fn() {}
+fun x(a: A, r: Runnable) {
+    a.foo(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.foo {} checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    a.foo(null) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.foo(Runnable { }) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.foo(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.foo(123) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.foo("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    a.bar(::fn) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.bar {} checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.bar(r) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    a.<!AMBIGUITY!>bar<!>(null)
+
+    a.bar(null as Runnable?) checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.bar(null as CharSequence?) checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    a.bar("") checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.<!INAPPLICABLE_CANDIDATE!>bar<!>(123)
+}