Raw FIR: use lambda parameter type if available

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
@@ -155,7 +154,7 @@ class ExpressionsConverter(
                     val multiParameter = buildValueParameter {
                         session = baseSession
                         origin = FirDeclarationOrigin.Source
-                        returnTypeRef = buildImplicitTypeRef()
+                        returnTypeRef = valueParameter.firValueParameter.returnTypeRef
                         this.name = name
                         symbol = FirVariableSymbol(name)
                         defaultValue = null

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1106,7 +1106,7 @@ class RawFirBuilder(
                             source = valueParameter.toFirSourceElement()
                             session = baseSession
                             origin = FirDeclarationOrigin.Source
-                            returnTypeRef = buildImplicitTypeRef {
+                            returnTypeRef = valueParameter.typeReference?.convertSafe() ?: buildImplicitTypeRef {
                                 source = multiDeclaration.toFirSourceElement(FirFakeSourceElementKind.ImplicitTypeRef)
                             }
                             this.name = name
@@ -1124,7 +1124,7 @@ class RawFirBuilder(
                         ) { toFirOrImplicitType() }
                         multiParameter
                     } else {
-                        val typeRef = buildImplicitTypeRef {
+                        val typeRef = valueParameter.typeReference?.convertSafe() ?: buildImplicitTypeRef {
                             source = implicitTypeRefSource
                         }
                         valueParameter.toFirValueParameter(typeRef)

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt

@@ -9,9 +9,9 @@ fun <X, Y> foo(y: Y, x: (X, Y) -> Unit) {}
 
 fun bar(aInstance: A, bInstance: B) {
     foo("") {
-        <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a, b): A<!>, c ->
+        (a, b): A, c ->
-        a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        a checkType { _<Int>() }
-        b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        b checkType { _<String>() }
         c checkType { _<String>() }
     }
 

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.fir.kt

@@ -27,7 +27,7 @@ fun bar(aList: List<A>) {
         b checkType { _<String>() }
     }
 
-    aList.foo { (a, b): B ->
+    aList.<!INAPPLICABLE_CANDIDATE!>foo<!> { (a, b): B ->
         b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt

@@ -4,23 +4,23 @@
 data class A(val x: Int, val y: String)
 
 fun bar() {
-    val x = { <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a, b): A<!> ->
+    val x = { (a, b): A ->
-        a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        a checkType { _<Int>() }
-        b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        b checkType { _<String>() }
     }
 
     x checkType { _<(A) -> Unit>() }
 
-    val y = { <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a: Int, b): A<!> ->
+    val y = { (a: Int, b): A ->
         a checkType { _<Int>() }
-        b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        b checkType { _<String>() }
     }
 
     y checkType { _<(A) -> Unit>() }
 
-    val y2 = { <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a: Number, b): A<!> ->
+    val y2 = { (a: Number, b): A ->
         a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        b checkType { _<String>() }
     }
 
     y2 checkType { _<(A) -> Unit>() }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.fir.kt

@@ -47,8 +47,8 @@ fun bar() {
         b checkType { _<String>() }
     }
 
-    foo { (a, b): B ->
+    <!INAPPLICABLE_CANDIDATE!>foo<!> { (a, b): B ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+        a checkType { _<Double>() }
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Short>() }
+        b checkType { _<Short>() }
     }
 }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.fir.kt

@@ -56,8 +56,8 @@ fun bar() {
         b checkType { _<String>() }
     }
 
-    foo { (_, b): B ->
+    <!INAPPLICABLE_CANDIDATE!>foo<!> { (_, b): B ->
         <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Short>() }
+        b checkType { _<Short>() }
     }
 }