[FIR] Handle unresolved callable references more correctly

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -7,7 +7,9 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.copy
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
@@ -16,10 +18,13 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
+import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.references.FirReference
+import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.*
+import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.withNullability
@@ -108,7 +113,13 @@ class FirSyntheticCallGenerator(
         val reference =
             generateCalleeReferenceWithCandidate(
                 idFunction, arguments, SyntheticCallableId.ID.callableName, CallKind.SyntheticIdForCallableReferencesResolution
-            ) ?: return null
+            ) ?: return callableReferenceAccess.transformCalleeReference(
+                StoreCalleeReference,
+                FirErrorNamedReferenceImpl(
+                    callableReferenceAccess.source,
+                    FirUnresolvedNameError(callableReferenceAccess.calleeReference.name)
+                )
+            )
         val fakeCallElement = FirFunctionCallImpl(null).copy(calleeReference = reference, arguments = arguments)
 
         return callCompleter.completeCall(fakeCallElement, expectedTypeRef).arguments[0] as FirCallableReferenceAccess?
@@ -204,7 +215,9 @@ class FirSyntheticCallGenerator(
         }
     }
 
-    private fun generateMemberFunction(session: FirSession, symbol: FirNamedFunctionSymbol, name: Name, returnType: FirTypeRef): FirSimpleFunctionImpl {
+    private fun generateMemberFunction(
+        session: FirSession, symbol: FirNamedFunctionSymbol, name: Name, returnType: FirTypeRef
+    ): FirSimpleFunctionImpl {
         val status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL).apply {
             isExpect = false
             isActual = false
@@ -229,8 +242,10 @@ class FirSyntheticCallGenerator(
         }
     }
 
-    private fun FirResolvedTypeRef.toValueParameter(session: FirSession, name: String, isVararg: Boolean = false): FirValueParameterImpl {
+    private fun FirResolvedTypeRef.toValueParameter(
-        val name = Name.identifier(name)
+        session: FirSession, nameAsString: String, isVararg: Boolean = false
+    ): FirValueParameterImpl {
+        val name = Name.identifier(nameAsString)
         return FirValueParameterImpl(
             session = session,
             source = null,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt

@@ -87,21 +87,21 @@ internal object StoreNameReference : FirDefaultTransformer<FirNamedReference>()
     }
 }
 
-internal object StoreCalleeReference : FirTransformer<FirResolvedNamedReference>() {
+internal object StoreCalleeReference : FirTransformer<FirNamedReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirResolvedNamedReference): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
         return element.compose()
     }
 
     override fun transformNamedReference(
         namedReference: FirNamedReference,
-        data: FirResolvedNamedReference
+        data: FirNamedReference
     ): CompositeTransformResult<FirNamedReference> {
         return data.compose()
     }
 
     override fun transformResolvedNamedReference(
         resolvedNamedReference: FirResolvedNamedReference,
-        data: FirResolvedNamedReference
+        data: FirNamedReference
     ): CompositeTransformResult<FirNamedReference> {
         return data.compose()
     }

compiler/fir/resolve/testData/resolve/expresssions/errCallable.kt

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

compiler/fir/resolve/testData/resolve/expresssions/errCallable.txt

@@ -18,10 +18,10 @@ FILE: errCallable.kt
         }
 
         public final fun foo(): R|kotlin/Unit| {
-            lval x: <ERROR TYPE REF: No result type for initializer> = ::Nested#
+            lval x: <ERROR TYPE REF: No result type for initializer> = ::<Unresolved name: Nested>#
         }
 
     }
     public final fun R|Your|.foo(): R|kotlin/Unit| {
-        lval x: <ERROR TYPE REF: No result type for initializer> = ::Nested#
+        lval x: R|kotlin/reflect/KFunction0<Your.Nested>| = ::R|/Your.Nested.Nested|
     }

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

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

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

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

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

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

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

@@ -13,4 +13,4 @@ import test.Foo
 fun Foo(): String = ""
 
 val f = Foo::bar
-val g = Foo::length
+val g = <!UNRESOLVED_REFERENCE!>Foo::length<!>

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

