[FIR] Report missing ASSIGNMENT_TYPE_MISMATCH on functional types

^KT-45989

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt

@@ -449,10 +449,6 @@ fun checkTypeMismatch(
     val typeContext = context.session.typeContext
 
     if (!isSubtypeForTypeMismatch(typeContext, subtype = rValueType, supertype = lValueType)) {
-        if (lValueType.isExtensionFunctionType || rValueType.isExtensionFunctionType) {
-            // TODO: remove after fix of KT-45989
-            return
-        }
         val resolvedSymbol = assignment?.calleeReference?.toResolvedCallableSymbol() as? FirPropertySymbol
         when {
             resolvedSymbol != null && lValueType is ConeCapturedType && lValueType.constructor.projection.kind.let {

compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt

@@ -24,7 +24,7 @@ class A : (<!WRONG_ANNOTATION_TARGET!>@Ann<!> Int)->Unit {
 @Target(AnnotationTarget.TYPE)
 annotation class TypeAnn
 
-val onType: (@TypeAnn A).(@Ann a: @TypeAnn A, @TypeAnn A)->@TypeAnn A? = { null }
+val onType: (@TypeAnn A).(@Ann a: @TypeAnn A, @TypeAnn A)->@TypeAnn A? = <!INITIALIZER_TYPE_MISMATCH!>{ null }<!>
 
 fun (@TypeAnn A).extFun(@Ann a: @TypeAnn A): @TypeAnn A? = null
 

compiler/testData/diagnostics/tests/functionAsExpression/FunctionType.fir.kt

@@ -27,5 +27,5 @@ fun testReceiverType() {
 
     val bas: String.() -> Unit = fun String.() {}
 
-    val bag: Int.() -> Unit = fun String.() {}
-}
+    val bag: Int.() -> Unit = <!INITIALIZER_TYPE_MISMATCH!>fun String.() {}<!>
+}

compiler/testData/diagnostics/tests/functionLiterals/kt56138.fir.kt

@@ -5,9 +5,9 @@ fun takeLambda1(f: String.() -> String) {}
 fun takeLambda2(f: String.(String) -> String) {}
 
 fun test_1() {
-    val x1: String.(String) -> String = { str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }
+    val x1: String.(String) -> String = <!INITIALIZER_TYPE_MISMATCH!>{ str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }<!>
     val x2: String.() -> String = { <!UNRESOLVED_REFERENCE!>it<!> }
-    val x3: String.() -> String = { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "x" }
+    val x3: String.() -> String = <!INITIALIZER_TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "x" }<!>
 }
 
 fun test_2() {

compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt

@@ -23,7 +23,7 @@ fun main() {
     foo(<!ARGUMENT_TYPE_MISMATCH!>fun(): String = "1"<!>)
     foo(((<!ARGUMENT_TYPE_MISMATCH!>fun(): String = "1"<!>)))
 
-    val a10: Int.(String) -> Int = fun (x: String) = 10
+    val a10: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!>
     val a11: () -> () -> () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() = fun(): String = "1"<!>
 
     val a12: Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>

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

@@ -153,7 +153,7 @@ fun main() {
     // Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
     select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), <!ARGUMENT_TYPE_MISMATCH!>{ x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> x }<!>)
     select(id(id(fun(x: String, y: String) { }), <!TOO_MANY_ARGUMENTS!>fun String.(x: String) {}<!>), { x, y -> x })
-    val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
+    val x26: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!> // it must be error, see KT-38439
     // Receiver must be specified in anonymous function declaration
     val x27: Int.(String) -> Int = id(<!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>fun (x: String) = 10<!>)
     select(id<Int.(String) -> Unit> {}, { x: Int, y: String -> x })

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

@@ -5,5 +5,5 @@ val test2f: suspend Any.() -> Unit = fun Any.() {}
 
 // This is a bug in the old inference and should be fixed in new inference
 // see "Fix anonymous function literals handling in type checker" for more details
-val test3f: suspend Any.(Int) -> Int = fun (k: Int) = k + 1
-val test4f: SuspendFn = fun Any.() {}
+val test3f: suspend Any.(Int) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
+val test4f: SuspendFn = <!INITIALIZER_TYPE_MISMATCH!>fun Any.() {}<!>

compiler/testData/diagnostics/tests/when/kt47922.fir.kt

@@ -12,10 +12,10 @@ abstract class NonSealedBase {
 
 sealed class ToState
 
-val sealedTest: SealedBase.() -> ToState? = {
+val sealedTest: SealedBase.() -> ToState? = <!INITIALIZER_TYPE_MISMATCH!>{
     <!NO_ELSE_IN_WHEN!>when<!>(this) {}
-}
+}<!>
 
-val nonSealedTest: NonSealedBase.() -> ToState? = {
+val nonSealedTest: NonSealedBase.() -> ToState? = <!INITIALIZER_TYPE_MISMATCH!>{
     when(this) {}
-}
+}<!>