FIR checker: fix REFERENCE_BY_QUALIFIED positioning strategy to consider callable reference

compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/callableReferenceOnUnresolvedLHS.fir.kt

@@ -6,8 +6,8 @@ class Impl : Inv
 class Scope<InterfaceT, ImplementationT : InterfaceT>(private val implClass: <!UNRESOLVED_REFERENCE!>j.Class<ImplementationT><!>) {
     fun foo(c: Collection<InterfaceT>) {
         val hm = c.asSequence()
-            .<!INAPPLICABLE_CANDIDATE!>filter<!>(<!UNRESOLVED_REFERENCE!>implClass::isInstance<!>)
-            .<!INAPPLICABLE_CANDIDATE!>map<!>(<!UNRESOLVED_REFERENCE!>implClass::cast<!>)
+            .<!INAPPLICABLE_CANDIDATE!>filter<!>(implClass::<!UNRESOLVED_REFERENCE!>isInstance<!>)
+            .<!INAPPLICABLE_CANDIDATE!>map<!>(implClass::<!UNRESOLVED_REFERENCE!>cast<!>)
             .toSet()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.fir.kt

@@ -11,7 +11,7 @@ suspend fun String.id(): String = this
 fun box() {
     val x = "f"
     builder {
-        <!INAPPLICABLE_CANDIDATE!>go1<!>(<!UNRESOLVED_REFERENCE!>x::id<!>)
-        <!INAPPLICABLE_CANDIDATE!>go2<!>(<!UNRESOLVED_REFERENCE!>x::id<!>)
+        <!INAPPLICABLE_CANDIDATE!>go1<!>(x::<!UNRESOLVED_REFERENCE!>id<!>)
+        <!INAPPLICABLE_CANDIDATE!>go2<!>(x::<!UNRESOLVED_REFERENCE!>id<!>)
     }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.fir.kt

@@ -15,8 +15,8 @@ suspend fun bar(x: Int) {}
 
 fun test() {
     test0(::foo)
-    <!INAPPLICABLE_CANDIDATE!>test1<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>test1<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>test0<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
+    <!INAPPLICABLE_CANDIDATE!>test0<!>(::<!UNRESOLVED_REFERENCE!>bar<!>)
     test1(::bar)
 }

compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.fir.kt

@@ -3,6 +3,6 @@
 internal class Z<K> {
     val map = HashMap<String, String>()
     inline fun compute(key: String, producer: () -> String): String {
-        return map.<!INAPPLICABLE_CANDIDATE!>getOrPut<!>(key, <!UNRESOLVED_REFERENCE!>::producer<!>)
+        return map.<!INAPPLICABLE_CANDIDATE!>getOrPut<!>(key, ::<!UNRESOLVED_REFERENCE!>producer<!>)
     }
 }

compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/callableReferences.fir.kt

@@ -49,7 +49,7 @@ fun main() {
     select(id(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction1<A, kotlin.Unit>")!>::foo4<!>), id { x: A -> }, id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> })
     select(id(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction1<B, kotlin.Unit>")!>::foo4<!>), id { x: B -> }, id { <!DEBUG_INFO_EXPRESSION_TYPE("B")!>it<!> })
     // Expected ambiguity
-    select(id(<!UNRESOLVED_REFERENCE!>::foo4<!>), id { x: A -> }, id { x: B -> }, id { <!DEBUG_INFO_EXPRESSION_TYPE("A & B")!>it<!> })
+    select(id(::<!UNRESOLVED_REFERENCE!>foo4<!>), id { x: A -> }, id { x: B -> }, id { <!DEBUG_INFO_EXPRESSION_TYPE("A & B")!>it<!> })
 
     select(id(::foo5), id { x: A -> }, id { x: B -> }, id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> })
 

compiler/testData/diagnostics/testsWithStdLib/inference/kt42620.fir.kt

@@ -3,13 +3,13 @@
 class Foo
 
 fun main1() = when {
-    else -> <!UNRESOLVED_REFERENCE!>Foo::plus<!>
+    else -> Foo::<!UNRESOLVED_REFERENCE!>plus<!>
 }
 
 fun main2() = if (true) Foo::minus else Foo::times
 
 fun main3() = if (true) { Foo::minus } else { Foo::times }
 
-fun main4() = try { Foo::minus } finally { <!UNRESOLVED_REFERENCE!>Foo::times<!> }
+fun main4() = try { Foo::minus } finally { Foo::<!UNRESOLVED_REFERENCE!>times<!> }
 
 fun main5() = Foo::minus ?: Foo::times