FIR checker: fix REFERENCE_BY_QUALIFIED positioning strategy to consider callable reference

compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt

@@ -4,10 +4,10 @@ class Your {
 
 class My {
     fun foo() {
-        val x = <!UNRESOLVED_REFERENCE!>::Nested<!> // Should be error
+        val x = ::<!UNRESOLVED_REFERENCE!>Nested<!> // Should be error
     }
 }
 
 fun Your.foo() {
-    val x = <!UNRESOLVED_REFERENCE!>::Nested<!> // Still should be error
+    val x = ::<!UNRESOLVED_REFERENCE!>Nested<!> // Still should be error
 }

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

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

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt

@@ -6,7 +6,7 @@ fun <T, R> foobaz(x: T): R = TODO()
 
 fun foo() {
     val x: (String) -> Int = ::bar
-    val y = <!UNRESOLVED_REFERENCE!>::bar<!>
+    val y = ::<!UNRESOLVED_REFERENCE!>bar<!>
     val z = ::baz
     val w: (String) -> Int = ::foobaz
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt

@@ -34,13 +34,13 @@ fun main() {
     <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
 
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(KotlinClass::<!UNRESOLVED_REFERENCE!>bar<!>)
     foo2(KotlinClass::bar)
     foo3(KotlinClass::bar)
 
     foo1(KotlinClass2::bar)
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(KotlinClass2::<!UNRESOLVED_REFERENCE!>bar<!>)
     foo3(KotlinClass2::bar)
 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.kt

@@ -4,5 +4,5 @@ fun foo(y: String) {}
 fun <T> bar(f: (T) -> Unit) {}
 
 fun test() {
-    bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.kt

@@ -25,7 +25,7 @@ fun test() {
 
             val t3 = bar(::baz)
 
-            bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
+            bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
         }
     }
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.kt

@@ -22,5 +22,5 @@ fun test() {
 
     val a6 = foo(::singleA, ::singleB)
 
-    foo(<!UNRESOLVED_REFERENCE!>::multiple<!>, <!UNRESOLVED_REFERENCE!>::multiple<!>)
+    foo(::<!UNRESOLVED_REFERENCE!>multiple<!>, ::<!UNRESOLVED_REFERENCE!>multiple<!>)
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/moreSpecificAmbiguousExtensions.kt

@@ -6,14 +6,14 @@ fun IB.extFun(x: IA) {}
 
 fun test() {
     val extFun1 = IA::extFun
-    val extFun2 = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun2 = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
 }
 
 fun testWithExpectedType() {
     // NB: should be resolved to kotlin/FunctionX, not kotlin/reflect/FunctionX
     val extFun_AB_A: IA.(IB) -> Unit = IA::extFun
-    val extFun_AA_B: IA.(IA) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun_AA_B: IA.(IA) -> Unit = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
     val extFun_BB_A: IB.(IB) -> Unit = IA::extFun
     val extFun_BA_B: IB.(IA) -> Unit = IB::extFun
-    val extFun_BB_B: IB.(IB) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun_BB_B: IB.(IB) -> Unit = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt

@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
 fun <T> baz(e: T, f: (T) -> Unit) {}
 
 fun test(a: A, b: B) {
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>fooB<!>, a)
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt

@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
 fun foo() = use(::bar)
 fun bar(x: String) = 1
 
-fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)
+fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(::<!UNRESOLVED_REFERENCE!>loop2<!>)
 fun loop2() = loop1()

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt

@@ -6,5 +6,5 @@ fun bar(): Int = 1
 fun bar(x: String): Int = 1
 
 fun main() {
-    <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
+    <!AMBIGUITY!>foo<!>(::<!UNRESOLVED_REFERENCE!>bar<!>)
 }