K2: Set proper source for implicit it/receiver parameter

Previously, error types on those implicit parameters were being lost.

Changed test data is only partly here
(only parts that are considered to be correct).

Other ones (new green-to-red changes) should belong to the next commit
and will be fixed soon (as a part of PCLA).

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt

@@ -266,7 +266,10 @@ class FirCallCompleter(
                         origin = FirDeclarationOrigin.Source
                         this.name = name
                         symbol = FirValueParameterSymbol(name)
-                        returnTypeRef = itType.approximateLambdaInputType(symbol).toFirResolvedTypeRef()
+                        returnTypeRef =
+                            itType.approximateLambdaInputType(symbol).toFirResolvedTypeRef(
+                                lambdaAtom.atom.source?.fakeElement(KtFakeSourceElementKind.ItLambdaParameter)
+                            )
                         defaultValue = null
                         isCrossinline = false
                         isNoinline = false
@@ -283,7 +286,9 @@ class FirCallCompleter(
                 !lambdaAtom.coerceFirstParameterToExtensionReceiver -> {
                     lambdaArgument.receiverParameter?.apply {
                         val type = receiverType.approximateLambdaInputType(valueParameter = null)
-                        val source = source?.fakeElement(KtFakeSourceElementKind.ImplicitTypeRef)
+                        val source =
+                            source?.fakeElement(KtFakeSourceElementKind.LambdaReceiver)
+                                ?: lambdaArgument.source?.fakeElement(KtFakeSourceElementKind.LambdaReceiver)
                         replaceTypeRef(typeRef.resolvedTypeFromPrototype(type, source))
                     }
                 }

compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt

@@ -230,6 +230,9 @@ sealed class KtFakeSourceElementKind(final override val shouldSkipErrorTypeRepor
     // where `it` parameter declaration has fake source
     object ItLambdaParameter : KtFakeSourceElementKind()
 
+    // While it doesn't have an explicit source, it still has a type that might be a ConeErrorType
+    object LambdaReceiver : KtFakeSourceElementKind()
+
     // { (a, b) -> foo() } -> { x -> val (a, b) = x; { foo() } }
     // where the inner block { foo() } has fake source
     object LambdaDestructuringBlock : KtFakeSourceElementKind()

compiler/testData/compileKotlinAgainstCustomBinaries/strictMetadataVersionSemanticsOldVersion/output.txt

@@ -14,6 +14,10 @@ compiler/testData/compileKotlinAgainstCustomBinaries/strictMetadataVersionSemant
 The class is loaded from $TMP_DIR$/library.jar!/a/C.class
     c.let { C() }
     ^
+compiler/testData/compileKotlinAgainstCustomBinaries/strictMetadataVersionSemanticsOldVersion/source.kt:6:11: error: class 'a.C' was compiled with an incompatible version of Kotlin. The actual metadata version is $ABI_VERSION_NEXT$, but the compiler version $ABI_VERSION$ can read versions up to $ABI_VERSION$.
+The class is loaded from $TMP_DIR$/library.jar!/a/C.class
+    c.let { C() }
+          ^
 compiler/testData/compileKotlinAgainstCustomBinaries/strictMetadataVersionSemanticsOldVersion/source.kt:6:13: error: class 'a.C' was compiled with an incompatible version of Kotlin. The actual metadata version is $ABI_VERSION_NEXT$, but the compiler version $ABI_VERSION$ can read versions up to $ABI_VERSION$.
 The class is loaded from $TMP_DIR$/library.jar!/a/C.class
     c.let { C() }

compiler/testData/diagnostics/tests/builderInference/issues/kt49263.fir.kt

@@ -2,9 +2,9 @@
 // CHECK_TYPE_WITH_EXACT
 
 fun test() {
-    val targetType = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>buildPostponedTypeVariable<!> {
+    val targetType = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>buildPostponedTypeVariable<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         consumeTargetType(<!CANNOT_INFER_PARAMETER_TYPE!>this<!>)
-    }
+    }<!>
     // exact type equality check — turns unexpected compile-time behavior into red code
     // considered to be non-user-reproducible code for the purposes of these tests
     checkExactType<TargetType>(targetType)

compiler/testData/diagnostics/tests/callableReference/ea81649_errorPropertyLHS.fir.kt

@@ -14,7 +14,7 @@ fun <T> bar(ff: <!UNRESOLVED_REFERENCE!>Err<!>.() -> Unit) {
 data class User(val surname: String)
 
 fun foo() {
-    bar<String> {
+    bar<String> <!UNRESOLVED_REFERENCE!>{
         User::surname
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/inference/builderInference/builderInferenceAnnotationInLambdaWithTVExpectedType.fir.kt

@@ -9,7 +9,7 @@ fun <T> applyBI(@BuilderInference t: T): T = t
 fun <V> myBuildList(a: MutableList<out V>.() -> Unit) {}
 
 fun main() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myBuildList<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>applyBI<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myBuildList<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>applyBI<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         <!CANNOT_INFER_PARAMETER_TYPE!>this<!>.<!UNRESOLVED_REFERENCE!>add<!>("1")
-    })
+    }<!>)
 }

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/stubTypeReceiverRestriction.fir.kt

@@ -8,31 +8,31 @@ fun <T> T.extension() {}
 fun use(p: Any?) {}
 
 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         <!BUILDER_INFERENCE_STUB_RECEIVER!>this.get(0)<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>this.get(0)<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 
 fun test2() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v = this.get(0)
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 fun test3() {
     operator fun <T> T.getValue(thisRef: Any?, prop: Any?): T = this
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>this.get(0)<!>
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 class Box<TIn>(val t: TIn)
@@ -40,12 +40,12 @@ class Box<TIn>(val t: TIn)
 fun test4() {
     operator fun <T> T.provideDelegate(thisRef: Any?, prop: Any?): Box<T> = Box(this)
     operator fun <T> Box<T>.getValue(thisRef: Any?, prop: Any?): T = this.t
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>this.get(0)<!>
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 fun <R> b(lambda: R.(List<R>) -> Unit) {}
@@ -53,20 +53,20 @@ fun <R> b(lambda: R.(List<R>) -> Unit) {}
 fun test5() {
 
     operator fun <T> T.invoke(): T = this
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         extension()
         <!CANNOT_INFER_PARAMETER_TYPE!>this<!><!NO_VALUE_FOR_PARAMETER!>()<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(::extension)
-    }
+    }<!>
 }
 
 val <T> T.genericLambda: T.((T) -> Unit) -> Unit get() = {}
 
 fun test6() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>extension<!>()
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>genericLambda<!> { }
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>genericLambda<!> { it.extension() }
         use(::extension)
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/stubTypeReceiverRestrictionDisabled.fir.kt

@@ -9,31 +9,31 @@ fun <T> T.extension() {}
 fun use(p: Any?) {}
 
 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         <!BUILDER_INFERENCE_STUB_RECEIVER!>this.get(0)<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>this.get(0)<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 
 fun test2() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v = this.get(0)
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 fun test3() {
     operator fun <T> T.getValue(thisRef: Any?, prop: Any?): T = this
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>this.get(0)<!>
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 class Box<TIn>(val t: TIn)
@@ -41,12 +41,12 @@ class Box<TIn>(val t: TIn)
 fun test4() {
     operator fun <T> T.provideDelegate(thisRef: Any?, prop: Any?): Box<T> = Box(this)
     operator fun <T> Box<T>.getValue(thisRef: Any?, prop: Any?): T = this.t
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>a<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         val v by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>this.get(0)<!>
         <!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(<!BUILDER_INFERENCE_STUB_RECEIVER!>v<!>::extension)
         use(it::extension)
-    }
+    }<!>
 }
 
 fun <R> b(lambda: R.(List<R>) -> Unit) {}
@@ -54,20 +54,20 @@ fun <R> b(lambda: R.(List<R>) -> Unit) {}
 fun test5() {
 
     operator fun <T> T.invoke(): T = this
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         extension()
         <!CANNOT_INFER_PARAMETER_TYPE!>this<!><!NO_VALUE_FOR_PARAMETER!>()<!>.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>extension<!>()
         use(::extension)
-    }
+    }<!>
 }
 
 val <T> T.genericLambda: T.((T) -> Unit) -> Unit get() = {}
 
 fun test6() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>b<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>extension<!>()
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>genericLambda<!> { }
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>genericLambda<!> { it.extension() }
         use(::extension)
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt

