[NI] Report error about unknown parameter type of lambda argument

KT-34335

compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.fir.kt

@@ -0,0 +1,36 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun callAny(arg: Any?) {}
+fun <T> callParam(arg: T) {}
+
+fun testAny() {
+    callAny { error -> error }
+    callAny l@{ error -> error }
+    callAny({error -> error})
+    callAny(({error -> error}))
+    callAny(l@{error -> error})
+    callAny((l@{error -> error}))
+}
+
+fun testAnyCall() {
+    callAny {
+        error -> <!UNRESOLVED_REFERENCE!>error<!>()
+    }
+}
+
+fun testParam() {
+    callParam {
+        param -> param
+    }
+}
+
+fun testParamCall() {
+    callParam {
+        param -> <!UNRESOLVED_REFERENCE!>param<!>()
+    }
+}
+
+fun testNoContext() {
+    { it -> it }
+}

compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt

@@ -0,0 +1,36 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun callAny(arg: Any?) {}
+fun <T> callParam(arg: T) {}
+
+fun testAny() {
+    callAny { <!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!> }
+    callAny l@{ <!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!> }
+    callAny({<!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!>})
+    callAny(({<!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!>}))
+    callAny(l@{<!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!>})
+    callAny((l@{<!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error<!>}))
+}
+
+fun testAnyCall() {
+    callAny {
+        <!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>error()<!>
+    }
+}
+
+fun testParam() {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
+        <!CANNOT_INFER_PARAMETER_TYPE!>param<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>param<!>
+    }
+}
+
+fun testParamCall() {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
+        <!CANNOT_INFER_PARAMETER_TYPE!>param<!> -> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>param()<!>
+    }
+}
+
+fun testNoContext() {
+    <!UNUSED_LAMBDA_EXPRESSION!>{ <!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> }<!>
+}

compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.txt

@@ -0,0 +1,9 @@
+package
+
+public fun callAny(/*0*/ arg: kotlin.Any?): kotlin.Unit
+public fun </*0*/ T> callParam(/*0*/ arg: T): kotlin.Unit
+public fun testAny(): kotlin.Unit
+public fun testAnyCall(): kotlin.Unit
+public fun testNoContext(): kotlin.Unit
+public fun testParam(): kotlin.Unit
+public fun testParamCall(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/nothingType/kt34335.fir.kt

@@ -0,0 +1,19 @@
+// !LANGUAGE: +NewInference
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun call(vararg x: Any?) {}
+fun <R> Any.call(vararg args: Any?): R = TODO()
+fun println(message: Any?) {}
+
+fun foo(action: (Int) -> Unit) {
+    action(10)
+}
+
+fun test1() {
+    call({ x -> println(x::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`.
+}
+
+fun test2() {
+    ::foo.call({ x -> println(x::class) })
+}

compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt

@@ -0,0 +1,19 @@
+// !LANGUAGE: +NewInference
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun call(vararg x: Any?) {}
+fun <R> Any.call(vararg args: Any?): R = TODO()
+fun println(message: Any?) {}
+
+fun foo(action: (Int) -> Unit) {
+    action(10)
+}
+
+fun test1() {
+    call({ <!NI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> println(<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`.
+}
+
+fun test2() {
+    ::foo.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>call<!>({ <!NI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> println(<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>::class) })
+}

compiler/testData/diagnostics/tests/inference/nothingType/kt34335.txt

@@ -0,0 +1,8 @@
+package
+
+public fun call(/*0*/ vararg x: kotlin.Any? /*kotlin.Array<out kotlin.Any?>*/): kotlin.Unit
+public fun foo(/*0*/ action: (kotlin.Int) -> kotlin.Unit): kotlin.Unit
+public fun println(/*0*/ message: kotlin.Any?): kotlin.Unit
+public fun test1(): kotlin.Unit
+public fun test2(): kotlin.Unit
+public fun </*0*/ R> kotlin.Any.call(/*0*/ vararg args: kotlin.Any? /*kotlin.Array<out kotlin.Any?>*/): R

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

@@ -8,7 +8,7 @@ fun <T, R> bar(f: (T) -> R) = f
 
 fun test() {
     <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
-    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
     <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
 
     <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }

compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.fir.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // FILE: Function.java
 public interface Function<E extends CharSequence, F extends java.util.Map<String, E>> {

compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // FILE: Function.java
 public interface Function<E extends CharSequence, F extends java.util.Map<String, E>> {
@@ -17,12 +16,12 @@ public class A {
 // FILE: main.kt
 fun main() {
     A().foo <!TYPE_MISMATCH!>{
-        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
         ""
     }<!>
 
     A.bar <!TYPE_MISMATCH!>{
-        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
         ""
     }<!>
 }

compiler/testData/diagnostics/tests/regressions/kt10843.kt

@@ -3,6 +3,6 @@
 // See EA-76890 / KT-10843: NPE during analysis
 fun lambda(x : Int?) = x?.<!FUNCTION_CALL_EXPECTED, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l<!> {
     <!OI;CANNOT_INFER_PARAMETER_TYPE!>y<!> ->
-    if (<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!> <!NI;UNREACHABLE_CODE!><!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0<!>) <!NI;UNREACHABLE_CODE!>return<!UNRESOLVED_REFERENCE!>@l<!> x<!>
-    <!NI;UNREACHABLE_CODE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
+    if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) return<!UNRESOLVED_REFERENCE!>@l<!> x
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
 }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>

compiler/testData/diagnostics/tests/resolve/newLineLambda.kt

@@ -113,6 +113,6 @@ fun testTwoLambdas() {
 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
     return { l1 ->
         <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>l1()
-        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!OI;CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NI;FUNCTION_EXPECTED!>l2<!>()<!> }<!><!>
+        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l2()<!> }<!><!>
     }
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt

@@ -7,4 +7,4 @@ object X2
 fun <T1> foo(x: T1, f: (T1) -> T1) = X1
 fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2
 
-val test: X2 = <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>foo<!>({ 0 }, { <!OI;CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!NI;UNREACHABLE_CODE!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1<!> })
+val test: X2 = <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>foo<!>({ 0 }, { <!OI;CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 })