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

compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt

@@ -0,0 +1,9 @@
+package a
+
+fun <T, R, S> foo(block: (T)-> R, second: (T)-> S) = block
+
+fun main() {
+    val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(fff, { x -> x + 1 })
+}
+

compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+//For testing error messages text see DiagnosticMessageTest.testFunctionPlaceholder
+package a
+
+class A<T, R>
+fun <T, R> foo(a: A<T, R>) = a
+fun <T, R> bar(f: (T) -> R) = f
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> }
+    <!INAPPLICABLE_CANDIDATE!>foo<!> { x -> x}
+    <!INAPPLICABLE_CANDIDATE!>foo<!> { x: Int -> x}
+
+    bar { it <!UNRESOLVED_REFERENCE!>+<!> 1 }
+    bar { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1}
+    bar { x: Int -> x + 1}
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.fir.kt

@@ -0,0 +1,16 @@
+package a
+
+interface Closeable {}
+class C : Closeable {}
+
+fun <T: Closeable, R> T.foo(block: (T)-> R) = block
+
+fun <T: Closeable, R> T.foo(block: (T, T)-> R) = block
+
+fun main() {
+    C().foo { // no ambiguity here
+        www ->
+        <!UNRESOLVED_REFERENCE!>xs<!>
+    }
+}
+

compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+package aa
+
+fun <T, R> foo(block: (T)-> R) = block
+
+fun test1() {
+    foo {
+        x ->  // here we have 'cannot infer parameter type' error
+        43
+    }
+}
+
+fun bar(f: (A)->Unit) {}
+
+fun test2() {
+    bar { a -> } // here we don't have 'cannot infer parameter type' error
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt

@@ -0,0 +1,13 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <K> id2(x: K, s: String): K = x
+fun <K> ret(s: String): K = TODO()
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>id2<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
+    <!INAPPLICABLE_CANDIDATE!>id2<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>, 42)
+
+    ret("foo")
+    <!INAPPLICABLE_CANDIDATE!>ret<!>(42)
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.fir.kt

@@ -0,0 +1,8 @@
+fun test() {
+    val a = <!INAPPLICABLE_CANDIDATE!>-<!>false
+}
+
+operator fun A.unaryMinus() {}
+operator fun B.unaryMinus() {}
+class A
+class B

compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.fir.kt

@@ -0,0 +1,13 @@
+// !WITH_NEW_INFERENCE
+package a
+
+fun <R> foo (f: ()->R, r: MutableList<R>) = r.add(f())
+fun <R> bar (r: MutableList<R>, f: ()->R) = r.add(f())
+
+fun test() {
+    val a = foo({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
+    val b = bar(arrayListOf(""), {1})
+}
+
+// from standard library
+fun <T> arrayListOf(vararg values: T) : MutableList<T> {}

compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+class X
+
+operator fun <T> X.component1(): T = TODO()
+
+fun test() {
+    val (y) = X()
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.fir.kt

@@ -0,0 +1,9 @@
+// !WITH_NEW_INFERENCE
+class X
+
+operator fun <T> X.iterator(): Iterable<T> = TODO()
+
+fun test() {
+    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (i in X()) {
+    }<!>
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.fir.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A
+fun A.fn(b: Int): Nothing = TODO()
+
+fun A.run() {
+    "".apply { <!INAPPLICABLE_CANDIDATE!>fn<!>("") }
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.fir.kt

@@ -0,0 +1,21 @@
+// !WITH_NEW_INFERENCE
+// WITH_RUNTIME
+
+fun Runnable.test(f: Runnable.(Int) -> Unit) {
+    <!INAPPLICABLE_CANDIDATE!>f<!>("")
+}
+
+fun test(f: Runnable.(Int) -> Unit, runnable: Runnable) {
+    with (runnable) {
+        <!INAPPLICABLE_CANDIDATE!>f<!>("")
+    }
+}
+
+fun Int.test(f: String.(Int) -> Unit) {
+    f("", 0)
+    <!INAPPLICABLE_CANDIDATE!>f<!>("")
+    with("") {
+        <!INAPPLICABLE_CANDIDATE!>f<!>(0)
+        <!INAPPLICABLE_CANDIDATE!>f<!>(0.0)
+    }
+}