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 extensionValRef = B<*>::<!UNRESOLVED_REFERENCE!>extensionVal<!>
-        val extensionFunRef = <!UNRESOLVED_REFERENCE!>B<*>::extensionFun<!>
+        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 extensionValRef = B::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extensionVal<!>
-        val extensionFunRef = <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>B::extensionFun<!>
+        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!>baz<!>(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
+    <!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<!>)
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt

@@ -378,7 +378,10 @@ object LightTreePositioningStrategies {
             if (node.tokenType == KtNodeTypes.CALL_EXPRESSION || node.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL) {
                 return markElement(tree.referenceExpression(node) ?: node, startOffset, endOffset, tree, node)
             }
-            if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION && node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION) {
+            if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION &&
+                node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION &&
+                node.tokenType != KtNodeTypes.CALLABLE_REFERENCE_EXPRESSION
+            ) {
                 return super.mark(node, startOffset, endOffset, tree)
             }
             val selector = tree.selector(node)
@@ -533,14 +536,14 @@ fun FlyweightCapableTreeStructure<LighterASTNode>.selector(node: LighterASTNode)
     val childrenRef = Ref<Array<LighterASTNode?>>()
     getChildren(node, childrenRef)
     val children = childrenRef.get() ?: return null
-    var dotFound = false
+    var dotOrDoubleColonFound = false
     for (child in children) {
         if (child == null) continue
-        if (child.tokenType == KtTokens.DOT) {
+        if (child.tokenType == KtTokens.DOT || child.tokenType == KtTokens.COLONCOLON) {
-            dotFound = true
+            dotOrDoubleColonFound = true
             continue
         }
-        if (dotFound && (child.tokenType == KtNodeTypes.CALL_EXPRESSION || child.tokenType == KtNodeTypes.REFERENCE_EXPRESSION)) {
+        if (dotOrDoubleColonFound && (child.tokenType == KtNodeTypes.CALL_EXPRESSION || child.tokenType == KtNodeTypes.REFERENCE_EXPRESSION)) {
             return child
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt

@@ -753,6 +753,7 @@ object PositioningStrategies {
                         is KtReferenceExpression -> return mark(selectorExpression)
                     }
                 }
+                is KtCallableReferenceExpression -> return mark(element.callableReference)
                 is KtCallExpression -> return mark(element.calleeExpression ?: element)
                 is KtConstructorDelegationCall -> return mark(element.calleeExpression ?: element)
                 is KtSuperTypeCallEntry -> return mark(element.calleeExpression)

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

@@ -4,7 +4,7 @@
 
 fun f1(x: String) {}
 fun f2(f: () -> Unit) {}
-fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(<!UNRESOLVED_REFERENCE!>::f1<!>)
+fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(::<!UNRESOLVED_REFERENCE!>f1<!>)
 
 
 @Target(AnnotationTarget.TYPE_PARAMETER,  AnnotationTarget.TYPE)

compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt

@@ -6,10 +6,10 @@ public interface J {
 
 // FILE: test.kt
 
-fun f1(x: Int?): Any = <!UNRESOLVED_REFERENCE!>x::hashCode<!>
+fun f1(x: Int?): Any = x::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <T> f2(t: T): Any = <!UNRESOLVED_REFERENCE!>t::hashCode<!>
+fun <T> f2(t: T): Any = t::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <S : String?> f3(s: S): Any = <!UNRESOLVED_REFERENCE!>s::hashCode<!>
+fun <S : String?> f3(s: S): Any = s::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <U : Any> f4(u: U?): Any = <!UNRESOLVED_REFERENCE!>u::hashCode<!>
+fun <U : Any> f4(u: U?): Any = u::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun f5(c: List<*>): Any = <!UNRESOLVED_REFERENCE!>c[0]::hashCode<!>
+fun f5(c: List<*>): Any = c[0]::<!UNRESOLVED_REFERENCE!>hashCode<!>
 
 fun f6(j: J): Any = j.platformString()::hashCode

compiler/testData/diagnostics/tests/callableReference/bound/functionCallWithoutArguments.fir.kt

@@ -1 +1 @@
-fun test() = <!UNRESOLVED_REFERENCE!>("").<!UNRESOLVED_REFERENCE!>hashCode<!>::hashCode<!>
+fun test() = ("").<!UNRESOLVED_REFERENCE!>hashCode<!>::<!UNRESOLVED_REFERENCE!>hashCode<!>

compiler/testData/diagnostics/tests/callableReference/bound/innerNested.fir.kt

@@ -1,9 +0,0 @@
-class Outer {
-    class Nested
-    inner class Inner
-}
-
-fun test() {
-    Outer()::Inner
-    <!UNRESOLVED_REFERENCE!>Outer()::Nested<!>
-}

compiler/testData/diagnostics/tests/callableReference/bound/innerNested.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Outer {
     class Nested
     inner class Inner

compiler/testData/diagnostics/tests/callableReference/bound/kt12843.fir.kt

@@ -1,6 +1,6 @@
 class Foo {
     fun bar() {}
-    fun f() = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::bar<!>
+    fun f() = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::<!UNRESOLVED_REFERENCE!>bar<!>
 }
 
-val f: () -> Unit = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::foo<!>
+val f: () -> Unit = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::<!UNRESOLVED_REFERENCE!>foo<!>

compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.fir.kt

@@ -1,14 +0,0 @@
-// FILE: A.java
-
-public class A {
-    public static void test() {}
-}
-
-// FILE: test.kt
-
-enum class E { EN }
-
-fun test() {
-    <!UNRESOLVED_REFERENCE!>A()::test<!>
-    <!UNRESOLVED_REFERENCE!>E.EN::valueOf<!>
-}

compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public class A {

compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt

@@ -18,9 +18,9 @@ class Test {
     val <T> List<T>.b: Int? get() = size
 
     fun <T> List<T>.testCallable1(): () -> Unit = a<T>::foo
-    fun <T> List<T>.testCallable2(): () -> Unit = <!UNRESOLVED_REFERENCE!>b?::foo<!>
+    fun <T> List<T>.testCallable2(): () -> Unit = b?::<!UNRESOLVED_REFERENCE!>foo<!>
-    fun <T> List<T>.testCallable3(): () -> Unit = <!UNRESOLVED_REFERENCE!>b<T, Any>::foo<!>
+    fun <T> List<T>.testCallable3(): () -> Unit = b<T, Any>::<!UNRESOLVED_REFERENCE!>foo<!>
-    fun <T> List<T>.testCallable4(): () -> Unit = <!UNRESOLVED_REFERENCE!>b<T>?::foo<!>
+    fun <T> List<T>.testCallable4(): () -> Unit = b<T>?::<!UNRESOLVED_REFERENCE!>foo<!>
 
     fun <T> List<T>.testClassLiteral1() = a<T>::class
     fun <T> List<T>.testClassLiteral2() = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>b<!>?::class

compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt

@@ -4,4 +4,4 @@ package test
 fun nullableFun(): Int? = null
 fun Int.foo() {}
 
-val test1 = <!UNRESOLVED_REFERENCE!>nullableFun()?::foo<!>
+val test1 = nullableFun()?::<!UNRESOLVED_REFERENCE!>foo<!>

compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt

@@ -19,6 +19,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
 fun <R : A> B<R>.test(){
     foo(A::bla)
     bar(A::bla)
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(<!UNRESOLVED_REFERENCE!>A::bla<!>)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(A::<!UNRESOLVED_REFERENCE!>bla<!>)
     star(A::bla)
 }

compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt

@@ -15,5 +15,5 @@ fun <K, V> B<K>.foo(p: KProperty1<K, V>) {}
 class C : A
 
 fun <R : A> B<R>.test(){
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>C::bla<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(C::<!UNRESOLVED_REFERENCE!>bla<!>)
 }

compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt

@@ -8,6 +8,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
 fun cr() {}
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, <!UNRESOLVED_REFERENCE!>::cr<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
     <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
 }

compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt

@@ -5,8 +5,8 @@ annotation class C
 enum class D
 
 fun main() {
-    <!UNRESOLVED_REFERENCE!>::A<!>
+    ::<!UNRESOLVED_REFERENCE!>A<!>
     ::B
-    <!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>::C<!>   // KT-3465
+    ::<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>C<!>   // KT-3465
-    <!UNRESOLVED_REFERENCE!>::D<!>
+    ::<!UNRESOLVED_REFERENCE!>D<!>
 }

compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.fir.kt

@@ -3,7 +3,7 @@ fun foo(x: Int, y: Any) = x
 fun foo(x: Any, y: Int) = y
 
 fun main() {
-    <!UNRESOLVED_REFERENCE!>::foo<!>
+    ::<!UNRESOLVED_REFERENCE!>foo<!>
     
-    val fooRef: (Int, Any) -> Unit = <!UNRESOLVED_REFERENCE!>::foo<!>
+    val fooRef: (Int, Any) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>
 }

compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.fir.kt

@@ -1,5 +0,0 @@
-annotation class Ann(val prop: String)
-
-val annCtorRef = <!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>::Ann<!>
-val annClassRef = Ann::class
-val annPropRef = Ann::prop

compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 annotation class Ann(val prop: String)
 
 val annCtorRef = ::<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>Ann<!>

compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.fir.kt

@@ -1,16 +0,0 @@
-// FILE: Foo.kt
-
-package test
-
-class Foo {
-    fun bar() {}
-}
-
-// FILE: test.kt
-
-import test.Foo
-
-fun Foo(): String = ""
-
-val f = Foo::bar
-val g = <!UNRESOLVED_REFERENCE!>Foo::length<!>

compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: Foo.kt
 
 package test

compiler/testData/diagnostics/tests/callableReference/function/constructorOfNestedClassInObject.fir.kt

@@ -16,6 +16,6 @@ fun test() {
 
     Outer.Companion::Wrapper
     (Outer.Companion)::Wrapper
-    <!UNRESOLVED_REFERENCE!>Outer::Wrapper<!>
+    Outer::<!UNRESOLVED_REFERENCE!>Wrapper<!>
-    <!UNRESOLVED_REFERENCE!>(Outer)::Wrapper<!>
+    (Outer)::<!UNRESOLVED_REFERENCE!>Wrapper<!>
 }

compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.fir.kt

@@ -1,31 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-// FILE: a.kt
-
-package first
-
-import checkSubtype
-
-class A
-
-fun A.foo() {}
-fun A.bar() {}
-fun A.baz() {}
-
-// FILE: b.kt
-
-package other
-
-import kotlin.reflect.KFunction1
-
-import first.A
-import first.foo
-import checkSubtype
-
-fun main() {
-    val x = first.A::foo
-    <!UNRESOLVED_REFERENCE!>first.A::bar<!>
-    <!UNRESOLVED_REFERENCE!>A::baz<!>
-
-    checkSubtype<KFunction1<A, Unit>>(x)
-}

compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 // FILE: a.kt

compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.fir.kt

@@ -1,20 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
-class A {
-    fun Int.extInt() = 42
-    fun A.extA(x: String) = x
-    
-    fun main() {
-        <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>Int::extInt<!>
-        <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>A::extA<!>
-
-        eat(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>Int::extInt<!>)
-        eat(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>A::extA<!>)
-    }
-}
-
-fun eat(value: Any) {}
-
-fun main() {
-    <!UNRESOLVED_REFERENCE!>A::extInt<!>
-    <!UNRESOLVED_REFERENCE!>A::extA<!>
-}

compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
 class A {
     fun Int.extInt() = 42

compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.fir.kt

@@ -26,9 +26,9 @@ class A {
 
 class B {
     fun main() {
-        <!UNRESOLVED_REFERENCE!>::Inner<!>
+        ::<!UNRESOLVED_REFERENCE!>Inner<!>
         val y = A::Inner
 
         checkSubtype<KFunction1<A, A.Inner>>(y)
     }
-}
+}

compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.fir.kt

@@ -1,23 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-// !LANGUAGE: +CallableReferencesToClassMembersWithEmptyLHS
-
-import kotlin.reflect.KFunction1
-
-class A {
-    inner class Inner
-}
-    
-fun A.main() {
-    ::Inner
-    val y = A::Inner
-
-    checkSubtype<KFunction1<A, A.Inner>>(y)
-}
-
-fun Int.main() {
-    <!UNRESOLVED_REFERENCE!>::Inner<!>
-    val y = A::Inner
-
-    checkSubtype<KFunction1<A, A.Inner>>(y)
-}

compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 // !LANGUAGE: +CallableReferencesToClassMembersWithEmptyLHS

compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.fir.kt

@@ -1,14 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KFunction1
-
-class A {
-    inner class Inner
-}
-
-fun main() {
-    <!UNRESOLVED_REFERENCE!>::Inner<!>
-    val y = A::Inner
-
-    checkSubtype<KFunction1<A, A.Inner>>(y)
-}

compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 import kotlin.reflect.KFunction1

compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.fir.kt

@@ -1,33 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KFunction0
-
-class A {
-    class Nested
-    
-    fun main() {
-        val x = ::Nested
-        val y = A::Nested
-
-        checkSubtype<KFunction0<Nested>>(x)
-        checkSubtype<KFunction0<Nested>>(y)
-    }
-    
-    companion object {
-        fun main() {
-            ::Nested
-            val y = A::Nested
-
-            checkSubtype<KFunction0<A.Nested>>(y)
-        }
-    }
-}
-
-class B {
-    fun main() {
-        <!UNRESOLVED_REFERENCE!>::Nested<!>
-        val y = A::Nested
-
-        checkSubtype<KFunction0<A.Nested>>(y)
-    }
-}

compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 import kotlin.reflect.KFunction0

compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.fir.kt

@@ -1,21 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KFunction0
-
-class A {
-    class Nested
-}
-    
-fun A.main() {
-    <!UNRESOLVED_REFERENCE!>::Nested<!>
-    val y = A::Nested
-    
-    checkSubtype<KFunction0<A.Nested>>(y)
-}
-
-fun Int.main() {
-    <!UNRESOLVED_REFERENCE!>::Nested<!>
-    val y = A::Nested
-
-    checkSubtype<KFunction0<A.Nested>>(y)
-}

compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 import kotlin.reflect.KFunction0

compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt

@@ -25,7 +25,7 @@ class A {
 
         expectFunction0Unit(::foo)
         expectFunction0String(::foo)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+        <!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+        <!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
     }
 }

compiler/testData/diagnostics/tests/callableReference/function/unresolved.fir.kt

@@ -4,21 +4,21 @@
 class A
 
 fun test1() {
-    val foo = <!UNRESOLVED_REFERENCE!>::foo<!>
+    val foo = ::<!UNRESOLVED_REFERENCE!>foo<!>
 
-    <!UNRESOLVED_REFERENCE!>::bar<!>
+    ::<!UNRESOLVED_REFERENCE!>bar<!>
 
-    <!UNRESOLVED_REFERENCE!>A::bar<!>
+    A::<!UNRESOLVED_REFERENCE!>bar<!>
 
-    <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>B<!>::bar<!>
+    <!UNRESOLVED_REFERENCE!>B<!>::<!UNRESOLVED_REFERENCE!>bar<!>
 }
 
 fun test2() {
     fun foo(x: Any) {}
     fun foo() {}
 
-    <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>
+    <!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>unresolved<!>)
-    <!UNRESOLVED_REFERENCE!>::unresolved<!>
+    ::<!UNRESOLVED_REFERENCE!>unresolved<!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt

@@ -16,14 +16,14 @@ fun <T> bar(s: T) {}
 fun <T> complex(t: T, f: (T) -> Unit) {}
 
 fun test1() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
     foo(1, ::bar)
 
     complex(1, ::bar)
 }
 
 fun <R> test2(x: R) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(x, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
     foo(x, ::bar)
 
     complex(x, ::bar)

compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt

@@ -14,7 +14,7 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
 
 fun test() {
     takeFun<String>(::foo)
-    <!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(<!UNRESOLVED_REFERENCE!>::fooInt<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(::<!UNRESOLVED_REFERENCE!>fooInt<!>)
 
     callFun<String, Wrapper<String>>(::createWrapper)
     callFun<Int, Wrapper<Number>>(::createWrapper)

compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt

@@ -23,8 +23,8 @@ fun test1() {
 fun <T> test2() {
     bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
     bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
-    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
-    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
 
     bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
     bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }

compiler/testData/diagnostics/tests/callableReference/generic/kt11075.fir.kt

@@ -6,5 +6,5 @@ object TestCallableReferences {
 
     fun test0(): (String) -> String = TestCallableReferences::foo
 
-    fun <T> test1(): (List<T>) -> List<T> = <!UNRESOLVED_REFERENCE!>TestCallableReferences::foo<!>
+    fun <T> test1(): (List<T>) -> List<T> = TestCallableReferences::<!UNRESOLVED_REFERENCE!>foo<!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.fir.kt

@@ -11,7 +11,7 @@ fun test() {
     val x2: (Int) -> Unit = baz(id(::foo), ::foo)
     val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
     val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
-    val x5: (Double) -> Unit = baz(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id(id(<!UNRESOLVED_REFERENCE!>::foo<!>)))
+    val x5: (Double) -> Unit = baz(id(::<!UNRESOLVED_REFERENCE!>foo<!>), id(id(::<!UNRESOLVED_REFERENCE!>foo<!>)))
 
 
     id<(Int) -> Unit>(id(id(::foo)))

compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.fir.kt

@@ -17,7 +17,7 @@ fun test1() {
     baz<String>(::foo).checkType { _<String?>() }
     baz<Boolean>(::foo).checkType { _<Boolean?>() }
 
-    val b1: Int = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val b1: Int = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
-    val b2: String = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val b2: String = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
-    val b3: Boolean = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val b3: Boolean = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
 }

compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.fir.kt

@@ -5,9 +5,9 @@ fun test() {
     val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
     val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
 
-    val a3: Array<Int.(Int) -> Double> = arrayOf(<!UNRESOLVED_REFERENCE!>Double::plus<!>, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
+    val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!UNRESOLVED_REFERENCE!>plus<!>, Double::<!UNRESOLVED_REFERENCE!>minus<!>)
-    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
+    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!UNRESOLVED_REFERENCE!>minus<!>)
-    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, <!UNRESOLVED_REFERENCE!>Int::minus<!>)
+    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!UNRESOLVED_REFERENCE!>minus<!>)
 }
 
 fun foo(x: Int) {}
@@ -18,5 +18,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
 fun test2() {
     bar(1, ::foo)
     bar("", ::foo)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(1.0, <!UNRESOLVED_REFERENCE!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(1.0, ::<!UNRESOLVED_REFERENCE!>foo<!>)
 }

compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt

@@ -5,7 +5,7 @@ fun foo(vararg ints: Int) {}
 fun test(i: IntArray) {
     myLet(i, ::foo)
     myLet(::foo)
-    <!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(::<!UNRESOLVED_REFERENCE!>foo<!>)
     myLet<IntArray>(::foo)
     myLetExplicit1(::foo)
     myLetExplicit2(::foo)

compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.fir.kt

@@ -1,12 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-
-class Unrelated()
-
-class Test(val name: String = "") {
-    init {
-        <!UNRESOLVED_REFERENCE!>Unrelated::name<!>
-        <!UNRESOLVED_REFERENCE!>Unrelated::foo<!>
-    }
-
-    fun foo() {}
-}

compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 
 class Unrelated()

compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt

@@ -14,13 +14,13 @@ class A {
 }
 
 fun test() {
-    <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>String::ext<!>
+    String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext<!>
-    <!UNRESOLVED_REFERENCE!>Obj::ext<!>
+    Obj::<!UNRESOLVED_REFERENCE!>ext<!>
 
-    <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>String::ext2<!>
+    String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext2<!>
-    <!UNRESOLVED_REFERENCE!>A.Companion::ext2<!>
+    A.Companion::<!UNRESOLVED_REFERENCE!>ext2<!>
-    <!UNRESOLVED_REFERENCE!>A::ext2<!>
+    A::<!UNRESOLVED_REFERENCE!>ext2<!>
 
-    <!UNRESOLVED_REFERENCE!>A::foo<!>
+    A::<!UNRESOLVED_REFERENCE!>foo<!>
-    <!UNRESOLVED_REFERENCE!>A::bar<!>
+    A::<!UNRESOLVED_REFERENCE!>bar<!>
 }

compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.fir.kt

@@ -21,6 +21,6 @@ fun test() {
     val pubMutRef: KMutableProperty1<JavaClass, Long> = JavaClass::publicMutable
     val protFinRef: KProperty1<JavaClass, Double> = JavaClass::protectedFinal
     val protMutRef: KMutableProperty1<JavaClass, Char> = JavaClass::protectedMutable
-    val privFinRef: KProperty1<JavaClass, String?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateFinal<!>
+    val privFinRef: KProperty1<JavaClass, String?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateFinal<!>
-    val privMutRef: KMutableProperty1<JavaClass, Any?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateMutable<!>
+    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateMutable<!>
 }

compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.fir.kt

@@ -23,6 +23,6 @@ fun test() {
     val pubMutRef: KMutableProperty0<Any?> = ::publicMutable
     val protFinRef: KProperty<Double> = ::protectedFinal
     val protMutRef: KMutableProperty<Char> = ::protectedMutable
-    val privFinRef: KProperty<JavaClass?> = <!UNRESOLVED_REFERENCE!>::privateFinal<!>
+    val privFinRef: KProperty<JavaClass?> = ::<!UNRESOLVED_REFERENCE!>privateFinal<!>
-    val privMutRef: KMutableProperty<Throwable?> = <!UNRESOLVED_REFERENCE!>::privateMutable<!>
+    val privMutRef: KMutableProperty<Throwable?> = ::<!UNRESOLVED_REFERENCE!>privateMutable<!>
 }

compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.fir.kt

@@ -7,5 +7,5 @@ class TestClass(var prop: Int)
 open class OtherClass
 fun OtherClass.test(prop: KProperty1<TestClass, Int>): Unit = throw Exception()
 class OtherClass2: OtherClass() {
-    val result = <!INAPPLICABLE_CANDIDATE!>test<!>(<!UNRESOLVED_REFERENCE!>TestClass::result<!>)
+    val result = <!INAPPLICABLE_CANDIDATE!>test<!>(TestClass::<!UNRESOLVED_REFERENCE!>result<!>)
 }

compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassNameCompatibility.fir.kt

@@ -22,7 +22,7 @@ fun B.foo(): Double = 0.0
 fun call(a: Any) {}
 
 fun testA(a: A) {
-    call(<!UNRESOLVED_REFERENCE!>A::foo<!>)
+    call(A::<!UNRESOLVED_REFERENCE!>foo<!>)
     call(A.Companion::foo)
 }
 

compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.fir.kt

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

compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.fir.kt

@@ -10,6 +10,6 @@ fun A.foo() = ""
 
 class A {
     fun main() {
-        bar(<!UNRESOLVED_REFERENCE!>::foo<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        bar(::<!UNRESOLVED_REFERENCE!>foo<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     }
 }

compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.fir.kt

@@ -3,14 +3,14 @@
 fun fun1() {}
 fun fun1(x: Int) {}
 
-val ref1 = <!UNRESOLVED_REFERENCE!>::fun1<!>
+val ref1 = ::<!UNRESOLVED_REFERENCE!>fun1<!>
 
 fun fun2(vararg x: Int) {}
 fun fun2(x: Int) {}
 
-val ref2 = <!UNRESOLVED_REFERENCE!>::fun2<!>
+val ref2 = ::<!UNRESOLVED_REFERENCE!>fun2<!>
 
 fun fun3(x0: Int, vararg xs: Int) {}
 fun fun3(x0: String, vararg xs: String) {}
 
-val ref3 = <!UNRESOLVED_REFERENCE!>::fun3<!>
+val ref3 = ::<!UNRESOLVED_REFERENCE!>fun3<!>

compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.fir.kt

@@ -8,4 +8,4 @@ fun foo(s: String) {}
 
 val x1 = ofType<() -> Unit>(::foo)
 val x2 = ofType<(String) -> Unit>(::foo)
-val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(::<!UNRESOLVED_REFERENCE!>foo<!>)

compiler/testData/diagnostics/tests/callableReference/resolve/byValType.fir.kt

@@ -3,7 +3,7 @@
 fun foo() {}
 fun foo(s: String) {}
 
-val x1 = <!UNRESOLVED_REFERENCE!>::foo<!>
+val x1 = ::<!UNRESOLVED_REFERENCE!>foo<!>
 val x2: () -> Unit = ::foo
 val x3: (String) -> Unit = ::foo
-val x4: (Int) -> Unit = <!UNRESOLVED_REFERENCE!>::foo<!>
+val x4: (Int) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>

compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.fir.kt

@@ -31,9 +31,9 @@ fun test() {
             val t3 = bar(::baz)
             t3
 
-            bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
+            bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
         }
     }
 }
 
-inline fun <T, R> myWith(receiver: T, block: T.() -> R): R = TODO()
+inline fun <T, R> myWith(receiver: T, block: T.() -> R): R = TODO()

compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.fir.kt

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

compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt

@@ -6,4 +6,4 @@ import kotlin.reflect.KProperty0
 object A
 
 fun <TProperty> property0(property: KProperty0<TProperty>) = A
-val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(<!UNRESOLVED_REFERENCE!>Map.Entry<K, *>::key<!>) // should be forbidden
+val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(Map.Entry<K, *>::<!UNRESOLVED_REFERENCE!>key<!>) // should be forbidden

compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificAmbiguousExtensions.fir.kt

@@ -9,13 +9,13 @@ 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() {
     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/testData/diagnostics/tests/callableReference/resolve/overloads.fir.kt

@@ -24,7 +24,7 @@ fun test() {
 
     B::bar checkType { _<KFunction1<B, Unit>>() }
 
-    <!UNRESOLVED_REFERENCE!>B::bas<!>
+    B::<!UNRESOLVED_REFERENCE!>bas<!>
 
-    <!UNRESOLVED_REFERENCE!>::fas<!>
+    ::<!UNRESOLVED_REFERENCE!>fas<!>
 }

compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt

@@ -11,6 +11,6 @@ fun <T> baz(e: T, f: (T) -> Unit) {}
 
 fun test(a: A, b: B) {
     // Note that diagnostic is always on callable references as they are resolved after simple arguments
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>fooB<!>, a)
 }

compiler/testData/diagnostics/tests/callableReference/resolve/withAs.fir.kt

@@ -6,5 +6,5 @@ fun foo(s: String) {}
 fun bar(f: () -> Unit) = 1
 fun bar(f: (String) -> Unit) = 2
 
-val x1 = <!UNRESOLVED_REFERENCE!>::foo<!> as () -> Unit
+val x1 = ::<!UNRESOLVED_REFERENCE!>foo<!> as () -> Unit
-val x2 = bar(<!UNRESOLVED_REFERENCE!>::foo<!> as (String) -> Unit)
+val x2 = bar(::<!UNRESOLVED_REFERENCE!>foo<!> as (String) -> Unit)

compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.fir.kt

@@ -14,14 +14,14 @@ class A {
 
 fun A.foo(): String = "A"
 
-val x0 = <!UNRESOLVED_REFERENCE!>A::foo<!>
+val x0 = A::<!UNRESOLVED_REFERENCE!>foo<!>
 
 val x1 = ofType<(A) -> Unit>(A::foo)
 val x2 = ofType<KProperty1<A, Int>>(A::foo)
 val x3: KProperty1<A, Int> = A::foo
 val x4: (A) -> String = A::foo
 
-val y0 = <!UNRESOLVED_REFERENCE!>A::bar<!>
+val y0 = A::<!UNRESOLVED_REFERENCE!>bar<!>
 val y1 = ofType<(A) -> Unit>(A::bar)
 val y2 = ofType<KProperty1<A, Int>>(A::bar)
 val y3: KProperty1<A, Int> = A::bar

compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.fir.kt

@@ -9,4 +9,4 @@ fun foo(s: String) {}
 
 val x1 = apply(1, ::foo)
 val x2 = apply("hello", ::foo)
-val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, <!UNRESOLVED_REFERENCE!>::foo<!>)
+val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, ::<!UNRESOLVED_REFERENCE!>foo<!>)

compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.fir.kt

@@ -22,7 +22,7 @@ val x1 = fn1(1, ::foo, ::foo)
 val x2 = fn1(1, ::foo, ::bar)
 
 val x3 = fn2(::bar, ::foo)
-val x4 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, ::bar)
+val x4 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::bar)
-val x5 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, <!UNRESOLVED_REFERENCE!>::foo<!>)
+val x5 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::<!UNRESOLVED_REFERENCE!>foo<!>)
 
 val x6 = fn3(1, ::qux)

compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.fir.kt

@@ -4,24 +4,24 @@
 fun foo() {}
 
 fun main() {
-    val x1 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print<!>
+    val x1 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x2 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>?::print<!>
+    val x2 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x3 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>::print<!>
+    val x3 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>::<!UNRESOLVED_REFERENCE!>print<!>
-    val x4 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>
+    val x4 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x5 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>
+    val x5 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x6 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info<!>?::print<!>?::print<!>
+    val x6 = <!UNRESOLVED_REFERENCE!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x7 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info!!::print<!>?::print<!>
+    val x7 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x8 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print<!>?::print<!>
+    val x8 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x9 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info<!>?::print<!>?::print<!>
+    val x9 = <!UNRESOLVED_REFERENCE!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x10 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print!!::print<!>
+    val x10 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::print!!::<!UNRESOLVED_REFERENCE!>print<!>
-    val x11 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info!!::print!!::print<!>
+    val x11 = <!UNRESOLVED_REFERENCE!>logger<!>!!::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
-    val x12 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print!!::print<!>
+    val x12 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
-    val x13 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>42?::unresolved<!>?::print<!>
+    val x13 = 42?::<!UNRESOLVED_REFERENCE!>unresolved<!>?::<!UNRESOLVED_REFERENCE!>print<!>
 
     val x14 = <!UNRESOLVED_REFERENCE!>logger<!><!SYNTAX!>?!!::info?::print?::print<!>
-    val x15 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!><!SYNTAX!>?!!::print?::print<!>
+    val x15 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!><!SYNTAX!>?!!::print?::print<!>
-    val x16 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!?::info<!>?::print<!>?::print<!>
+    val x16 = <!UNRESOLVED_REFERENCE!>logger<!>!!?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x17 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info!!?::print<!>?::print<!>
+    val x17 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
 
     // It must be OK
     val x18 = String?::hashCode ?: ::foo

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt

@@ -13,10 +13,10 @@ fun wrong(arg: Wrong) {}
 class Wrong
 
 class Right {
-    val prop: () -> Unit by <!UNRESOLVED_REFERENCE!>::wrong<!>
+    val prop: () -> Unit by ::<!UNRESOLVED_REFERENCE!>wrong<!>
 }
 
 fun box(): String {
     Right().prop()
     return "OK"
-}
+}

compiler/testData/diagnostics/tests/incompleteCode/illegalSelectorCallableReference.fir.kt

@@ -1,8 +1,8 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 
 fun test() {
-    <!UNRESOLVED_REFERENCE!>"a"."b"::foo<!>
+    "a"."b"::<!UNRESOLVED_REFERENCE!>foo<!>
     "a"."b"::class
-    <!UNRESOLVED_REFERENCE!>"a"."b"."c"::foo<!>
+    "a"."b"."c"::<!UNRESOLVED_REFERENCE!>foo<!>
     "a"."b"."c"::class
 }

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

@@ -24,7 +24,7 @@ fun <T> Foo2<T>.setX(y: T): T {
 fun Float.bar() {}
 
 fun test1() {
-    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown"), UNRESOLVED_REFERENCE!>Foo<*>::setX<!>
+    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>Foo<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
     val foo = Foo<Float>(1f)
 
     fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, 1)
@@ -42,7 +42,7 @@ fun test2() {
 }
 
 fun test3() {
-    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown"), UNRESOLVED_REFERENCE!>Foo2<*>::setX<!>
+    val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>Foo2<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
     val foo = Foo2<Int>(1)
 
     fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, "")

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

@@ -27,22 +27,22 @@ interface Foo {
     // CR on property with to receivers are forbidden
     fun <T: Foo> test() {
         // with LHS and property
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
 
         // with LHS and mutable property
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
 
         // with LHS and propery + mutable property (mixed)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar9<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar9<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar9<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar9<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
-        <!INAPPLICABLE_CANDIDATE!>bar9<!>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
+        <!INAPPLICABLE_CANDIDATE!>bar9<!>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
     }
 }
 
@@ -84,14 +84,14 @@ fun <T : Foo, R: Number, D: Int> main() {
     bar1(::resolve) // OK
 
     // with LHS and conflicting projection
-    bar2<T>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar2<T>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
-    bar2<Foo>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar2<Foo>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
-    bar2(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar2(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
 
     // with LHS and Any? expected type
-    bar3<T>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar3<T>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
-    bar3<Foo>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar3<Foo>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
-    bar3(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
+    bar3(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
 
     // with LHS and `Function` expected type
     bar4<T>(Foo::resolve) // ERROR before the fix in NI
@@ -114,14 +114,14 @@ fun <T : Foo, R: Number, D: Int> main() {
     bar7(Foo::resolve) // OK
 
     // with LHS and sentension function expected type
-    <!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>Int::x1<!>) // ERROR before the fix in NI
+    <!INAPPLICABLE_CANDIDATE!>bar10<!><D>(Int::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
     bar10<Int>(Int::x1) // OK
     bar10(Int::x1) // OK
 
     fun Int.ext() {
         // with LHS and sentension function expected type
-        <!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>::x1<!>) // ERROR before the fix in NI
+        <!INAPPLICABLE_CANDIDATE!>bar10<!><D>(::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
-        <!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
+        <!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
-        <!INAPPLICABLE_CANDIDATE!>bar10<!>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
+        <!INAPPLICABLE_CANDIDATE!>bar10<!>(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.fir.kt

@@ -12,5 +12,5 @@ fun <V, T : V?> G<T>.foo(vararg values: V2<V?>) = build()
 fun forReference(ref: Any?) {}
 
 fun test() {
-    forReference(<!UNRESOLVED_REFERENCE!>G<Int?>::foo<!>)
+    forReference(G<Int?>::<!UNRESOLVED_REFERENCE!>foo<!>)
 }

compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.fir.kt

@@ -7,5 +7,5 @@ fun foo(i: Long) {}
 fun bar(f: (Boolean) -> Unit) {}
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
 }

compiler/testData/diagnostics/tests/inference/regressions/kt34282.fir.kt

@@ -6,5 +6,5 @@ fun foo(x: Float) = 10f
 fun foo(x: String) = ""
 
 fun main() {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::foo<!>) // no report about unresolved callable reference for `foo`
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>foo<!>) // no report about unresolved callable reference for `foo`
 }

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

@@ -3,5 +3,5 @@ fun <T, U> T.map(f: (T) -> U) = f(this)
 fun consume(s: String) {}
 
 fun test() {
-    consume(1.<!INAPPLICABLE_CANDIDATE!>map<!>(<!UNRESOLVED_REFERENCE!>::foo<!>))
+    consume(1.<!INAPPLICABLE_CANDIDATE!>map<!>(::<!UNRESOLVED_REFERENCE!>foo<!>))
-}
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/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

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

@@ -129,7 +129,7 @@ fun poll36(flag: Boolean) {
 }
 
 fun poll4() {
-    val inv = try { ::bar } finally { <!UNRESOLVED_REFERENCE!>::foo<!> }
+    val inv = try { ::bar } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -139,7 +139,7 @@ fun poll41() {
 }
 
 fun poll42() {
-    val inv = try { ::bar3 } finally { <!UNRESOLVED_REFERENCE!>::foo3<!> }
+    val inv = try { ::bar3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -149,7 +149,7 @@ fun poll43() {
 }
 
 fun poll44() {
-    val inv = try { ::bar5 } finally { <!UNRESOLVED_REFERENCE!>::foo5<!> }
+    val inv = try { ::bar5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -164,7 +164,7 @@ fun poll46() {
 }
 
 fun poll5() {
-    val inv = try { ::bar } catch (e: Exception) { ::foo } finally { <!UNRESOLVED_REFERENCE!>::foo<!> }
+    val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -174,7 +174,7 @@ fun poll51() {
 }
 
 fun poll52() {
-    val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { <!UNRESOLVED_REFERENCE!>::foo3<!> }
+    val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -184,7 +184,7 @@ fun poll53() {
 }
 
 fun poll54() {
-    val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { <!UNRESOLVED_REFERENCE!>::foo5<!> }
+    val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -199,7 +199,7 @@ fun poll56() {
 }
 
 fun poll6() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar<!>
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar<!>
     inv
 }
 
@@ -209,7 +209,7 @@ fun poll61() {
 }
 
 fun poll62() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar3<!>
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!>
     inv
 }
 
@@ -219,7 +219,7 @@ fun poll63() {
 }
 
 fun poll64() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar5<!>
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar5<!>
     inv
 }
 
@@ -269,7 +269,7 @@ fun poll76() {
 }
 
 fun poll8() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -279,7 +279,7 @@ fun poll81() {
 }
 
 fun poll82() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo3<!>)
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo3<!>)
     <!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
@@ -289,7 +289,7 @@ fun poll83() {
 }
 
 fun poll84() {
-    val inv = <!UNRESOLVED_REFERENCE!>::bar5<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo5<!>)
+    val inv = ::<!UNRESOLVED_REFERENCE!>bar5<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo5<!>)
     inv
 }
 

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt

@@ -22,6 +22,6 @@ fun main(c: CollectionWithSize) {
     CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
     c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt

@@ -23,6 +23,6 @@ fun main(c: CollectionWithSize) {
     CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
     c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt

@@ -22,6 +22,6 @@ fun main(c: CollectionWithSize) {
     CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
     c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt

@@ -18,7 +18,7 @@ public class Inv<T> {
 
 fun test(inv: Inv<String>) {
     val m: ((String) -> String) -> Inv<String> = inv::map
-    <!INAPPLICABLE_CANDIDATE!>take<!>(<!UNRESOLVED_REFERENCE!>inv::map<!>)
+    <!INAPPLICABLE_CANDIDATE!>take<!>(inv::<!UNRESOLVED_REFERENCE!>map<!>)
 }
 
 fun take(f: ((String) -> String) -> Inv<String>) {}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.fir.kt

@@ -115,28 +115,28 @@ class C : O.B() {
     val n = FromCompanionC::foo
 
     // INVISIBLE: direct superclasses themselves.
-    val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val b = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val f = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // INVISIBLE: "cousin" supertypes themselves
-    val g = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Alpha<!>::foo<!>
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val h = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Beta<!>::foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val i = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Gamma<!>::foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: classifiers from "cousin" superclasses
-    val k = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo<!>
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val l = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBeta<!>::foo<!>
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val m = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromGamma<!>::foo<!>
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
-    val o = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo<!>
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val p = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val q = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: Classifiers from supertypes of our own companion
-    val r = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromDelta<!>::foo<!>
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 }

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.fir.kt

@@ -115,28 +115,28 @@ class C : O.B() {
     val n = FromCompanionC::foo
 
     // INVISIBLE: direct superclasses themselves.
-    val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val b = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val f = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // INVISIBLE: "cousin" supertypes themselves
-    val g = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Alpha<!>::foo<!>
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val h = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Beta<!>::foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val i = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Gamma<!>::foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: classifiers from "cousin" superclasses
-    val k = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo<!>
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val l = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBeta<!>::foo<!>
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val m = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromGamma<!>::foo<!>
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
-    val o = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo<!>
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val p = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
-    val q = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 
     // DEPRECATED: Classifiers from supertypes of our own companion
-    val r = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromDelta<!>::foo<!>
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
 }

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.fir.kt

@@ -12,7 +12,7 @@ object A {
     }
 
     class Derived : Base() {
-        val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
+        val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
     }
 }
 
@@ -30,7 +30,7 @@ object B {
     }
 
     class Derived : Base() {
-        val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
+        val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
     }
 }
 
@@ -48,7 +48,7 @@ object C {
     }
 
     class Derived : Base() {
-        val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
+        val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
     }
 }
 
@@ -64,6 +64,6 @@ object D {
     }
 
     class Derived : Base() {
-        val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
+        val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
     }
 }

compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt

@@ -1,2 +1,2 @@
 // !WITH_NEW_INFERENCE
-val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::unwrap<!>
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::<!UNRESOLVED_REFERENCE!>unwrap<!>

compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt

@@ -1,4 +1,4 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
-val unwrapped = some.<!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>cabc<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>$Wrapper<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Any<!>>::unwrap<!>
+val unwrapped = some.<!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>cabc<!><!SYNTAX!>$Wrapper<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Any<!>>::<!UNRESOLVED_REFERENCE!>unwrap<!>

compiler/testData/diagnostics/tests/regressions/kt13685.fir.kt

@@ -3,5 +3,5 @@
 
 fun foo() {
     val text: List<Any> = null!!
-    text.<!UNRESOLVED_REFERENCE!>map<!> <!UNRESOLVED_REFERENCE!>Any<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>?<!>::toString<!>
+    text.<!UNRESOLVED_REFERENCE!>map<!> <!UNRESOLVED_REFERENCE!>Any<!><!SYNTAX!>?<!>::<!UNRESOLVED_REFERENCE!>toString<!>
 }

compiler/testData/diagnostics/tests/regressions/kt31975.fir.kt

@@ -11,7 +11,7 @@ interface TypeConstructor
 
 class Refiner {
     val memoizedFunctionLambda = createMemoizedFunction { it.foo() } // error type infered, no diagnostic, BAD, backend fails
-    val memoizedFunctionReference = createMemoizedFunction(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>TypeConstructor::foo<!>) // EXTENSION_IN_CLASS_REFERENCE_IS_NOT_ALLOWED, fine
+    val memoizedFunctionReference = createMemoizedFunction(TypeConstructor::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>foo<!>) // EXTENSION_IN_CLASS_REFERENCE_IS_NOT_ALLOWED, fine
     val memoizedFunctionTypes = createMemoizedFunction<TypeConstructor, Boolean> { it.foo() } // works fine
 
     private fun TypeConstructor.foo(): Boolean = true