diff --git a/compiler/fir/analysis-tests/testData/resolve/cast.fir.txt b/compiler/fir/analysis-tests/testData/resolve/cast.fir.txt
index c428a52..1e39d4d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cast.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/cast.fir.txt
@@ -18,7 +18,7 @@
     }
 
         public get(): R|(kotlin/String) -> kotlin/Boolean|
-    public final val hError: R|(ERROR CLASS: Cannot infer type for parameter <unused var>) -> ERROR CLASS: Cannot infer type variable TypeVariable(_L)| = fun <anonymous>(<unused var>: <ERROR TYPE REF: Cannot infer type for parameter <unused var>>): <ERROR TYPE REF: Cannot infer type variable TypeVariable(_L)> <inline=NoInline>  {
+    public final val hError: R|(ERROR CLASS: Cannot infer type for parameter <unused var>) -> ERROR CLASS: Cannot infer type variable TypeVariable(_L)| = ERROR_EXPR(CS errors: _synthetic/ACCEPT_SPECIFIC_TYPE_CALL)fun <anonymous>(<unused var>: <ERROR TYPE REF: Cannot infer type for parameter <unused var>>): <ERROR TYPE REF: Cannot infer type variable TypeVariable(_L)> <inline=NoInline>  {
         ^ Boolean(true)
     }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.dot b/compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.dot
index 55eddee..40c2e10 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.dot
@@ -150,35 +150,43 @@
                 subgraph cluster_17 {
                     color=blue
                     51 [label="Enter block"];
-                    52 [label="Exit anonymous function expression"];
-                    53 [label="Variable declaration: lval lambda: R|() -> kotlin/Int|"];
-                    54 [label="Exit block"];
+                    subgraph cluster_18 {
+                        color=blue
+                        52 [label="Function call arguments enter"];
+                        53 [label="Anonymous function capture"];
+                        54 [label="Postponed enter to lambda"];
+                        subgraph cluster_19 {
+                            color=blue
+                            55 [label="Enter function <anonymous>" style="filled" fillcolor=red];
+                            subgraph cluster_20 {
+                                color=blue
+                                56 [label="Enter block"];
+                                subgraph cluster_21 {
+                                    color=blue
+                                    57 [label="Function call arguments enter"];
+                                    58 [label="Access variable R|<local>/x|"];
+                                    59 [label="Smart cast: R|<local>/x|"];
+                                    60 [label="Function call arguments exit"];
+                                }
+                                61 [label="Function call enter: R|<local>/x|.R|kotlin/Int.inc|()"];
+                                62 [label="Function call exit: R|<local>/x|.R|kotlin/Int.inc|()" style="filled" fillcolor=yellow];
+                                63 [label="Exit block"];
+                            }
+                            64 [label="Exit function <anonymous>" style="filled" fillcolor=red];
+                        }
+                        65 [label="Function call arguments exit"];
+                    }
+                    66 [label="Postponed exit from lambda"];
+                    67 [label="Function call exit: R|_synthetic/ACCEPT_SPECIFIC_TYPE_CALL|(...)" style="filled" fillcolor=yellow];
+                    68 [label="Variable declaration: lval lambda: R|() -> kotlin/Int|"];
+                    69 [label="Exit block"];
                 }
-                55 [label="Exit when branch result"];
-                56 [label="Exit when"];
+                70 [label="Exit when branch result"];
+                71 [label="Exit when"];
             }
-            57 [label="Exit block"];
+            72 [label="Exit block"];
         }
-        58 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
-    subgraph cluster_18 {
-        color=blue
-        59 [label="Enter function <anonymous>" style="filled" fillcolor=red];
-        subgraph cluster_19 {
-            color=blue
-            60 [label="Enter block"];
-            subgraph cluster_20 {
-                color=blue
-                61 [label="Function call arguments enter"];
-                62 [label="Access variable R|<local>/x|"];
-                63 [label="Smart cast: R|<local>/x|"];
-                64 [label="Function call arguments exit"];
-            }
-            65 [label="Function call enter: R|<local>/x|.R|kotlin/Int.inc|()"];
-            66 [label="Function call exit: R|<local>/x|.R|kotlin/Int.inc|()" style="filled" fillcolor=yellow];
-            67 [label="Exit block"];
-        }
-        68 [label="Exit function <anonymous>" style="filled" fillcolor=red];
+        73 [label="Exit function test_2" style="filled" fillcolor=red];
     }
     42 -> {43};
     43 -> {44};
@@ -187,182 +195,188 @@
     46 -> {47};
     47 -> {48};
     48 -> {49 50};
-    49 -> {56};
+    49 -> {71};
     50 -> {51};
     51 -> {52};
-    52 -> {53 59};
-    52 -> {59} [style=dashed];
+    52 -> {53};
     53 -> {54};
-    54 -> {55};
+    53 -> {55} [color=green label="CapturedByValue"];
+    54 -> {55 65 66};
+    54 -> {55} [style=dashed];
     55 -> {56};
     56 -> {57};
     57 -> {58};
+    58 -> {59};
     59 -> {60};
     60 -> {61};
     61 -> {62};
     62 -> {63};
     63 -> {64};
-    64 -> {65};
-    65 -> {66};
-    66 -> {67};
+    65 -> {67};
+    66 -> {67} [label="Postponed"];
     67 -> {68};
-
-    subgraph cluster_21 {
-        color=red
-        69 [label="Enter function getInt" style="filled" fillcolor=red];
-        subgraph cluster_22 {
-            color=blue
-            70 [label="Enter block"];
-            subgraph cluster_23 {
-                color=blue
-                71 [label="Function call arguments enter"];
-                72 [label="Function call arguments exit"];
-            }
-            73 [label="Function call enter: R?C|kotlin/Function0.invoke|()"];
-            74 [label="Function call exit: R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()" style="filled" fillcolor=yellow];
-            75 [label="Const: Int(1)"];
-            76 [label="Jump: ^getInt Int(1)"];
-            77 [label="Stub" style="filled" fillcolor=gray];
-            78 [label="Exit block" style="filled" fillcolor=gray];
-        }
-        79 [label="Exit function getInt" style="filled" fillcolor=red];
-    }
+    68 -> {69};
     69 -> {70};
     70 -> {71};
     71 -> {72};
     72 -> {73};
-    73 -> {74};
+
+    subgraph cluster_22 {
+        color=red
+        74 [label="Enter function getInt" style="filled" fillcolor=red];
+        subgraph cluster_23 {
+            color=blue
+            75 [label="Enter block"];
+            subgraph cluster_24 {
+                color=blue
+                76 [label="Function call arguments enter"];
+                77 [label="Function call arguments exit"];
+            }
+            78 [label="Function call enter: R?C|kotlin/Function0.invoke|()"];
+            79 [label="Function call exit: R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()" style="filled" fillcolor=yellow];
+            80 [label="Const: Int(1)"];
+            81 [label="Jump: ^getInt Int(1)"];
+            82 [label="Stub" style="filled" fillcolor=gray];
+            83 [label="Exit block" style="filled" fillcolor=gray];
+        }
+        84 [label="Exit function getInt" style="filled" fillcolor=red];
+    }
     74 -> {75};
     75 -> {76};
-    76 -> {79};
-    76 -> {77} [style=dotted];
-    77 -> {78} [style=dotted];
-    78 -> {79} [style=dotted];
+    76 -> {77};
+    77 -> {78};
+    78 -> {79};
+    79 -> {80};
+    80 -> {81};
+    81 -> {84};
+    81 -> {82} [style=dotted];
+    82 -> {83} [style=dotted];
+    83 -> {84} [style=dotted];
 
