[FIR] Fix extension property reference resolution

On type with star projection
#KT-44372 Fixed

compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.fir.txt

@@ -40,8 +40,8 @@ FILE: referenceToExtension.kt
         }
 
         public final fun test_2(): R|kotlin/Unit| {
-            lval extensionValRef: <ERROR TYPE REF: Unresolved reference: extensionVal> = Q|GenericTest.B|::<Unresolved reference: extensionVal>#
-            lval extensionFunRef: <ERROR TYPE REF: Unresolved reference: extensionFun> = Q|GenericTest.B|::<Unresolved reference: extensionFun>#
+            lval extensionValRef: R|kotlin/reflect/KProperty1<GenericTest.B<*>, GenericTest.A<CapturedType(*)>>| = Q|GenericTest.B|::R|/GenericTest.extensionVal<kotlin/Any?>|
+            lval extensionFunRef: R|@ExtensionFunctionType kotlin/reflect/KFunction1<GenericTest.B<*>, GenericTest.A<CapturedType(*)>>| = Q|GenericTest.B|::R|/GenericTest.extensionFun<kotlin/Any?>|
         }
 
     }

compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.kt

@@ -17,8 +17,8 @@ class GenericTest {
     }
 
     fun test_2() {
-        val extensionValRef = B<*>::<!UNRESOLVED_REFERENCE!>extensionVal<!>
-        val extensionFunRef = B<*>::<!UNRESOLVED_REFERENCE!>extensionFun<!>
+        val extensionValRef = B<*>::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extensionVal<!>
+        val extensionFunRef = B<*>::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extensionFun<!>
     }
 }
 

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java

@@ -3339,6 +3339,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt");
             }
 
+            @Test
+            @TestMetadata("extensionProperty.kt")
+            public void testExtensionProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/function/extensionProperty.kt");
+            }
+
             @Test
             @TestMetadata("genericCallableReferenceArguments.kt")
             public void testGenericCallableReferenceArguments() throws Exception {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt

@@ -66,7 +66,8 @@ internal object CheckCallableReferenceExpectedType : CheckerStage() {
                     ?.let(candidate.substitutor::substituteOrSelf)
 
             if (resultingReceiverType != null && declarationReceiverType != null) {
-                addSubtypeConstraint(resultingReceiverType, declarationReceiverType, position)
+                val capturedReceiver = context.inferenceComponents.ctx.captureFromExpression(resultingReceiverType) ?: resultingReceiverType
+                addSubtypeConstraint(capturedReceiver, declarationReceiverType, position)
             }
         }
 

compiler/testData/codegen/box/callableReference/function/extensionProperty.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+
+fun box(): String {
+    val arr: Array<KClass<*>> = arrayOf(String::class, Number::class) as Array<KClass<*>>
+    val xs = arr.myMap { it.java }.toList()
+    val ys = arr.myMap(KClass<*>::java).toList()
+    if (xs != ys) return "fail1"
+    if (!arr.foo()) return "fail2"
+    return "OK"
+}
+
+public inline fun <A, B> Array<out A>.myMap(transform: (A) -> B): List<B> {
+    return mapTo(ArrayList<B>(size), transform)
+}
+
+fun Any?.foo(): Boolean {
+    val result = (this as Array<KClass<*>>).map(KClass<*>::java).toList()
+    val withLambda = (this as Array<KClass<*>>).map { it.java }.toList()
+    return result == withLambda
+}

compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt

@@ -24,10 +24,10 @@ fun <T> Foo2<T>.setX(y: T): T {
 fun Float.bar() {}
 
 fun test1() {
-    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Unresolved reference: setX")!>Foo<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
+    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction2<Foo<*>, CapturedType(*), CapturedType(*)>")!>Foo<*>::setX<!>
     val foo = Foo<Float>(1f)
 
-    fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, 1)
+    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
     foo.x.bar()
 }
@@ -42,10 +42,10 @@ fun test2() {
 }
 
 fun test3() {
-    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Unresolved reference: setX")!>Foo2<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
+    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction2<Foo2<*>, CapturedType(*), CapturedType(*)>")!>Foo2<*>::setX<!>
     val foo = Foo2<Int>(1)
 
-    fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, "")
+    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     foo.x.<!INAPPLICABLE_CANDIDATE!>bar<!>()
 }

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -3339,6 +3339,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                 runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt");
             }
 
+            @Test
+            @TestMetadata("extensionProperty.kt")
+            public void testExtensionProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/function/extensionProperty.kt");
+            }
+
             @Test
             @TestMetadata("genericCallableReferenceArguments.kt")
             public void testGenericCallableReferenceArguments() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -3339,6 +3339,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                 runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt");
             }
 
+            @Test
+            @TestMetadata("extensionProperty.kt")
+            public void testExtensionProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/function/extensionProperty.kt");
+            }
+
             @Test
             @TestMetadata("genericCallableReferenceArguments.kt")
             public void testGenericCallableReferenceArguments() throws Exception {

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -2922,6 +2922,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt");
             }
 
+            @TestMetadata("extensionProperty.kt")
+            public void testExtensionProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/function/extensionProperty.kt");
+            }
+
             @TestMetadata("genericCallableReferenceArguments.kt")
             public void testGenericCallableReferenceArguments() throws Exception {
                 runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferenceArguments.kt");