@@ -78,11 +78,11 @@ fun main() {
 
     // Interdependent lambdas by input-output types aren't supported
     takeInterdependentLambdas({}, {})
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { 10 })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>(<!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!>, <!CANNOT_INFER_PARAMETER_TYPE!>{ 10 }<!>)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { it })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>(<!CANNOT_INFER_PARAMETER_TYPE!>{ 10 }<!>, <!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!>)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>(<!CANNOT_INFER_PARAMETER_TYPE!>{ 10 }<!>, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x })
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 }, { it })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 }, <!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!>)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>(<!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!>, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 })
 
     // Dependent lambdas by input-output types
     takeDependentLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>it<!> }, { it })

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

@@ -0,0 +1,16 @@
+// !CHECK_TYPE
+
+package a
+
+import checkSubtype
+
+fun <T> emptyList(): List<T> = throw Exception()
+
+fun <T> foo(f: T.() -> Unit, l: List<T>): T = throw Exception("$f$l")
+
+fun test() {
+    val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
+    checkSubtype<Int>(q)
+
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!CANNOT_INFER_PARAMETER_TYPE!>{}<!>, <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+}

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

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !CHECK_TYPE
 
 package a

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

@@ -3,9 +3,9 @@
 fun <T, R : Any> foo(body: (R?) -> T): T = fail()
 
 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         true