-    subgraph cluster_24 {
+    subgraph cluster_25 {
         color=red
-        80 [label="Enter function test_3" style="filled" fillcolor=red];
-        subgraph cluster_25 {
+        85 [label="Enter function test_3" style="filled" fillcolor=red];
+        subgraph cluster_26 {
             color=blue
-            81 [label="Enter block"];
-            subgraph cluster_26 {
+            86 [label="Enter block"];
+            subgraph cluster_27 {
                 color=blue
-                82 [label="Function call arguments enter"];
-                83 [label="Anonymous function capture"];
-                84 [label="Postponed enter to lambda"];
-                subgraph cluster_27 {
+                87 [label="Function call arguments enter"];
+                88 [label="Anonymous function capture"];
+                89 [label="Postponed enter to lambda"];
+                subgraph cluster_28 {
                     color=blue
-                    85 [label="Enter function <anonymous>" style="filled" fillcolor=red];
-                    subgraph cluster_28 {
+                    90 [label="Enter function <anonymous>" style="filled" fillcolor=red];
+                    subgraph cluster_29 {
                         color=blue
-                        86 [label="Enter block"];
-                        87 [label="Const: Int(1)"];
-                        88 [label="Jump: ^test_3 Int(1)"];
-                        89 [label="Stub" style="filled" fillcolor=gray];
-                        90 [label="Exit block" style="filled" fillcolor=gray];
+                        91 [label="Enter block"];
+                        92 [label="Const: Int(1)"];
+                        93 [label="Jump: ^test_3 Int(1)"];
+                        94 [label="Stub" style="filled" fillcolor=gray];
+                        95 [label="Exit block" style="filled" fillcolor=gray];
                     }
-                    91 [label="Exit function <anonymous>" style="filled" fillcolor=gray];
+                    96 [label="Exit function <anonymous>" style="filled" fillcolor=gray];
                 }
-                92 [label="Function call arguments exit"];
+                97 [label="Function call arguments exit"];
             }
-            93 [label="Function call enter: R|/getInt|(...)"];
-            94 [label="Postponed exit from lambda"];
-            95 [label="Function call exit: R|/getInt|(...)" style="filled" fillcolor=yellow];
-            96 [label="Jump: ^test_3 R|/getInt|(<L> = getInt@fun <anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>  {
+            98 [label="Function call enter: R|/getInt|(...)"];
+            99 [label="Postponed exit from lambda"];
+            100 [label="Function call exit: R|/getInt|(...)" style="filled" fillcolor=yellow];
+            101 [label="Jump: ^test_3 R|/getInt|(<L> = getInt@fun <anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>  {
     ^test_3 Int(1)
 }
 )"];
-            97 [label="Stub" style="filled" fillcolor=gray];
-            98 [label="Exit block" style="filled" fillcolor=gray];
+            102 [label="Stub" style="filled" fillcolor=gray];
+            103 [label="Exit block" style="filled" fillcolor=gray];
         }
-        99 [label="Exit function test_3" style="filled" fillcolor=red];
+        104 [label="Exit function test_3" style="filled" fillcolor=red];
     }
-    80 -> {81};
-    81 -> {82};
-    82 -> {83};
-    83 -> {84};
-    83 -> {85} [color=green style=dotted label="CapturedByValue"];
-    84 -> {85 92 94};
-    84 -> {85} [style=dashed];
     85 -> {86};
     86 -> {87};
     87 -> {88};
-    88 -> {99};
-    88 -> {89} [style=dotted];
-    89 -> {90} [style=dotted];
-    90 -> {91} [style=dotted];
-    91 -> {94} [style=dotted];
+    88 -> {89};
+    88 -> {90} [color=green style=dotted label="CapturedByValue"];
+    89 -> {90 97 99};
+    89 -> {90} [style=dashed];
+    90 -> {91};
+    91 -> {92};
     92 -> {93};
-    93 -> {95};
-    94 -> {84} [color=green style=dashed];
-    94 -> {95} [label="Postponed"];
-    95 -> {96};
-    96 -> {99};
-    96 -> {97} [style=dotted];
-    97 -> {98} [style=dotted];
-    98 -> {99} [style=dotted];
+    93 -> {104};
+    93 -> {94} [style=dotted];
+    94 -> {95} [style=dotted];
+    95 -> {96} [style=dotted];
+    96 -> {99} [style=dotted];
+    97 -> {98};
+    98 -> {100};
+    99 -> {89} [color=green style=dashed];
+    99 -> {100} [label="Postponed"];
+    100 -> {101};
+    101 -> {104};
+    101 -> {102} [style=dotted];
+    102 -> {103} [style=dotted];
+    103 -> {104} [style=dotted];
 
-    subgraph cluster_29 {
+    subgraph cluster_30 {
         color=red
-        100 [label="Enter function test_4" style="filled" fillcolor=red];
-        subgraph cluster_30 {
+        105 [label="Enter function test_4" style="filled" fillcolor=red];
+        subgraph cluster_31 {
             color=blue
-            101 [label="Enter block"];
-            subgraph cluster_31 {
+            106 [label="Enter block"];
+            subgraph cluster_32 {
                 color=blue
-                102 [label="Function call arguments enter"];
-                103 [label="Anonymous function capture"];
-                104 [label="Postponed enter to lambda"];
-                subgraph cluster_32 {
+                107 [label="Function call arguments enter"];
+                108 [label="Anonymous function capture"];
+                109 [label="Postponed enter to lambda"];
+                subgraph cluster_33 {
                     color=blue
-                    105 [label="Enter function <anonymous>" style="filled" fillcolor=red];
-                    subgraph cluster_33 {
+                    110 [label="Enter function <anonymous>" style="filled" fillcolor=red];
+                    subgraph cluster_34 {
                         color=blue
-                        106 [label="Enter block"];
-                        107 [label="Const: Int(1)"];
-                        108 [label="Jump: ^test_4 Int(1)"];
-                        109 [label="Stub" style="filled" fillcolor=gray];
-                        110 [label="Exit block" style="filled" fillcolor=gray];
+                        111 [label="Enter block"];
+                        112 [label="Const: Int(1)"];
+                        113 [label="Jump: ^test_4 Int(1)"];
+                        114 [label="Stub" style="filled" fillcolor=gray];
+                        115 [label="Exit block" style="filled" fillcolor=gray];
                     }
-                    111 [label="Exit function <anonymous>" style="filled" fillcolor=gray];
+                    116 [label="Exit function <anonymous>" style="filled" fillcolor=gray];
                 }
-                112 [label="Function call arguments exit"];
+                117 [label="Function call arguments exit"];
             }
-            113 [label="Function call enter: R|/getInt|(...)"];
-            114 [label="Postponed exit from lambda"];
-            115 [label="Function call exit: R|/getInt|(...)" style="filled" fillcolor=yellow];
-            116 [label="Jump: ^test_4 R|/getInt|(getInt@fun <anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>  {
+            118 [label="Function call enter: R|/getInt|(...)"];
+            119 [label="Postponed exit from lambda"];
+            120 [label="Function call exit: R|/getInt|(...)" style="filled" fillcolor=yellow];
+            121 [label="Jump: ^test_4 R|/getInt|(getInt@fun <anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>  {
     ^test_4 Int(1)
 }
 )"];
-            117 [label="Stub" style="filled" fillcolor=gray];
-            118 [label="Exit block" style="filled" fillcolor=gray];
+            122 [label="Stub" style="filled" fillcolor=gray];
+            123 [label="Exit block" style="filled" fillcolor=gray];
         }
-        119 [label="Exit function test_4" style="filled" fillcolor=red];
+        124 [label="Exit function test_4" style="filled" fillcolor=red];
     }
-    100 -> {101};
-    101 -> {102};
-    102 -> {103};
-    103 -> {104};
-    103 -> {105} [color=green style=dotted label="CapturedByValue"];
-    104 -> {105 112 114};
-    104 -> {105} [style=dashed];
     105 -> {106};
     106 -> {107};
     107 -> {108};
-    108 -> {119};
-    108 -> {109} [style=dotted];
-    109 -> {110} [style=dotted];
-    110 -> {111} [style=dotted];
-    111 -> {114} [style=dotted];
+    108 -> {109};
+    108 -> {110} [color=green style=dotted label="CapturedByValue"];
+    109 -> {110 117 119};
+    109 -> {110} [style=dashed];
+    110 -> {111};
+    111 -> {112};
     112 -> {113};
-    113 -> {115};
-    114 -> {104} [color=green style=dashed];
-    114 -> {115} [label="Postponed"];
-    115 -> {116};
-    116 -> {119};
-    116 -> {117} [style=dotted];
-    117 -> {118} [style=dotted];
-    118 -> {119} [style=dotted];
+    113 -> {124};
+    113 -> {114} [style=dotted];
+    114 -> {115} [style=dotted];
+    115 -> {116} [style=dotted];
+    116 -> {119} [style=dotted];
+    117 -> {118};
+    118 -> {120};
+    119 -> {109} [color=green style=dashed];
+    119 -> {120} [label="Postponed"];
+    120 -> {121};
+    121 -> {124};
+    121 -> {122} [style=dotted];
+    122 -> {123} [style=dotted];
+    123 -> {124} [style=dotted];
 
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/recursiveProblemWithSyntaxError.fir.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/recursiveProblemWithSyntaxError.fir.txt
index ae2acee..4baa070 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/recursiveProblemWithSyntaxError.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/recursiveProblemWithSyntaxError.fir.txt
@@ -1,8 +1,8 @@
 FILE: recursiveProblemWithSyntaxError.kt
-    public final val foo: <ERROR TYPE REF: Unresolved name: bar> = bar@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: bar> <inline=NoInline>  {
+    public final val foo: <ERROR TYPE REF: Unresolved name: bar> = ERROR_EXPR(Inapplicable(INAPPLICABLE): _synthetic/ACCEPT_SPECIFIC_TYPE_CALL)bar@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: bar> <inline=NoInline>  {
         ^ <Unresolved name: bar>#
     }
-    .R|SubstitutionOverride<kotlin/Function0.invoke: <ERROR TYPE REF: Unresolved name: bar>><Inapplicable(INAPPLICABLE_ARGUMENTS_MAPPING_ERROR): kotlin/Function0.invoke>#|(ERROR_EXPR(Argument is absent)).<Unresolved name: bar>#(<Call has no callee>#(<L> = <Call has no callee>@fun <anonymous>(): <ERROR TYPE REF: cycle> <inline=NoInline>  {
+    .R|SubstitutionOverride<kotlin/Function0.invoke: <ERROR TYPE REF: Unresolved name: bar>><Inapplicable(INAPPLICABLE_ARGUMENTS_MAPPING_ERROR): kotlin/Function0.invoke>#|(ERROR_EXPR(Argument is absent)).<Unresolved name: bar>#(<Call has no callee>#(ERROR_EXPR(Inapplicable(INAPPLICABLE): _synthetic/ACCEPT_SPECIFIC_TYPE_CALL)<L> = <Call has no callee>@fun <anonymous>(): <ERROR TYPE REF: cycle> <inline=NoInline>  {
         ^ R|/foo|
     }
     ))
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.fir.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.fir.txt
index d47f770..7959a7b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.fir.txt
@@ -13,7 +13,7 @@
         public final fun act(): R|kotlin/Unit| {
             <Super cannot be a callee>#()
             <Unresolved name: invoke>#()
-            <Super cannot be a callee>#(<L> = <Super cannot be a callee>@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: println> <inline=NoInline>  {
+            <Super cannot be a callee>#(ERROR_EXPR(Inapplicable(INAPPLICABLE): _synthetic/ACCEPT_SPECIFIC_TYPE_CALL)<L> = <Super cannot be a callee>@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: println> <inline=NoInline>  {
                 ^ <Unresolved name: println>#(ERROR_EXPR(Incorrect character: 'weird'))
             }
             )
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/incorrectGenericLambdaProperty.fir.txt b/compiler/fir/analysis-tests/testData/resolve/problems/incorrectGenericLambdaProperty.fir.txt
index 24064ad..dddf688 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/incorrectGenericLambdaProperty.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/incorrectGenericLambdaProperty.fir.txt
@@ -1,6 +1,6 @@
 FILE: incorrectGenericLambdaProperty.kt
     public final fun main(args: R|kotlin/Array<kotlin/String>|): R|kotlin/Unit| {
-        lval <T> passIt: R|(ERROR CLASS: Cannot infer type for parameter <destruct>) -> ERROR CLASS: Symbol not found for T| = fun <anonymous>(<destruct>: <ERROR TYPE REF: Cannot infer type for parameter <destruct>>): <ERROR TYPE REF: Symbol not found for T> <inline=NoInline>  {
+        lval <T> passIt: R|(ERROR CLASS: Cannot infer type for parameter <destruct>) -> ERROR CLASS: Symbol not found for T| = ERROR_EXPR(CS errors: _synthetic/ACCEPT_SPECIFIC_TYPE_CALL)fun <anonymous>(<destruct>: <ERROR TYPE REF: Cannot infer type for parameter <destruct>>): <ERROR TYPE REF: Symbol not found for T> <inline=NoInline>  {
             lval t: <ERROR TYPE REF: Symbol not found for T> = R|<local>/<destruct>|.<Unresolved name: component1>#()
             ^  {
                 R|<local>/t|
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
index 7d3de7f..0cbc21c 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
@@ -170,7 +170,10 @@
 
     is ConeDestructuringDeclarationsOnTopLevel -> null // TODO Currently a parsing error. Would be better to report here instead KT-58563
     is ConeCannotInferTypeParameterType -> FirErrors.CANNOT_INFER_PARAMETER_TYPE.createOn(source)
-    is ConeCannotInferValueParameterType -> FirErrors.CANNOT_INFER_PARAMETER_TYPE.createOn(source)
+    is ConeCannotInferValueParameterType -> when {
+        isTopLevelLambda -> FirErrors.VALUE_PARAMETER_WITHOUT_EXPLICIT_TYPE.createOn(source)
+        else -> FirErrors.CANNOT_INFER_PARAMETER_TYPE.createOn(source)
+    }
     is ConeCannotInferReceiverParameterType -> FirErrors.CANNOT_INFER_PARAMETER_TYPE.createOn(source)
     is ConeTypeVariableTypeIsNotInferred -> FirErrors.INFERENCE_ERROR.createOn(callOrAssignmentSource ?: source)
     is ConeInstanceAccessBeforeSuperCall -> FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL.createOn(source, this.target)
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeResolutionAtoms.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeResolutionAtoms.kt
index e6b7f85..688f124 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeResolutionAtoms.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeResolutionAtoms.kt
@@ -79,7 +79,10 @@
         private fun createRawAtom(expression: FirExpression?, allowUnresolvedExpression: Boolean): ConeResolutionAtom? {
             return when (expression) {
                 null -> null
-                is FirAnonymousFunctionExpression -> ConeResolutionAtomWithPostponedChild(expression)
+                is FirAnonymousFunctionExpression -> when {
+                    expression.isResolved -> ConeSimpleLeafResolutionAtom(expression, allowUnresolvedExpression)
+                    else -> ConeResolutionAtomWithPostponedChild(expression)
+                }
                 is FirCallableReferenceAccess -> when {
                     expression.isResolved -> ConeSimpleLeafResolutionAtom(expression, allowUnresolvedExpression)
                     else -> ConeResolutionAtomWithPostponedChild(expression)
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
index f45f07f..fb525b6 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
@@ -44,9 +44,12 @@
 import org.jetbrains.kotlin.resolve.calls.inference.addEqualityConstraintIfCompatible
 import org.jetbrains.kotlin.resolve.calls.inference.addSubtypeConstraintIfCompatible
 import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor
+import org.jetbrains.kotlin.resolve.calls.inference.buildCurrentSubstitutor
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemCompletionMode
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage
 import org.jetbrains.kotlin.types.TypeApproximatorConfiguration
+import org.jetbrains.kotlin.types.model.KotlinTypeMarker
+import org.jetbrains.kotlin.types.model.TypeConstructorMarker
 import org.jetbrains.kotlin.types.model.safeSubstitute
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
@@ -126,13 +129,35 @@
 
                 inferenceSession.processPartiallyResolvedCall(call, resolutionMode, completionMode)
 
-                call
+                if (candidate.isSyntheticCallForTopLevelLambda()) {
+                    val storage = candidate.system.currentStorage()
+
+                    val fixingNotInferredVariables: Map<TypeConstructorMarker, KotlinTypeMarker> = buildMap {
+                        if (storage.notFixedTypeVariables.isEmpty()) return@buildMap
+
+                        for (typeConstructor in storage.allTypeVariables.keys.toList().drop(storage.outerSystemVariablesPrefixSize)) {
+                            if (typeConstructor !in storage.notFixedTypeVariables) continue
+                            put(typeConstructor, session.typeContext.createUninferredType(typeConstructor))
+                        }
+                    }
+
+                    val finalSubstitutor = storage
+                        .buildCurrentSubstitutor(session.typeContext, emptyMap()) as ConeSubstitutor
+                    call.transformSingle(
+                        createCompletionResultsWriter(finalSubstitutor),
+                        null
+                    )
+                } else {
+                    call
+                }
             }
 
             ConstraintSystemCompletionMode.UNTIL_FIRST_LAMBDA -> throw IllegalStateException()
         }
     }
 
+    private fun Candidate.isSyntheticCallForTopLevelLambda(): Boolean = callInfo.callSite is FirAnonymousFunctionExpression
+
     private fun checkStorageConstraintsAfterFullCompletion(storage: ConstraintStorage) {
         // Fast path for sake of optimization
         if (storage.notFixedTypeVariables.isEmpty()) return
@@ -351,7 +376,7 @@
                         this.name = name
                         symbol = FirValueParameterSymbol(name)
                         returnTypeRef =
-                            itType.approximateLambdaInputType(symbol, withPCLASession).toFirResolvedTypeRef(
+                            itType.approximateLambdaInputType(symbol, withPCLASession, candidate).toFirResolvedTypeRef(
                                 lambdaAtom.anonymousFunction.source?.fakeElement(KtFakeSourceElementKind.ItLambdaParameter)
                             )
                         defaultValue = null
@@ -371,7 +396,7 @@
                 receiverType == null -> lambda.replaceReceiverParameter(null)
                 !lambdaAtom.coerceFirstParameterToExtensionReceiver -> {
                     lambda.receiverParameter?.apply {
-                        val type = receiverType.approximateLambdaInputType(valueParameter = null, withPCLASession)
+                        val type = receiverType.approximateLambdaInputType(valueParameter = null, withPCLASession, candidate)
                         val source =
                             source?.fakeElement(KtFakeSourceElementKind.LambdaReceiver)
                                 ?: lambda.source?.fakeElement(KtFakeSourceElementKind.LambdaReceiver)
@@ -393,7 +418,7 @@
                             name = SpecialNames.UNDERSCORE_FOR_UNUSED_VAR
                             symbol = FirValueParameterSymbol(name)
                             returnTypeRef = contextParameterType
-                                .approximateLambdaInputType(symbol, withPCLASession)
+                                .approximateLambdaInputType(symbol, withPCLASession, candidate)
                                 .toFirResolvedTypeRef(lambdaAtom.anonymousFunction.source?.fakeElement(KtFakeSourceElementKind.LambdaContextParameter))
                             valueParameterKind = if (session.languageVersionSettings.supportsFeature(LanguageFeature.ContextParameters)) {
                                 FirValueParameterKind.ContextParameter
@@ -428,7 +453,7 @@
                     )
                     return@forEachIndexed
                 }
-                val newReturnType = theParameters[index].approximateLambdaInputType(parameter.symbol, withPCLASession)
+                val newReturnType = theParameters[index].approximateLambdaInputType(parameter.symbol, withPCLASession, candidate)
                 val newReturnTypeRef = if (parameter.returnTypeRef is FirImplicitTypeRef) {
                     newReturnType.toFirResolvedTypeRef(parameter.source?.fakeElement(KtFakeSourceElementKind.ImplicitReturnTypeOfLambdaValueParameter))
                 } else parameter.returnTypeRef.resolvedTypeFromPrototype(newReturnType)
@@ -515,12 +540,15 @@
     private fun ConeKotlinType.approximateLambdaInputType(
         valueParameter: FirValueParameterSymbol?,
         isRootLambdaForPCLASession: Boolean,
+        containingCandidate: Candidate,
     ): ConeKotlinType {
         // We only run lambda completion from ConstraintSystemCompletionContext.analyzeRemainingNotAnalyzedPostponedArgument when they are
         // left uninferred.
         // Currently, we use stub types for builder inference, so CANNOT_INFER_PARAMETER_TYPE is the only possible result here.
         if (useErrorTypeInsteadOfTypeVariableForParameterType(isReceiver = valueParameter == null, isRootLambdaForPCLASession)) {
-            val diagnostic = valueParameter?.let(::ConeCannotInferValueParameterType) ?: ConeCannotInferReceiverParameterType()
+            val diagnostic = valueParameter?.let {
+                ConeCannotInferValueParameterType(it, isTopLevelLambda = containingCandidate.isSyntheticCallForTopLevelLambda())
+            } ?: ConeCannotInferReceiverParameterType()
             return ConeErrorType(diagnostic)
         }
 
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt
index 6c688d8b..8903fd2 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt
@@ -22,19 +22,18 @@
 import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.utils.addDefaultBoundIfNecessary
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
 import org.jetbrains.kotlin.fir.moduleData
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
+import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
-import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.calls.ArgumentTypeMismatch
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
 import org.jetbrains.kotlin.fir.resolve.calls.candidate.*
@@ -56,9 +55,11 @@
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.ArrayFqNames
+import org.jetbrains.kotlin.resolve.calls.inference.buildCurrentSubstitutor
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.model.safeSubstitute
 
 class FirSyntheticCallGenerator(
     private val components: BodyResolveComponents
@@ -245,6 +246,70 @@
             .firstOrNull() // TODO: it should be single() after KTIJ-26465 is fixed
     }
 
+    fun resolveAnonymousFunctionExpressionWithSyntheticOuterCall(
+        anonymousFunctionExpression: FirAnonymousFunctionExpression,
+        expectedTypeData: ResolutionMode.WithExpectedType?,
+        context: ResolutionContext,
+    ): FirExpression {
+        val argumentList = buildUnaryArgumentList(anonymousFunctionExpression)
+
+        val reference = generateCalleeReferenceToFunctionWithExpectedTypeForArgument(
+            anonymousFunctionExpression,
+            argumentList,
+            expectedTypeData?.expectedType,
+            context,
+        )
+
+        val fakeCall = buildFunctionCall {
+            calleeReference = reference
+            this.argumentList = argumentList
+        }
+
+        components.dataFlowAnalyzer.enterCallArguments(fakeCall, argumentList.arguments)
+        components.dataFlowAnalyzer.enterAnonymousFunctionExpression(anonymousFunctionExpression)
+        components.dataFlowAnalyzer.exitCallArguments()
+
+        val resultingCall = components.callCompleter.completeCall(fakeCall, ResolutionMode.ContextIndependent)
+
+        components.dataFlowAnalyzer.exitFunctionCall(fakeCall, callCompleted = true)
+
+        val resolvedArgument = resultingCall.arguments[0]
+
+        (resultingCall.calleeReference as? FirResolvedErrorReference)?.let {
+            if (expectedTypeData?.expectedTypeMismatchIsReportedInChecker != true || it.diagnostic.actualTypeIfMismatch(anonymousFunctionExpression) == null) {
+                return buildErrorExpression(
+                    anonymousFunctionExpression.source?.fakeElement(KtFakeSourceElementKind.ErrorExpressionForTopLevelLambda),
+                    it.diagnostic,
+                    resolvedArgument
+                )
+            }
+        }
+
+        return resolvedArgument
+    }
+
+    private fun ConeDiagnostic.actualTypeIfMismatch(
+        anonymousFunctionExpression: FirAnonymousFunctionExpression
+    ): ConeKotlinType? {
+        if (this !is ConeInapplicableCandidateError) return null
+        val argumentTypeMismatch = candidate.diagnostics.singleOrNull() as? ArgumentTypeMismatch ?: return null
+
+        if (argumentTypeMismatch.argument == anonymousFunctionExpression) {
+            val candidate = candidate as Candidate
+            val storage = if (candidate.usedOuterCs) candidate.system.currentStorage() else candidate.system.asReadOnlyStorage()
+            val substitutor = storage.buildCurrentSubstitutor(components.session.typeContext, emptyMap())
+
+            anonymousFunctionExpression.anonymousFunction.replaceTypeRef(
+                anonymousFunctionExpression.anonymousFunction.typeRef.withReplacedConeType(
+                    substitutor.safeSubstitute(components.session.typeContext, argumentTypeMismatch.actualType) as ConeKotlinType
+                )
+            )
+
+            return argumentTypeMismatch.actualType
+        }
+        return null
+    }
+
     fun resolveCallableReferenceWithSyntheticOuterCall(
         callableReferenceAccess: FirCallableReferenceAccess,
         expectedType: ConeKotlinType?,
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
index 8cb6697..256dca8 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
@@ -169,7 +169,7 @@
 
                 context.forPropertyInitializer {
                     if (!initializerIsAlreadyResolved) {
-                        val resolutionMode = withExpectedType(returnTypeRefBeforeResolve)
+                        val resolutionMode = withExpectedType(returnTypeRefBeforeResolve, expectedTypeMismatchIsReportedInChecker = true)
                         property.transformReturnTypeRef(transformer, resolutionMode)
                             .transformInitializer(transformer, resolutionMode)
                             .replaceBodyResolveState(FirPropertyBodyResolveState.INITIALIZER_RESOLVED)
@@ -1129,7 +1129,7 @@
                 anonymousFunctionExpression // return the same instance
             }
             is ResolutionMode.WithExpectedType -> {
-                transformTopLevelAnonymousFunctionExpression(anonymousFunctionExpression, data.expectedType)
+                transformTopLevelAnonymousFunctionExpression(anonymousFunctionExpression, data)
             }
 
 
@@ -1155,11 +1155,24 @@
      */
     private fun transformTopLevelAnonymousFunctionExpression(
         anonymousFunctionExpression: FirAnonymousFunctionExpression,
-        expectedType: ConeKotlinType?,
-    ): FirStatement = anonymousFunctionExpression.also {
-        it.replaceAnonymousFunction(transformTopLevelAnonymousFunctionInObsoleteWay(anonymousFunctionExpression, expectedType))
+        expectedTypeData: ResolutionMode.WithExpectedType?,
+    ): FirStatement = when {
+        session.languageVersionSettings.supportsFeature(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument) ->
+            components.syntheticCallGenerator.resolveAnonymousFunctionExpressionWithSyntheticOuterCall(
+                anonymousFunctionExpression, expectedTypeData, resolutionContext
+            )
+        else -> {
+            @OptIn(OnlyForDefaultLanguageFeatureDisabled::class) // ResolveTopLevelLambdasAsSyntheticCallArgument
+            val updatedAnonymousFunction = transformTopLevelAnonymousFunctionInObsoleteWay(
+                anonymousFunctionExpression, expectedTypeData?.expectedType
+            )
+            anonymousFunctionExpression.replaceAnonymousFunction(updatedAnonymousFunction)
+
+            anonymousFunctionExpression
+        }
     }
 
+    @OnlyForDefaultLanguageFeatureDisabled(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument)
     private fun transformTopLevelAnonymousFunctionInObsoleteWay(
         anonymousFunctionExpression: FirAnonymousFunctionExpression,
         expectedType: ConeKotlinType?
@@ -1253,6 +1266,37 @@
         )
     }
 
+    @OnlyForDefaultLanguageFeatureDisabled(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument)
+    private object ImplicitToErrorTypeTransformer : FirTransformer<Any?>() {
+        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
+            return element
+        }
+
+        override fun transformValueParameter(
+            valueParameter: FirValueParameter,
+            data: Any?
+        ): FirStatement =
+            whileAnalysing(valueParameter.moduleData.session, valueParameter) {
+                if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
+                    valueParameter.replaceReturnTypeRef(
+                        valueParameter.returnTypeRef.resolvedTypeFromPrototype(
+                            ConeErrorType(
+                                ConeSimpleDiagnostic(
+                                    "No type for parameter",
+                                    DiagnosticKind.ValueParameterWithNoTypeAnnotation
+                                )
+                            ),
+                            fallbackSource = valueParameter.source?.fakeElement(
+                                KtFakeSourceElementKind.ImplicitReturnTypeOfLambdaValueParameter,
+                            ),
+                        )
+                    )
+                }
+                return valueParameter
+            }
+    }
+
+    @OnlyForDefaultLanguageFeatureDisabled(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument)
     private fun obtainValueParametersFromResolvedLambdaAtom(
         resolvedLambdaAtom: ConeResolvedLambdaAtom,
         lambda: FirAnonymousFunction,
@@ -1290,6 +1334,7 @@
         }
     }
 
+    @OnlyForDefaultLanguageFeatureDisabled(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument)
     private fun obtainValueParametersFromExpectedType(
         expectedType: ConeKotlinType?,
         lambda: FirAnonymousFunction
@@ -1305,6 +1350,7 @@
         return obtainValueParametersFromExpectedParameterTypes(parameterTypes, lambda)
     }
 
+    @OnlyForDefaultLanguageFeatureDisabled(LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument)
     private fun obtainValueParametersFromExpectedParameterTypes(
         expectedTypeParameterTypes: List<ConeKotlinType>,
         lambda: FirAnonymousFunction
@@ -1476,34 +1522,6 @@
         }
     }
 
-    private object ImplicitToErrorTypeTransformer : FirTransformer<Any?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
-            return element
-        }
-
-        override fun transformValueParameter(
-            valueParameter: FirValueParameter,
-            data: Any?
-        ): FirStatement =
-            whileAnalysing(valueParameter.moduleData.session, valueParameter) {
-                if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
-                    valueParameter.replaceReturnTypeRef(
-                        valueParameter.returnTypeRef.resolvedTypeFromPrototype(
-                            ConeErrorType(
-                                ConeSimpleDiagnostic(
-                                    "No type for parameter",
-                                    DiagnosticKind.ValueParameterWithNoTypeAnnotation
-                                )
-                            ),
-                            fallbackSource = valueParameter.source?.fakeElement(
-                                KtFakeSourceElementKind.ImplicitReturnTypeOfLambdaValueParameter,
-                            ),
-                        )
-                    )
-                }
-                return valueParameter
-            }
-    }
 
     private val FirVariable.initializerResolved: Boolean
         get() {
diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/annotations.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/annotations.kt
index 812cbee..6de4e20 100644
--- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/annotations.kt
+++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/annotations.kt
@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.fir
 
+import org.jetbrains.kotlin.config.LanguageFeature
+
 /**
  * [NoMutableState] annotation means that annotated class has no mutable state
  *   and it's safe to use it concurrent environment (e.g. as session component)
@@ -36,3 +38,11 @@
 @RequiresOptIn
 annotation class SessionConfiguration
 
+/**
+ * Declarations that are only being used in case some default language features are disabled: mostly likely due to using not the latest
+ * language version.
+ *
+ * Let's try to have a convention to use a relevant language feature name as a side comment.
+ */
+@RequiresOptIn
+annotation class OnlyForDefaultLanguageFeatureDisabled(val languageFeature: LanguageFeature)
diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt
index ab99bae..b12352a 100644
--- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt
+++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt
@@ -40,7 +40,8 @@
 
 class ConeCannotInferValueParameterType(
     val valueParameter: FirValueParameterSymbol,
-    override val reason: String = "Cannot infer type for parameter ${valueParameter.name}"
+    override val reason: String = "Cannot infer type for parameter ${valueParameter.name}",
+    val isTopLevelLambda: Boolean = false,
 ) : ConeCannotInferType()
 
 class ConeCannotInferReceiverParameterType(
diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirErrorExpressionRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirErrorExpressionRenderer.kt
index fea41be..ed65a2f 100644
--- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirErrorExpressionRenderer.kt
+++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirErrorExpressionRenderer.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.renderer
 
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 
 abstract class FirErrorExpressionRenderer {
@@ -17,6 +18,11 @@
 class FirErrorExpressionOnlyErrorRenderer : FirErrorExpressionRenderer() {
     override fun renderErrorExpression(errorExpression: FirErrorExpression) {
         printer.print("ERROR_EXPR(${errorExpression.diagnostic.reason})")
+        errorExpression.expression?.let {
+            if (errorExpression.source?.kind == KtFakeSourceElementKind.ErrorExpressionForTopLevelLambda) {
+                it.accept(components.visitor)
+            }
+        }
     }
 }
 
diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt
index fd09373..1fc0e32 100644
--- a/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt
+++ b/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt
@@ -504,6 +504,12 @@
      * For plugin-generated things
      */
     object PluginGenerated : KtFakeSourceElementKind()
+
+    /**
+     * To store some diagnostic for erroneously resolved top-level lambda
+     * See [org.jetbrains.kotlin.config.LanguageFeature.ResolveTopLevelLambdasAsSyntheticCallArgument] and its usages
+     */
+    object ErrorExpressionForTopLevelLambda : KtFakeSourceElementKind()
 }
 
 sealed class AbstractKtSourceElement {
diff --git a/compiler/testData/diagnostics/tests/FunctionReturnTypes.fir.kt b/compiler/testData/diagnostics/tests/FunctionReturnTypes.fir.kt
index 50fcf7c..9ebae20 100644
--- a/compiler/testData/diagnostics/tests/FunctionReturnTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/FunctionReturnTypes.fir.kt
@@ -173,31 +173,31 @@
 }
 
 fun testFunctionLiterals() {
-    val endsWithVarDeclaration : () -> Boolean = <!INITIALIZER_TYPE_MISMATCH!>{
-        val x = 2
-    }<!>
+    val endsWithVarDeclaration : () -> Boolean = {
+        <!RETURN_TYPE_MISMATCH!>val x = 2<!>
+    }
 
-    val endsWithAssignment: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
+    val endsWithAssignment: () -> Int = {
+        var x = 1
+        <!RETURN_TYPE_MISMATCH!>x = 333<!>
+    }
+
+    val endsWithReAssignment: () -> Int = {
+        var x = 1
+        <!RETURN_TYPE_MISMATCH!>x += 333<!>
+    }
+
+    val endsWithFunDeclaration : () -> String = {
         var x = 1
         x = 333
-    }<!>
+        <!RETURN_TYPE_MISMATCH!>fun meow() : Unit {}<!>
+    }
 
-    val endsWithReAssignment: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
-        var x = 1
-        x += 333
-    }<!>
-
-    val endsWithFunDeclaration : () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
+    val endsWithObjectDeclaration : () -> Int = {
         var x = 1
         x = 333
-        fun meow() : Unit {}
-    }<!>
-
-    val endsWithObjectDeclaration : () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
-        var x = 1
-        x = 333
-        <!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}
-    }<!>
+        <!RETURN_TYPE_MISMATCH!><!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}<!>
+    }
 
     val expectedUnitReturnType1: () -> Unit = {
         val x = 1
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.fir.kt
index 05a6a14..53e2957 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.fir.kt
@@ -4,16 +4,16 @@
 
 fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
 fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
-val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
-val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
+val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ 1 }<!>
 fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
 fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
 
 fun outer() {
     fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
-    val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
-    val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
+    val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+    val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ 1 }<!>
     fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
     fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
 }
@@ -21,16 +21,16 @@
 class Outer {
     fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
-    val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
-    val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
+    val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+    val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ 1 }<!>
     fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
     fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
 
     class Nested {
         fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
         fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
-        val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
-        val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
+        val test3: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+        val test4: () -> Int = fun (): Int = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>{ 1 }<!>
         fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
         fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
     }
diff --git a/compiler/testData/diagnostics/tests/extensions/contextReceivers/deprecated.fir.kt b/compiler/testData/diagnostics/tests/extensions/contextReceivers/deprecated.fir.kt
index 60e8bbf..b8510b1 100644
--- a/compiler/testData/diagnostics/tests/extensions/contextReceivers/deprecated.fir.kt
+++ b/compiler/testData/diagnostics/tests/extensions/contextReceivers/deprecated.fir.kt
@@ -45,7 +45,7 @@
     val x: <!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(A) () -> Unit = body
     val y = body
     val z: suspend <!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(A) B.() -> Unit = {}
-    val w: (<!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit, <!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit) -> (<!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit) = <!CONTEXT_RECEIVERS_DEPRECATED!>{ a, b -> { } }<!>
+    val w: (<!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit, <!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit) -> (<!CONTEXT_RECEIVERS_DEPRECATED!>context<!>(Int) () -> Unit) = { a, b -> { } }
     return {}
 }
 
diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.fir.kt b/compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.fir.kt
index 1b7149e..a50ac5d 100644
--- a/compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.fir.kt
@@ -3,8 +3,8 @@
     if (a == 1) return "4"
     when (a) {
         5 -> return "2"
-        3 -> return <!NULL_FOR_NONNULL_TYPE!>null<!>
-        2 -> return <!RETURN_TYPE_MISMATCH!>2<!>
+        3 -> return <!NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!>
+        2 -> return <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>2<!>
     }
     return ""
 }
@@ -13,7 +13,7 @@
     if (a == 1) return@l "4"
     when (a) {
         5 -> return@l "2"
-        3 -> return@l <!RETURN_TYPE_MISMATCH!>null<!>
+        3 -> return@l <!NULL_FOR_NONNULL_TYPE!>null<!>
         2 -> return@l <!RETURN_TYPE_MISMATCH!>2<!>
     }
     return@l ""
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
index 222c025..47504ce 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
@@ -4,11 +4,11 @@
 
     val a: () -> Unit = { bar += 4 }
 
-    val b: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{ bar = 4 }<!>
+    val b: () -> Int = { <!RETURN_TYPE_MISMATCH!>bar = 4<!> }
 
-    val c: () -> <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }
+    val c: () -> <!UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }
 
-    val d: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{ bar += 4 }<!>
+    val d: () -> Int = { <!RETURN_TYPE_MISMATCH!>bar += 4<!> }
 
     val e: Unit = run { bar += 4 }
 
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.fir.kt
index cd0abe9..905868a 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.fir.kt
@@ -6,7 +6,7 @@
 }
 
 val b: () -> Unit = l@ {
-    if (flag) return@l <!RETURN_TYPE_MISMATCH!>4<!>
+    if (flag) return@l <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>4<!>
 }
 
 val c: () -> Any = l@ {
@@ -18,6 +18,6 @@
     5
 }
 