@@ -21,8 +21,8 @@ import first.foo
 
 fun main() {
     val x = first.A::foo
-    first.A::bar
+    <!UNRESOLVED_REFERENCE!>first.A::bar<!>
-    A::baz
+    <!UNRESOLVED_REFERENCE!>A::baz<!>
 
     checkSubtype<KFunction1<A, Unit>>(x)
 }

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

@@ -15,6 +15,6 @@ class A {
 fun eat(value: Any) {}
 
 fun main() {
-    A::extInt
+    <!UNRESOLVED_REFERENCE!>A::extInt<!>
-    A::extA
+    <!UNRESOLVED_REFERENCE!>A::extA<!>
 }

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

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

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

@@ -16,7 +16,7 @@ fun A.main() {
 }
 
 fun Int.main() {
-    ::Inner
+    <!UNRESOLVED_REFERENCE!>::Inner<!>
     val y = A::Inner
 
     checkSubtype<KFunction1<A, A.Inner>>(y)

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

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

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

@@ -25,7 +25,7 @@ class A {
 
 class B {
     fun main() {
-        ::Nested
+        <!UNRESOLVED_REFERENCE!>::Nested<!>
         val y = A::Nested
 
         <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KFunction0<A.Nested>>(y)

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

@@ -14,7 +14,7 @@ fun A.main() {
 }
 
 fun Int.main() {
-    ::Nested
+    <!UNRESOLVED_REFERENCE!>::Nested<!>
     val y = A::Nested
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KFunction0<A.Nested>>(y)

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

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

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

@@ -4,8 +4,8 @@
 
 fun main() {
     Configuration().commands {
-        <!INAPPLICABLE_CANDIDATE!>Command1<!> { <!UNRESOLVED_REFERENCE!>someService<!>::execute } // Overload resolution ambiguity. All these functions match.
+        <!INAPPLICABLE_CANDIDATE!>Command1<!> { <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>someService<!>::execute<!> } // Overload resolution ambiguity. All these functions match.
-        <!INAPPLICABLE_CANDIDATE!>Command2<!> { <!UNRESOLVED_REFERENCE!>someService<!>::execute } // Overload resolution ambiguity. All these functions match.
+        <!INAPPLICABLE_CANDIDATE!>Command2<!> { <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>someService<!>::execute<!> } // Overload resolution ambiguity. All these functions match.
         <!INAPPLICABLE_CANDIDATE!>Command1<!> { { <!UNRESOLVED_REFERENCE!>someService<!>.<!UNRESOLVED_REFERENCE!>execute<!>(<!UNRESOLVED_REFERENCE!>it<!>) } } // fine
         <!INAPPLICABLE_CANDIDATE!>Command2<!> { { <!UNRESOLVED_REFERENCE!>someService<!>.<!UNRESOLVED_REFERENCE!>execute<!>(<!UNRESOLVED_REFERENCE!>it<!>) } } // fine
     }

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

@@ -4,8 +4,8 @@ class Unrelated()
 
 class Test(val name: String = "") {
     init {
-        Unrelated::name
+        <!UNRESOLVED_REFERENCE!>Unrelated::name<!>
-        Unrelated::foo
+        <!UNRESOLVED_REFERENCE!>Unrelated::foo<!>
     }
 
     fun foo() {}

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

@@ -21,6 +21,6 @@ fun test() {
     A.Companion::ext2
     A::ext2
 
-    A::foo
+    <!UNRESOLVED_REFERENCE!>A::foo<!>
-    A::bar
+    <!UNRESOLVED_REFERENCE!>A::bar<!>
 }

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

@@ -4,7 +4,7 @@
 package foo
 
 fun test() {
-    foo::test
+    <!UNRESOLVED_REFERENCE!>foo::test<!>
 }
 
 // FILE: qualifiedName.kt
@@ -12,5 +12,5 @@ fun test() {
 package foo.bar
 
 fun test() {
-    foo.bar::test
+    <!UNRESOLVED_REFERENCE!>foo.bar::test<!>
 }

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

@@ -17,10 +17,10 @@ public class JavaClass {
 import kotlin.reflect.*
 
 fun test() {
-    val pubFinRef: KProperty1<JavaClass, Int> = JavaClass::publicFinal
+    val pubFinRef: KProperty1<JavaClass, Int> = <!UNRESOLVED_REFERENCE!>JavaClass::publicFinal<!>
-    val pubMutRef: KMutableProperty1<JavaClass, Long> = JavaClass::publicMutable
+    val pubMutRef: KMutableProperty1<JavaClass, Long> = <!UNRESOLVED_REFERENCE!>JavaClass::publicMutable<!>
-    val protFinRef: KProperty1<JavaClass, Double> = JavaClass::protectedFinal
+    val protFinRef: KProperty1<JavaClass, Double> = <!UNRESOLVED_REFERENCE!>JavaClass::protectedFinal<!>
-    val protMutRef: KMutableProperty1<JavaClass, Char> = JavaClass::protectedMutable
+    val protMutRef: KMutableProperty1<JavaClass, Char> = <!UNRESOLVED_REFERENCE!>JavaClass::protectedMutable<!>
-    val privFinRef: KProperty1<JavaClass, String?> = JavaClass::privateFinal
+    val privFinRef: KProperty1<JavaClass, String?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateFinal<!>
-    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::privateMutable
+    val privMutRef: KMutableProperty1<JavaClass, Any?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateMutable<!>
 }

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

@@ -19,10 +19,10 @@ import JavaClass.*
 import kotlin.reflect.*
 
 fun test() {
-    val pubFinRef: KProperty0<String> = ::publicFinal
+    val pubFinRef: KProperty0<String> = <!UNRESOLVED_REFERENCE!>::publicFinal<!>
-    val pubMutRef: KMutableProperty0<Any?> = ::publicMutable
+    val pubMutRef: KMutableProperty0<Any?> = <!UNRESOLVED_REFERENCE!>::publicMutable<!>
-    val protFinRef: KProperty<Double> = ::protectedFinal
+    val protFinRef: KProperty<Double> = <!UNRESOLVED_REFERENCE!>::protectedFinal<!>
-    val protMutRef: KMutableProperty<Char> = ::protectedMutable
+    val protMutRef: KMutableProperty<Char> = <!UNRESOLVED_REFERENCE!>::protectedMutable<!>
-    val privFinRef: KProperty<JavaClass?> = ::privateFinal
+    val privFinRef: KProperty<JavaClass?> = <!UNRESOLVED_REFERENCE!>::privateFinal<!>
-    val privMutRef: KMutableProperty<Throwable?> = ::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<!>(TestClass::result)
+    val result = <!INAPPLICABLE_CANDIDATE!>test<!>(<!UNRESOLVED_REFERENCE!>TestClass::result<!>)
 }

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

@@ -3,7 +3,7 @@
 fun eat(value: Any) {}
 
 fun test(param: String) {
-    val a = ::param
+    val a = <!UNRESOLVED_REFERENCE!>::param<!>
 
     val local = "local"
     val b = ::local

compiler/testData/diagnostics/tests/classLiteral/integerValueType.fir.kt

@@ -7,5 +7,5 @@ fun f(x: KClass<out Int>) {}
 fun test() {
     f(42::class)
     f((40 + 2)::class)
-    42::toInt
+    <!UNRESOLVED_REFERENCE!>42::toInt<!>
 }

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

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

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<!>(::foo))
+    consume(1.<!INAPPLICABLE_CANDIDATE!>map<!>(<!UNRESOLVED_REFERENCE!>::foo<!>))
 }

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

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

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

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

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

@@ -119,8 +119,8 @@ class C : O.B() {
     val b = O.A::foo
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = O.A.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo
+    val e = <!UNRESOLVED_REFERENCE!>O.A.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
-    val f = O.B.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo
+    val f = <!UNRESOLVED_REFERENCE!>O.B.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
 
     // INVISIBLE: "cousin" supertypes themselves
     val g = O.Alpha::foo

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

@@ -119,8 +119,8 @@ class C : O.B() {
     val b = O.A::foo
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = O.A.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo
+    val e = <!UNRESOLVED_REFERENCE!>O.A.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
-    val f = O.B.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo
+    val f = <!UNRESOLVED_REFERENCE!>O.B.<!AMBIGUITY!>Companion<!>.<!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
 
     // INVISIBLE: "cousin" supertypes themselves
     val g = O.Alpha::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!>sdf<!>()()<!><out Any><!>::unwrap
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>sdf<!>()()<!><out Any><!>::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<!><!SYNTAX!>$Wrapper<!><out Any>::unwrap
+val unwrapped = some.<!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>cabc<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>$Wrapper<!><out Any>::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<!><!SYNTAX!>?<!>::toString
+    text.<!UNRESOLVED_REFERENCE!>map<!> <!UNRESOLVED_REFERENCE!>Any<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>?<!>::toString<!>
 }

compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/qualifiedJavaClassReferenceInKClassExtension.fir.kt

@@ -6,5 +6,5 @@ val <T : Any> KClass<T>.java: Class<T> get() = null!!
 
 val <T : Any> KClass<T>.foo: Any?
     get() {
-        return java.<!UNRESOLVED_REFERENCE!>lang<!>.<!UNRESOLVED_REFERENCE!>Integer<!>::hashCode
+        return <!UNRESOLVED_REFERENCE!>java.<!UNRESOLVED_REFERENCE!>lang<!>.<!UNRESOLVED_REFERENCE!>Integer<!>::hashCode<!>
     }

compiler/testData/diagnostics/tests/typealias/methodReference.fir.kt

@@ -4,4 +4,4 @@ class C {
 
 typealias CA = C
 
-val cf = CA::foo
+val cf = <!UNRESOLVED_REFERENCE!>CA::foo<!>

compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.fir.kt

@@ -50,7 +50,7 @@ fun foo(
     test.ClassAlias::Nested
 
     test.ClassSample::func
-    test.ClassAlias::func
+    <!UNRESOLVED_REFERENCE!>test.ClassAlias::func<!>
 
     test.ClassSample.Nested::func
     test.ClassAlias.Nested::func
@@ -68,7 +68,7 @@ fun foo(
     test.EnumAlias::Nested
 
     test.EnumSample::func
-    test.EnumAlias::func
+    <!UNRESOLVED_REFERENCE!>test.EnumAlias::func<!>
 
     test.EnumSample.Nested::func
     test.EnumAlias.Nested::func

compiler/testData/ir/irText/expressions/propertyReferences.fir.txt

@@ -252,7 +252,7 @@ FILE fqName:<root> fileName:/propertyReferences.kt
   PROPERTY name:test_J_CONST visibility:public modality:FINAL [val]
     FIELD PROPERTY_BACKING_FIELD name:test_J_CONST type:IrErrorType visibility:private [final,static]
       EXPRESSION_BODY
-        ERROR_CALL 'Unsupported callable reference: Q|J|::CONST#' type=IrErrorType
+        ERROR_CALL 'Unsupported callable reference: Q|J|::<Unresolved name: CONST>#' type=IrErrorType
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test_J_CONST> visibility:public modality:FINAL <> () returnType:IrErrorType
       correspondingProperty: PROPERTY name:test_J_CONST visibility:public modality:FINAL [val]
       BLOCK_BODY
@@ -261,7 +261,7 @@ FILE fqName:<root> fileName:/propertyReferences.kt
   PROPERTY name:test_J_nonConst visibility:public modality:FINAL [val]
     FIELD PROPERTY_BACKING_FIELD name:test_J_nonConst type:IrErrorType visibility:private [final,static]
       EXPRESSION_BODY
-        ERROR_CALL 'Unsupported callable reference: Q|J|::nonConst#' type=IrErrorType
+        ERROR_CALL 'Unsupported callable reference: Q|J|::<Unresolved name: nonConst>#' type=IrErrorType
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test_J_nonConst> visibility:public modality:FINAL <> () returnType:IrErrorType
       correspondingProperty: PROPERTY name:test_J_nonConst visibility:public modality:FINAL [val]
       BLOCK_BODY