-    }
+    }<!>
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
         true
     }
@@ -15,9 +15,9 @@ fun test1() {
 fun <T, R> bar(body: (R) -> T): T = fail()
 
 fun test2() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         true
-    }
+    }<!>
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
         true
     }
@@ -45,4 +45,4 @@ fun test4() {
     }
 }
 
-fun fail(): Nothing = throw Exception()
+fun fail(): Nothing = throw Exception()

compiler/testData/diagnostics/tests/inference/regressions/kt2445.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNREACHABLE_CODE
+//KT-2445 Calling method with function with generic parameter causes compile-time exception
+package a
+
+fun main() {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
+
+    }<!>
+}
+
+fun <R> test(callback: (R) -> Unit):Unit = callback(null!!)

compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNREACHABLE_CODE
 //KT-2445 Calling method with function with generic parameter causes compile-time exception
 package a

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

@@ -10,7 +10,7 @@ fun test() {
     foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
     foo <!ARGUMENT_TYPE_MISMATCH!>{ x: Int -> x}<!>
 
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { it + 1 }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> <!CANNOT_INFER_PARAMETER_TYPE!>{ it + 1 }<!>
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x + 1}
     bar { x: Int -> x + 1}
 }

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

@@ -42,9 +42,9 @@ fun <`_`> bar(): Foo<<!UNDERSCORE_USAGE_WITHOUT_BACKTICKS!>_<!>> = TODO()
 fun <`_`> bar1(): Foo<Foo<<!UNDERSCORE_USAGE_WITHOUT_BACKTICKS!>_<!>>> = TODO()
 
 fun test() {
-    val x1 = foo<Int, (<!UNRESOLVED_REFERENCE!>_<!>) -> Unit> { { it } }
+    val x1 = foo<Int, (<!UNRESOLVED_REFERENCE!>_<!>) -> Unit> { <!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!> }
     val x2 = foo<Int, (Int) -> <!UNRESOLVED_REFERENCE!>_<!>> { { it } }
-    val x3 = foo<Int, ((<!UNRESOLVED_REFERENCE!>_<!>)) -> <!UNRESOLVED_REFERENCE!>_<!>> { { it } }
+    val x3 = foo<Int, ((<!UNRESOLVED_REFERENCE!>_<!>)) -> <!UNRESOLVED_REFERENCE!>_<!>> { <!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!> }
     val x4 = <!FUNCTION_CALL_EXPECTED!>foo<!><!UNRESOLVED_REFERENCE!><<!>Int<!SYNTAX!>, _ -> Float><!> { { <!UNRESOLVED_REFERENCE!>it<!> } }
     val x5 = foo<Int, Foo<(<!UNRESOLVED_REFERENCE!>_<!>) -> Float>> { <!ARGUMENT_TYPE_MISMATCH!>{ it }<!> }
     val x6 = foo<Int, Foo<(<!UNRESOLVED_REFERENCE!>_<!>) -> <!UNRESOLVED_REFERENCE!>_<!>>> { <!ARGUMENT_TYPE_MISMATCH!>{ it }<!> }

compiler/testData/diagnostics/tests/kt49438.fir.kt

@@ -1,7 +1,7 @@
 fun <K> foo(x: K) {}
-val x1 = foo<(<!UNRESOLVED_REFERENCE!>unresolved<!>) -> Float> { it.<!UNRESOLVED_REFERENCE!>toFloat<!>() }
+val x1 = foo<(<!UNRESOLVED_REFERENCE!>unresolved<!>) -> Float> <!CANNOT_INFER_PARAMETER_TYPE!>{ it.<!UNRESOLVED_REFERENCE!>toFloat<!>() }<!>
 val x2 = foo<(<!UNRESOLVED_REFERENCE!>unresolved<!>) -> Float> { <!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> it.<!UNRESOLVED_REFERENCE!>toFloat<!>() }
-val x3 = foo<<!UNRESOLVED_REFERENCE!>unresolved<!>.() -> Float> { <!CANNOT_INFER_PARAMETER_TYPE!>this<!>.<!UNRESOLVED_REFERENCE!>toFloat<!>() }
+val x3 = foo<<!UNRESOLVED_REFERENCE!>unresolved<!>.() -> Float> <!CANNOT_INFER_PARAMETER_TYPE!>{ <!CANNOT_INFER_PARAMETER_TYPE!>this<!>.<!UNRESOLVED_REFERENCE!>toFloat<!>() }<!>
 val x4 = foo<(Array<<!UNRESOLVED_REFERENCE!>unresolved<!>>) -> Int> { it.size }
 
 fun <T> bar() = foo<(T) -> String> { it.toString() }

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.fir.kt

@@ -19,7 +19,7 @@ class C(p: Any, val v: Any) {
 
     <!PROPERTY_WITH_NO_TYPE_NO_INITIALIZER!>var test5<!>
         get() { return <!UNRESOLVED_REFERENCE!>p<!> }
-        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.let {} }
+        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.let <!CANNOT_INFER_PARAMETER_TYPE!>{}<!> }
 
     <!PROPERTY_WITH_NO_TYPE_NO_INITIALIZER!>lateinit var test6<!>
 }

compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt

@@ -18,9 +18,9 @@ class C {
     fun p() : Resource? = null
 
     fun bar() {
-        foo(<!ARGUMENT_TYPE_MISMATCH!>p()<!>) {
+        foo(<!ARGUMENT_TYPE_MISMATCH!>p()<!>) <!CANNOT_INFER_PARAMETER_TYPE!>{
 
-        }
+        }<!>
     }
 }
 

compiler/testData/diagnostics/tests/regressions/kt31975.fir.kt

@@ -9,7 +9,7 @@ interface A
 interface TypeConstructor
 
 class Refiner {
-    val memoizedFunctionLambda = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>createMemoizedFunction<!> { it.foo() } // error type infered, no diagnostic, BAD, backend fails
+    val memoizedFunctionLambda = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>createMemoizedFunction<!> <!CANNOT_INFER_PARAMETER_TYPE!>{ it.foo() }<!> // error type infered, no diagnostic, BAD, backend fails
     val memoizedFunctionReference = createMemoizedFunction(TypeConstructor::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>foo<!>) // EXTENSION_IN_CLASS_REFERENCE_IS_NOT_ALLOWED, fine
     val memoizedFunctionTypes = createMemoizedFunction<TypeConstructor, Boolean> { it.foo() } // works fine
 

compiler/testData/diagnostics/testsWithStdLib/builderInference/typeVariableShouldNotBeFixed.fir.kt

@@ -23,10 +23,10 @@ fun <C> context(p: Processor<in C>, exec: Exec<C>) {}
 fun <M> materialize(): Processor<M> = TODO()
 
 private fun foo(model: Model) {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER("M")!>materialize<!>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER("T")!>apply<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER("M")!>materialize<!>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER("T")!>apply<!> <!CANNOT_INFER_PARAMETER_TYPE!>{
         context(
             <!CANNOT_INFER_PARAMETER_TYPE!>this<!>,
             Exec { m, p -> p.process(m) } // Note: Builder inference
         )
-    }
+    }<!>
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/stubCallOnReceiver.fir.kt

@@ -12,13 +12,13 @@ fun <KotlinType : Any> defineType(definition: TypeDefinition<KotlinType>.() -> U
 fun foo() {
     defineType {
         parse { it.toInt() }
-        serialize { toString() }
+        serialize <!CANNOT_INFER_PARAMETER_TYPE!>{ toString() }<!>
     }
 }
 
 fun bar() {
     defineType {
         parse { it.toInt() }
-        serialize { <!CANNOT_INFER_PARAMETER_TYPE!>this<!>.toString() }
+        serialize <!CANNOT_INFER_PARAMETER_TYPE!>{ <!CANNOT_INFER_PARAMETER_TYPE!>this<!>.toString() }<!>
     }
 }