-val e: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>l@ {
-    if (flag) 4
-}<!>
+val e: () -> Int = l@ {
+    <!RETURN_TYPE_MISMATCH!>if (flag) 4<!>
+}
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/kt66512.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/kt66512.fir.kt
index 10ba818..bd1cc47 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/kt66512.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/kt66512.fir.kt
@@ -9,7 +9,7 @@
 // ================= Lambdas assigned to a variable =================
 
 val expectedMyUnitExplicitReturnString: () -> MyUnit = l@ {
-    return@l <!RETURN_TYPE_MISMATCH!>""<!>
+    return@l <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>""<!>
 }
 
 // ============== Lambdas passed as function argument ===============
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/kt66534.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/kt66534.fir.kt
index 79bf1ac..2cf8bbb 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/kt66534.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/kt66534.fir.kt
@@ -67,7 +67,7 @@
 
 fun expectedFlexibleUnitExplicitReturnString() {
     A.foo = l@ {
-        return@l <!RETURN_TYPE_MISMATCH!>""<!>
+        return@l <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>""<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.fir.kt
index 5b81054..a419cc7 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.fir.kt
@@ -1,10 +1,10 @@
 // RUN_PIPELINE_TILL: FRONTEND
-val a = l@ <!UNRESOLVED_REFERENCE!>{
+val a = l@ {
     return@l <!UNRESOLVED_REFERENCE!>r<!>
-}<!>
+}
 
 val b = l@ {
     if ("" == "OK") return@l
 
     return@l <!UNRESOLVED_REFERENCE!>r<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/functionTypeInitializerTypeMismatch.fir.kt b/compiler/testData/diagnostics/tests/functionTypeInitializerTypeMismatch.fir.kt
index 831fd3a..9f64536 100644
--- a/compiler/testData/diagnostics/tests/functionTypeInitializerTypeMismatch.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionTypeInitializerTypeMismatch.fir.kt
@@ -1,14 +1,6 @@
 // RUN_PIPELINE_TILL: FRONTEND
 // RENDER_DIAGNOSTICS_MESSAGES
 
-val f1: () -> Int = { <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
-val f2: () -> Int = l@ {
-    return@l <!RETURN_TYPE_MISMATCH("Int; String")!>""<!>
-}
-val f3: () -> Int = l@ {
-    if (true) return@l 4
-    return@l <!RETURN_TYPE_MISMATCH("Int; String")!>""<!>
-}
 val f5: () -> Int = <!INITIALIZER_TYPE_MISMATCH("Function0<Int>; Function1<ERROR CLASS: Cannot infer type for parameter it, String>")!>{ <!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> "" }<!>
 val f6: () -> Int = <!INITIALIZER_TYPE_MISMATCH("Function0<Int>; Function1<Any, String>")!>{ it: Any -> "" }<!>
 val f7: () -> Int = {  -> <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
@@ -16,7 +8,7 @@
 val f9: String = <!INITIALIZER_TYPE_MISMATCH("String; Function0<String>")!>{  -> "" }<!>
 val f10: Function0<Int> = {  -> <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
 val f11: Function0<<!REDUNDANT_PROJECTION("Function0<out Int>")!>out<!> Int> = {  -> <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
-val f12: Function0<<!CONFLICTING_PROJECTION("Function0<in Int>")!>in<!> Int> = {  -> "" }
+val f12: Function0<<!CONFLICTING_PROJECTION("Function0<in Int>")!>in<!> Int> = {  -> <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
 val f13: Function0<*> = {  -> "" }
 val f14: Function<Int> = {  -> <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
 val f15: Function<Int> = { <!RETURN_TYPE_MISMATCH("Int; String")!>""<!> }
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.fir.kt
index 2c57d19..4fd739b 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.fir.kt
@@ -13,7 +13,7 @@
 
 val b: () -> Unit = l@{
     // Error, coercion can't be applied at this position!
-    if (true) return@l <!RETURN_TYPE_MISMATCH!>"hello"<!>
+    if (true) return@l <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>"hello"<!>
 
     // However, this is OK, because here coercion is applied
     "hello"
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt
index 98c2713..838d55e 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt
@@ -11,8 +11,8 @@
         return@l
     }
 
-    val c = l@<!CANNOT_INFER_PARAMETER_TYPE!>{
+    val c = l@{
         // Error: block doesn't have an expected type, so call can't be inferred!
         return@l <!CANNOT_INFER_PARAMETER_TYPE, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
-    }<!>
+    }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.fir.kt
index 8f88d85..2414791 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.fir.kt
@@ -10,9 +10,9 @@
 }
 
 fun noCoercionBlockHasExplicitType() {
-    val b: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
-        if (true) 42
-    }<!>
+    val b: () -> Int = {
+        <!RETURN_TYPE_MISMATCH!>if (true) 42<!>
+    }
 }
 
 fun noCoercionBlockHasExplicitReturn() {
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/wrongExpectedTypeForWhen.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/wrongExpectedTypeForWhen.fir.kt
index 4c8fb5e..9f7dbeb 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/wrongExpectedTypeForWhen.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/constraints/wrongExpectedTypeForWhen.fir.kt
@@ -1,6 +1,6 @@
 // RUN_PIPELINE_TILL: FRONTEND
 fun foo() {
-    var f: Int = <!INITIALIZER_TYPE_MISMATCH!>if (true) <!ARGUMENT_TYPE_MISMATCH!>{ x: Long ->  }<!> else { x: Long ->  }<!>
+    var f: Int = <!INITIALIZER_TYPE_MISMATCH!>if (true) <!ARGUMENT_TYPE_MISMATCH!>{ x: Long ->  }<!> else <!ARGUMENT_TYPE_MISMATCH!>{ x: Long ->  }<!><!>
 }
 
 class A {
diff --git a/compiler/testData/diagnostics/tests/inference/pcla/forceLambdaCompletionFromReturnStatement/earlyReturn.fir.kt b/compiler/testData/diagnostics/tests/inference/pcla/forceLambdaCompletionFromReturnStatement/earlyReturn.fir.kt
index a744731..856c0e4 100644
--- a/compiler/testData/diagnostics/tests/inference/pcla/forceLambdaCompletionFromReturnStatement/earlyReturn.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/pcla/forceLambdaCompletionFromReturnStatement/earlyReturn.fir.kt
@@ -8,9 +8,9 @@
 fun main(b: Boolean) {
     build { container ->
         if (b) {
-            return@build <!UNRESOLVED_REFERENCE!>{ <!VALUE_PARAMETER_WITHOUT_EXPLICIT_TYPE!>arg<!> ->
-                arg.<!UNRESOLVED_REFERENCE!>length<!>
-            }<!>
+            return@build { arg ->
+                arg.length
+            }
         }
         container.consume({ arg: String -> })
     }
diff --git a/compiler/testData/diagnostics/tests/inference/pcla/specialCallsWithLambdas.fir.kt b/compiler/testData/diagnostics/tests/inference/pcla/specialCallsWithLambdas.fir.kt
index 1dd79da..744791a3e 100644
--- a/compiler/testData/diagnostics/tests/inference/pcla/specialCallsWithLambdas.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/pcla/specialCallsWithLambdas.fir.kt
@@ -176,7 +176,7 @@
 
 fun poll84(): Flow<String> {
     return flow {
-        val inv = {<!RETURN_TYPE_MISMATCH!>{1}<!>} in setOf({{1f}})
+        val inv = {{<!RETURN_TYPE_MISMATCH!>1<!>}} in setOf({{1f}})
         <!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.fir.kt b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.fir.kt
index 5054697..4ac450f 100644
--- a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.fir.kt
@@ -1,6 +1,6 @@
 // RUN_PIPELINE_TILL: FRONTEND
 fun foo() {
-    fun bar() = <!RECURSION_IN_IMPLICIT_TYPES!>{
+    fun bar() = {
         <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
-    }<!>
+    }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt
index 1e0fec5..382a41b 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt
@@ -4,6 +4,6 @@
 fun <T, R, S> foo(block: (T)-> R, second: (T)-> S) = block
 
 fun main() {
-    val fff = <!UNRESOLVED_REFERENCE!>{ x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }<!>
+    val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
     <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>foo<!>(<!ARGUMENT_TYPE_MISMATCH!>fff<!>, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x + 1 })
 }
diff --git a/compiler/testData/diagnostics/tests/inference/underscoredTypeInForbiddenPositions.fir.kt b/compiler/testData/diagnostics/tests/inference/underscoredTypeInForbiddenPositions.fir.kt
index d5154ad..ff9f53a 100644
--- a/compiler/testData/diagnostics/tests/inference/underscoredTypeInForbiddenPositions.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/underscoredTypeInForbiddenPositions.fir.kt
@@ -47,7 +47,7 @@
     val x1cp = foo<Int, context(<!UNRESOLVED_REFERENCE!>_<!>) () -> Unit> { <!CANNOT_INFER_PARAMETER_TYPE!>{ "" }<!> }
     val x2 = foo<Int, (Int) -> <!UNRESOLVED_REFERENCE!>_<!>> { <!UNRESOLVED_REFERENCE!>{ it }<!> }
     val x3 = foo<Int, ((<!UNRESOLVED_REFERENCE!>_<!>)) -> <!UNRESOLVED_REFERENCE!>_<!>> { <!CANNOT_INFER_PARAMETER_TYPE!>{ it }<!> }
-    val x4 = <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE, FUNCTION_CALL_EXPECTED!>foo<!><!UNRESOLVED_REFERENCE!><<!>Int<!SYNTAX!>, _ -> Float><!> { <!UNRESOLVED_REFERENCE!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!> }
+    val x4 = <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE, FUNCTION_CALL_EXPECTED!>foo<!><!UNRESOLVED_REFERENCE!><<!>Int<!SYNTAX!>, _ -> Float><!> <!CANNOT_INFER_PARAMETER_TYPE!>{ { <!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 }<!> }
     val x7 = foo<Int, Foo<(Int) -> <!UNRESOLVED_REFERENCE!>_<!>>> { <!ARGUMENT_TYPE_MISMATCH!>{ it }<!> }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt235.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt235.fir.kt
index 73c85fa..a390148 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt235.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt235.fir.kt
@@ -5,29 +5,29 @@
 
 fun main() {
     val array = MyArray()
-    val f: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
-        array[2] = 23 //error: Type mismatch: inferred type is Int (!!!) but String was expected
-    }<!>
-    val g: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
+    val f: () -> String = {
+        <!RETURN_TYPE_MISMATCH!>array[2] = 23<!> //error: Type mismatch: inferred type is Int (!!!) but String was expected
+    }
+    val g: () -> String = {
         var x = 1
-        x += 2  //no error, but it should be here
-    }<!>
-    val h: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
+        <!RETURN_TYPE_MISMATCH!>x += 2<!>  //no error, but it should be here
+    }
+    val h: () -> String = {
         var x = 1
-        x = 2  //the same
-    }<!>
+        <!RETURN_TYPE_MISMATCH!>x = 2<!>  //the same
+    }
     val array1 = MyArray1()
-    val i: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
-        array1[2] = 23
-    }<!>
+    val i: () -> String = {
+        <!RETURN_TYPE_MISMATCH!>array1[2] = 23<!>
+    }
 
-    val fi: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
-        array[2] = 23
-    }<!>
-    val gi: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
+    val fi: () -> String = {
+        <!RETURN_TYPE_MISMATCH!>array[2] = 23<!>
+    }
+    val gi: () -> String = {
         var x = 1
-        x += 21
-    }<!>
+        <!RETURN_TYPE_MISMATCH!>x += 21<!>
+    }
 
     var m: MyNumber = MyNumber()
     val a: () -> MyNumber = {
diff --git a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt b/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
index 5773198..058beec 100644
--- a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
@@ -112,7 +112,7 @@
 
 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
     return <!RETURN_TYPE_MISMATCH!>{ l1 ->
-        l1()
-        <!TOO_MANY_ARGUMENTS!>{ <!CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!UNRESOLVED_REFERENCE!>l2<!>() }<!>
+        <!RETURN_TYPE_MISMATCH!>l1()
+        <!TOO_MANY_ARGUMENTS!>{ <!CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!UNRESOLVED_REFERENCE!>l2<!>() }<!><!>
     }<!>
 }
diff --git a/compiler/testData/diagnostics/tests/when/kt47922.fir.kt b/compiler/testData/diagnostics/tests/when/kt47922.fir.kt
index ca9f054..42a2f54 100644
--- a/compiler/testData/diagnostics/tests/when/kt47922.fir.kt
+++ b/compiler/testData/diagnostics/tests/when/kt47922.fir.kt
@@ -13,10 +13,10 @@
 
 sealed class ToState
 
-val sealedTest: SealedBase.() -> ToState? = <!INITIALIZER_TYPE_MISMATCH!>{
-    <!NO_ELSE_IN_WHEN!>when<!>(this) {}
-}<!>
+val sealedTest: SealedBase.() -> ToState? = {
+    <!RETURN_TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!>(this) {}<!>
+}
 
-val nonSealedTest: NonSealedBase.() -> ToState? = <!INITIALIZER_TYPE_MISMATCH!>{
-    when(this) {}
-}<!>
+val nonSealedTest: NonSealedBase.() -> ToState? = {
+    <!RETURN_TYPE_MISMATCH!>when(this) {}<!>
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/nullableUnitLiteral.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/nullableUnitLiteral.fir.kt
index 1047927..f65a443 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/nullableUnitLiteral.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/nullableUnitLiteral.fir.kt
@@ -4,8 +4,8 @@
 fun test() {
     val closeable: java.io.Closeable? = null
     val closeF = fun() { closeable?.close() }
-    val closeFB = fun(): Unit = <!RETURN_TYPE_MISMATCH!>closeable?.close()<!>
-    val closeFR = fun() { return <!RETURN_TYPE_MISMATCH!>closeable?.close()<!> }
+    val closeFB = fun(): Unit = <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>closeable?.close()<!>
+    val closeFR = fun() { return <!RETURN_TYPE_MISMATCH, RETURN_TYPE_MISMATCH!>closeable?.close()<!> }
     val closeL = { closeable?.close() }
     val closeLR = label@ { return@label closeable?.close() }
 }
diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt
index c92a921..f117096 100644
--- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt
+++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt
@@ -378,6 +378,8 @@
     AnnotationDefaultTargetMigrationWarning(KOTLIN_2_2, kind = BUG_FIX), // KT-73255, KT-73494
     AllowDnnTypeOverridingFlexibleType(KOTLIN_2_2, kind = OTHER), // KT-74049
 
+    ResolveTopLevelLambdasAsSyntheticCallArgument(KOTLIN_2_1), // KT-67869
+
     // 2.3
 
     ForbidCompanionInLocalInnerClass(KOTLIN_2_3, kind = BUG_FIX),
diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt
index ec540af..d9dadc0 100644
--- a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt
+++ b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt
@@ -229,7 +229,7 @@
 
     fun TypeConstructorMarker.isFinalClassConstructor(): Boolean
 
-    fun TypeVariableMarker.freshTypeConstructor(): TypeConstructorMarker
+    fun TypeVariableMarker./**/freshTypeConstructor(): TypeConstructorMarker
 
     fun CapturedTypeMarker.typeConstructorProjection(): TypeArgumentMarker
     fun CapturedTypeMarker.typeParameter(): TypeParameterMarker?