FIR initializer: don't report type mismatch on incompatible extensions

This commit suppresses type mismatch error from KT-45989

compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java

@@ -2691,6 +2691,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/problems/doubleGenericDiamond.kt");
         }
 
+        @TestMetadata("fakeTypeMismatchOnExtensionReference.kt")
+        public void testFakeTypeMismatchOnExtensionReference() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt");
+        }
+
         @TestMetadata("falseIntersection.kt")
         public void testFalseIntersection() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/problems/falseIntersection.kt");

compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.fir.txt

@@ -0,0 +1,20 @@
+FILE: fakeTypeMismatchOnExtensionReference.kt
+    public abstract interface IrElement : R|kotlin/Any| {
+    }
+    public final fun R|IrElement|.dumpKotlinLike(options: R|kotlin/String| = String()): R|kotlin/String| {
+        ^dumpKotlinLike String()
+    }
+    public final fun R|IrElement|.dump(normalizeNames: R|kotlin/Boolean| = Boolean(false)): R|kotlin/String| {
+        ^dump String()
+    }
+    public final fun foo(dumpStrategy: R|kotlin/String|): R|kotlin/Unit| {
+        lval dump: R|IrElement.() -> kotlin/String| = when () {
+            ==(R|<local>/dumpStrategy|, String(KotlinLike)) ->  {
+                Q|IrElement|::R|/dumpKotlinLike|
+            }
+            else ->  {
+                Q|IrElement|::R|/dump|
+            }
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt

@@ -0,0 +1,8 @@
+interface IrElement
+
+fun IrElement.dumpKotlinLike(options: String = ""): String = ""
+fun IrElement.dump(normalizeNames: Boolean = false): String = ""
+
+fun foo(dumpStrategy: String) {
+    val dump: IrElement.() -> String = if (dumpStrategy == "KotlinLike") IrElement::dumpKotlinLike else IrElement::dump
+}

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java

@@ -3047,6 +3047,12 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest {
                 runTest("compiler/fir/analysis-tests/testData/resolve/problems/doubleGenericDiamond.kt");
             }
 
+            @Test
+            @TestMetadata("fakeTypeMismatchOnExtensionReference.kt")
+            public void testFakeTypeMismatchOnExtensionReference() throws Exception {
+                runTest("compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt");
+            }
+
             @Test
             @TestMetadata("falseIntersection.kt")
             public void testFalseIntersection() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -3081,6 +3081,12 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
                 runTest("compiler/fir/analysis-tests/testData/resolve/problems/doubleGenericDiamond.kt");
             }
 
+            @Test
+            @TestMetadata("fakeTypeMismatchOnExtensionReference.kt")
+            public void testFakeTypeMismatchOnExtensionReference() throws Exception {
+                runTest("compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt");
+            }
+
             @Test
             @TestMetadata("falseIntersection.kt")
             public void testFalseIntersection() throws Exception {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInitializerTypeMismatchChecker.kt

@@ -35,6 +35,9 @@ object FirInitializerTypeMismatchChecker : FirPropertyChecker() {
                 // val p: Byte = 42 or similar situation
                 return
             }
+            if (propertyType.isExtensionFunctionType || expressionType.isExtensionFunctionType) {
+                return
+            }
             val source = declaration.source ?: return
             reporter.report(INITIALIZER_TYPE_MISMATCH.on(source, propertyType, expressionType), context)
         }

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

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

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

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

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

@@ -23,7 +23,7 @@ fun main() {
     foo(fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
     foo(((fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)))
 
-    val a10: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!>
+    val a10: Int.(String) -> Int = fun (x: String) = 10
     val a11: () -> () -> () -> Int = 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) { }), { x, 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 = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!> // it must be error, see KT-38439
+    val x26: Int.(String) -> Int = 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(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 = <!INITIALIZER_TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
+val test3f: suspend Any.(Int) -> Int = fun (k: Int) = k + 1
-val test4f: SuspendFn = <!INITIALIZER_TYPE_MISMATCH!>fun Any.() {}<!>
+val test4f: SuspendFn = fun Any.() {}