From d91000e39c1c83c3b72b76e6d60ed7fae846cec9 Mon Sep 17 00:00:00 2001
From: Kirill Rakhman <kirill.rakhman@jetbrains.com>
Date: Fri, 3 Nov 2023 13:39:27 +0100
Subject: [PATCH] [FIR] Report INAPPLICABLE_CANDIDATE or more specific
 diagnostic for callable references

... instead of just UNRESOLVED_REFERENCE when something went wrong
during resolution.

#KT-59401 related
---
 .../callableReferences/companions.fir.txt            |  2 +-
 .../callableReferences/companions.kt                 |  2 +-
 ...CallableReferencesAfterAllSimpleArguments.fir.txt |  4 ++--
 ...solveCallableReferencesAfterAllSimpleArguments.kt |  4 ++--
 .../callableReferences/implicitTypes.fir.txt         |  2 +-
 .../callableReferences/implicitTypes.kt              |  2 +-
 .../implicitTypes.reversed.fir.txt                   |  2 +-
 .../callableReferences/implicitTypes.reversed.kt     |  2 +-
 .../src/org/jetbrains/kotlin/fir/FirCallResolver.kt  | 12 +++++++-----
 .../annotations/annotationRenderingInTypes.fir.kt    |  2 +-
 .../adapted/noKFunctionForAdaptation.fir.kt          |  4 ++--
 .../bound/expressionWithNullableType.fir.kt          | 10 +++++-----
 .../callableReference/bound/privateToThis.fir.kt     |  4 ++--
 .../bound/reservedExpressionSyntax.fir.kt            |  6 +++---
 .../bound/reservedExpressionSyntax2.fir.kt           |  2 +-
 .../constraintFromLHSWithCorrectDirection.fir.kt     |  2 +-
 ...constraintFromLHSWithCorrectDirectionError.fir.kt |  2 +-
 .../expectedTypeAsSubtypeOfFunctionType.fir.kt       |  2 +-
 .../function/abstractClassConstructors.fir.kt        |  2 +-
 .../function/noAmbiguityMemberVsTopLevel.fir.kt      |  4 ++--
 .../generic/dependOnArgumentType.fir.kt              |  4 ++--
 .../generic/explicitTypeArguments.fir.kt             |  2 +-
 .../generic/genericExtensionFunction.fir.kt          |  4 ++--
 .../genericCallWithReferenceAgainstVararg.fir.kt     |  2 +-
 .../tests/callableReference/kt46437.fir.kt           |  2 +-
 ...erExtensionsImportedFromObjectsUnsupported.fir.kt |  6 +++---
 .../property/javaInstanceField.fir.kt                |  4 ++--
 .../property/javaStaticFieldViaImport.fir.kt         |  4 ++--
 .../adaptedReferenceAgainstReflectionType.fir.kt     |  2 +-
 ...ityWarningOnReferenceAgainstReflectiveType.fir.kt |  2 +-
 .../callableReference/resolve/kt35887_simple.fir.kt  |  2 +-
 ...eCallableReferencesAfterAllSimpleArguments.fir.kt |  4 ++--
 .../diagnostics/tests/delegation/kt49477.fir.kt      |  2 +-
 .../diagnostics/tests/delegation/kt49477Error.fir.kt |  2 +-
 ...edFieldAndKotlinInvisiblePropertyReference.fir.kt |  4 ++--
 .../diagnostics/tests/inference/kt39220.fir.kt       |  8 ++++----
 .../referenceToSamFunctionAgainstExpectedType.fir.kt |  2 +-
 ...basicSuspendConversionForCallableReference.fir.kt |  2 +-
 .../tests/varargs/varargViewedAsArray.fir.kt         | 10 +++++-----
 .../suspendConversionForCallableReferences.fir.kt    |  4 ++--
 .../callableReferenceToASuspendFunction.fir.kt       |  4 ++--
 .../inference/delegates/kt50994.fir.kt               |  2 +-
 .../inference/delegates/kt50994.fir.txt              |  2 +-
 .../linked/statements/assignments/p-2/neg/1.2.fir.kt |  6 +++---
 44 files changed, 80 insertions(+), 78 deletions(-)

diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.fir.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.fir.txt
index 105b47f2b12..9faabb0c7f3 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.fir.txt
@@ -53,7 +53,7 @@ FILE: main.kt
         R|/foo1|(Q|KotlinClass|::R|/KotlinClass.Companion.baz|)
         R|/foo2|(Q|KotlinClass|::R|/KotlinClass.baz|)
         <Ambiguity: foo3, [/foo3, /foo3]>#(Q|KotlinClass|::R|/KotlinClass.baz|)
-        R|/foo1<Inapplicable(INAPPLICABLE): /foo1>#|(Q|KotlinClass|::<Unresolved reference: bar>#)
+        R|/foo1<Inapplicable(INAPPLICABLE): /foo1>#|(Q|KotlinClass|::<Inapplicable(INAPPLICABLE): /JavaClass.bar>#)
         R|/foo2|(Q|KotlinClass|::R|/JavaClass.bar|)
         R|/foo3|(Q|KotlinClass|::R|/JavaClass.bar|)
         R|/foo1|(Q|KotlinClass2|::R|/KotlinClass2.Companion.bar|)
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
index 4018e5020bd..5fa55829b48 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
@@ -34,7 +34,7 @@ fun main() {
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo3<!>(KotlinClass::baz)
 
     // Type mismatch
-    foo1(KotlinClass::<!UNRESOLVED_REFERENCE!>bar<!>)
+    foo1(KotlinClass::<!INAPPLICABLE_CANDIDATE!>bar<!>)
     foo2(KotlinClass::bar)
     foo3(KotlinClass::bar)
 
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.fir.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.fir.txt
index 80b1d363491..16b6d4d9184 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.fir.txt
@@ -10,6 +10,6 @@ FILE: resolveCallableReferencesAfterAllSimpleArguments.kt
     public final fun <T> baz(e: R|T|, f: R|(T) -> kotlin/Unit|): R|kotlin/Unit| {
     }
     public final fun test(a: R|A|, b: R|B|): R|kotlin/Unit| {
-        R|/baz<Inapplicable(INAPPLICABLE): /baz>#|<R|A|>(R|<local>/a|, ::<Unresolved reference: fooB>#)
-        R|/bar<Inapplicable(INAPPLICABLE): /bar>#|<R|A|>(::<Unresolved reference: fooB>#, R|<local>/a|)
+        R|/baz<Inapplicable(INAPPLICABLE): /baz>#|<R|A|>(R|<local>/a|, ::<Inapplicable(INAPPLICABLE): /fooB>#)
+        R|/bar<Inapplicable(INAPPLICABLE): /bar>#|<R|A|>(::<Inapplicable(INAPPLICABLE): /fooB>#, R|<local>/a|)
     }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
index 4532c22b733..cedc49708ff 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
+++ b/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) {
-    baz(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
-    bar(::<!UNRESOLVED_REFERENCE!>fooB<!>, a)
+    baz(a, ::<!INAPPLICABLE_CANDIDATE!>fooB<!>)
+    bar(::<!INAPPLICABLE_CANDIDATE!>fooB<!>, a)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.fir.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.fir.txt
index 4ea0a252edf..e4c058df6fe 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.fir.txt
@@ -9,7 +9,7 @@ FILE: implicitTypes.kt
         ^bar Int(1)
     }
     public final fun loop1(): R|(ERROR CLASS: Cannot infer argument for type parameter T) -> ERROR CLASS: Cannot infer argument for type parameter R| {
-        ^loop1 R|/use<Inapplicable(INAPPLICABLE): /use>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(::<Unresolved reference: loop2>#)
+        ^loop1 R|/use<Inapplicable(INAPPLICABLE): /use>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(::<Inapplicable(INAPPLICABLE): /loop2>#)
     }
     public final fun loop2(): <ERROR TYPE REF: cycle> {
         ^loop2 R|/loop1|()
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
index 1c76deeea5d..b692a26e384 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
+++ b/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() = use(::<!UNRESOLVED_REFERENCE!>loop2<!>)
+fun loop1() = use(::<!INAPPLICABLE_CANDIDATE!>loop2<!>)
 fun loop2() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>loop1()<!>
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.fir.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.fir.txt
index c978e7c8600..e7d60114f62 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.fir.txt
@@ -9,7 +9,7 @@ FILE: implicitTypes.reversed.kt
         ^bar Int(1)
     }
     public final fun loop1(): R|(ERROR CLASS: Cannot infer argument for type parameter T) -> ERROR CLASS: Cannot infer argument for type parameter R| {
-        ^loop1 R|/use<Inapplicable(INAPPLICABLE): /use>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(::<Unresolved reference: loop2>#)
+        ^loop1 R|/use<Inapplicable(INAPPLICABLE): /use>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(::<Inapplicable(INAPPLICABLE): /loop2>#)
     }
     public final fun loop2(): R|(ERROR CLASS: Cannot infer argument for type parameter T) -> ERROR CLASS: Cannot infer argument for type parameter R| {
         ^loop2 R|/loop1|()
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.kt
index 561f29d2471..a3ce3669f23 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.reversed.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() = use(::<!UNRESOLVED_REFERENCE!>loop2<!>)
+fun loop1() = use(::<!INAPPLICABLE_CANDIDATE!>loop2<!>)
 fun loop2() = loop1()
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
index 010e24b9272..bb525069598 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
@@ -414,11 +414,13 @@ class FirCallResolver(
             !isSuccess -> {
                 val errorReference = buildReferenceWithErrorCandidate(
                     info,
-                    if (applicability == CandidateApplicability.K2_UNSUPPORTED) {
-                        val unsupportedResolutionDiagnostic = reducedCandidates.firstOrNull()?.diagnostics?.firstOrNull() as? Unsupported
-                        ConeUnsupported(unsupportedResolutionDiagnostic?.message ?: "", unsupportedResolutionDiagnostic?.source)
-                    } else {
-                        ConeUnresolvedReferenceError(info.name)
+                    when {
+                        applicability == CandidateApplicability.K2_UNSUPPORTED -> {
+                            val unsupportedResolutionDiagnostic = reducedCandidates.firstOrNull()?.diagnostics?.firstOrNull() as? Unsupported
+                            ConeUnsupported(unsupportedResolutionDiagnostic?.message ?: "", unsupportedResolutionDiagnostic?.source)
+                        }
+                        reducedCandidates.size == 1 -> createConeDiagnosticForCandidateWithError(applicability, reducedCandidates.single())
+                        else -> ConeUnresolvedReferenceError(info.name)
                     },
                     callableReferenceAccess.source
                 )
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
index 7d6814ec7b3..5be4614dd3e 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
@@ -3,7 +3,7 @@
 
 fun f1(x: String) {}
 fun f2(f: () -> Unit) {}
-fun test1() = f2(::<!UNRESOLVED_REFERENCE("f1")!>f1<!>)
+fun test1() = f2(::<!INAPPLICABLE_CANDIDATE("fun f1(x: String): Unit")!>f1<!>)
 
 
 @Target(AnnotationTarget.TYPE_PARAMETER,  AnnotationTarget.TYPE)
diff --git a/compiler/testData/diagnostics/tests/callableReference/adapted/noKFunctionForAdaptation.fir.kt b/compiler/testData/diagnostics/tests/callableReference/adapted/noKFunctionForAdaptation.fir.kt
index 8eab7076077..2621c349681 100644
--- a/compiler/testData/diagnostics/tests/callableReference/adapted/noKFunctionForAdaptation.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/adapted/noKFunctionForAdaptation.fir.kt
@@ -3,12 +3,12 @@ fun foo(x: String = "O"): String = x
 fun bar(x: String = "K"): String = x
 
 fun dump(dumpStrategy: String) {
-    val k0: kotlin.reflect.KFunction0<String> = returnAdapter(::<!UNRESOLVED_REFERENCE!>foo<!>) // Error: ADAPTED_CALLABLE_REFERENCE_AGAINST_REFLECTION_TYPE
+    val k0: kotlin.reflect.KFunction0<String> = returnAdapter(::<!INAPPLICABLE_CANDIDATE!>foo<!>) // Error: ADAPTED_CALLABLE_REFERENCE_AGAINST_REFLECTION_TYPE
     val k1: kotlin.reflect.KFunction0<String> = <!INITIALIZER_TYPE_MISMATCH!>::foo<!>
     // Should be error here, too
     val k2: kotlin.reflect.KFunction0<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>if (dumpStrategy == "KotlinLike") ::foo else ::bar<!>
 
-    val f0: Function0<String> = returnAdapter(::<!UNRESOLVED_REFERENCE!>foo<!>)
+    val f0: Function0<String> = returnAdapter(::<!INAPPLICABLE_CANDIDATE!>foo<!>)
     val f1: Function0<String> = ::foo
     val f2: Function0<String> = if (dumpStrategy == "KotlinLike") ::foo else ::bar
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt
index 7f33b4cbd4c..5b2122695fb 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt
@@ -6,10 +6,10 @@ public interface J {
 
 // FILE: test.kt
 
-fun f1(x: Int?): Any = x::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <T> f2(t: T): Any = t::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <S : String?> f3(s: S): Any = s::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun <U : Any> f4(u: U?): Any = u::<!UNRESOLVED_REFERENCE!>hashCode<!>
-fun f5(c: List<*>): Any = c[0]::<!UNRESOLVED_REFERENCE!>hashCode<!>
+fun f1(x: Int?): Any = x::<!UNSAFE_CALL!>hashCode<!>
+fun <T> f2(t: T): Any = t::<!UNSAFE_CALL!>hashCode<!>
+fun <S : String?> f3(s: S): Any = s::<!UNSAFE_CALL!>hashCode<!>
+fun <U : Any> f4(u: U?): Any = u::<!UNSAFE_CALL!>hashCode<!>
+fun f5(c: List<*>): Any = c[0]::<!UNSAFE_CALL!>hashCode<!>
 
 fun f6(j: J): Any = j.platformString()::hashCode
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.fir.kt
index 442c3627147..8c260b27967 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.fir.kt
@@ -9,7 +9,7 @@ class Foo<out T>(name: T) {
         val ok2 = this@Foo::prop
         val ok3 = object { val y: Any = this@Foo::prop }
 
-        val fail1 = Foo(prop)::<!UNRESOLVED_REFERENCE!>prop<!>
+        val fail1 = Foo(prop)::<!INVISIBLE_REFERENCE!>prop<!>
     }
 
     fun testFunc() {
@@ -17,7 +17,7 @@ class Foo<out T>(name: T) {
         val ok2 = this@Foo::func
         val ok3 = object { val y: Any = this@Foo::func }
 
-        val fail1 = Foo(prop)::<!UNRESOLVED_REFERENCE!>func<!>
+        val fail1 = Foo(prop)::<!INVISIBLE_REFERENCE!>func<!>
     }
 
     private fun func(t: T): T = t
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt
index 2f4780bc6e2..0bbe805ba4d 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt
@@ -19,9 +19,9 @@ class Test {
 
     fun <T> List<T>.testCallable1(): () -> Unit = a::foo
     fun <T> List<T>.testCallable1a(): () -> Unit = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>a<!><T>::foo
-    fun <T> List<T>.testCallable2(): () -> Unit = b?::<!UNRESOLVED_REFERENCE!>foo<!>
-    fun <T> List<T>.testCallable3(): () -> Unit = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>b<!><T, Any>::<!UNRESOLVED_REFERENCE!>foo<!>
-    fun <T> List<T>.testCallable4(): () -> Unit = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>b<!><T>?::<!UNRESOLVED_REFERENCE!>foo<!>
+    fun <T> List<T>.testCallable2(): () -> Unit = b?::<!UNSAFE_CALL!>foo<!>
+    fun <T> List<T>.testCallable3(): () -> Unit = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>b<!><T, Any>::<!UNSAFE_CALL!>foo<!>
+    fun <T> List<T>.testCallable4(): () -> Unit = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>b<!><T>?::<!UNSAFE_CALL!>foo<!>
 
     fun <T> List<T>.testClassLiteral1() = a::class
     fun <T> List<T>.testClassLiteral1a() = <!EXPLICIT_TYPE_ARGUMENTS_IN_PROPERTY_ACCESS!>a<!><T>::class
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt
index 1a8ec946b8a..254f337237f 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt
@@ -4,4 +4,4 @@ package test
 fun nullableFun(): Int? = null
 fun Int.foo() {}
 
-val test1 = nullableFun()?::<!UNRESOLVED_REFERENCE!>foo<!>
+val test1 = nullableFun()?::<!UNSAFE_CALL!>foo<!>
diff --git a/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt b/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt
index eae0aa00f0d..47da11be8c7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt
@@ -18,6 +18,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)
-    baz(A::<!UNRESOLVED_REFERENCE!>bla<!>)
+    baz(A::<!INAPPLICABLE_CANDIDATE!>bla<!>)
     star(A::bla)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt b/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt
index 6f84b03e6ff..cb3fe48d189 100644
--- a/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt
@@ -14,5 +14,5 @@ fun <K, V> B<K>.foo(p: KProperty1<K, V>) {}
 class C : A
 
 fun <R : A> B<R>.test(){
-    foo(C::<!UNRESOLVED_REFERENCE!>bla<!>)
+    foo(C::<!INAPPLICABLE_CANDIDATE!>bla<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
index 86913a82ace..4f913e25bf8 100644
--- a/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
@@ -7,6 +7,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
 fun cr() {}
 
 fun test() {
-    takeIt(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
+    takeIt(42, ::<!INAPPLICABLE_CANDIDATE!>cr<!>)
     takeIt(42, <!ARGUMENT_TYPE_MISMATCH!>{ }<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt
index dabdec37e8c..d919a018e30 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt
@@ -8,5 +8,5 @@ fun main() {
     ::<!UNRESOLVED_REFERENCE!>A<!>
     ::<!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B<!>
     ::<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>C<!>   // KT-3465
-    ::<!UNRESOLVED_REFERENCE!>D<!>
+    ::<!INVISIBLE_REFERENCE!>D<!>
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
index cb21ffcfa16..7e866f8668e 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
@@ -25,7 +25,7 @@ class A {
 
         expectFunction0Unit(::foo)
         expectFunction0String(::foo)
-        expectFunction1Unit(::<!UNRESOLVED_REFERENCE!>foo<!>)
-        expectFunction1String(::<!UNRESOLVED_REFERENCE!>foo<!>)
+        expectFunction1Unit(::<!INAPPLICABLE_CANDIDATE!>foo<!>)
+        expectFunction1String(::<!INAPPLICABLE_CANDIDATE!>foo<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt
index fc8eea48886..62c5d3f9615 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt
+++ b/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() {
-    foo(1, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    foo(1, A::<!INAPPLICABLE_CANDIDATE!>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) {
-    foo(x, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    foo(x, A::<!INAPPLICABLE_CANDIDATE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
     foo(x, ::bar)
 
     complex(x, ::bar)
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt b/compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt
index 00fd1ed9da6..29433d0f8b4 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt
@@ -13,7 +13,7 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
 
 fun test() {
     takeFun<String>(::foo)
-    takeFun<String>(::<!UNRESOLVED_REFERENCE!>fooInt<!>)
+    takeFun<String>(::<!INAPPLICABLE_CANDIDATE!>fooInt<!>)
 
     callFun<String, Wrapper<String>>(::createWrapper)
     callFun<Int, Wrapper<Number>>(::createWrapper)
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt
index 5582063a049..b9f2892c322 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt
@@ -22,8 +22,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>>() }
-    bar<Wrapper, T, T>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
-    bar<Wrapper, Int, Int>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
+    bar<Wrapper, T, T>(Wrapper::<!INAPPLICABLE_CANDIDATE!>fooReturnString<!>)
+    bar<Wrapper, Int, Int>(Wrapper::<!INAPPLICABLE_CANDIDATE!>fooReturnString<!>)
 
     bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
     bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
diff --git a/compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt b/compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt
index 995bf4d0184..456c8a638e7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt
@@ -4,7 +4,7 @@ fun foo(vararg ints: Int) {}
 fun test(i: IntArray) {
     myLet(i, ::foo)
     myLet(::foo)
-    myLet<Int>(::<!UNRESOLVED_REFERENCE!>foo<!>)
+    myLet<Int>(::<!INAPPLICABLE_CANDIDATE!>foo<!>)
     myLet<IntArray>(::foo)
     myLetExplicit1(::foo)
     myLetExplicit2(::foo)
diff --git a/compiler/testData/diagnostics/tests/callableReference/kt46437.fir.kt b/compiler/testData/diagnostics/tests/callableReference/kt46437.fir.kt
index 44e6814a701..2bd177997e1 100644
--- a/compiler/testData/diagnostics/tests/callableReference/kt46437.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/kt46437.fir.kt
@@ -1,5 +1,5 @@
 fun box(): String {
-    if (true) X::<!UNRESOLVED_REFERENCE!>y<!> else null
+    if (true) X::<!INVISIBLE_REFERENCE!>y<!> else null
     return "OK"
 }
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt b/compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt
index acb5d9506f8..88854f3feff 100644
--- a/compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt
@@ -15,11 +15,11 @@ class A {
 
 fun test() {
     String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext<!>
-    Obj::<!UNRESOLVED_REFERENCE!>ext<!>
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Obj::ext<!>
 
     String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext2<!>
-    A.Companion::<!UNRESOLVED_REFERENCE!>ext2<!>
-    A::<!UNRESOLVED_REFERENCE!>ext2<!>
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>A.Companion::ext2<!>
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>A::ext2<!>
 
     A::<!UNRESOLVED_REFERENCE!>foo<!>
     A::<!UNRESOLVED_REFERENCE!>bar<!>
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.fir.kt
index e2c3f36339b..17869fb872a 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.fir.kt
+++ b/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?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateFinal<!>
-    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateMutable<!>
+    val privFinRef: KProperty1<JavaClass, String?> = JavaClass::<!INVISIBLE_REFERENCE!>privateFinal<!>
+    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::<!INVISIBLE_REFERENCE!>privateMutable<!>
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.fir.kt
index e5362097048..b3f62015aec 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.fir.kt
+++ b/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 privMutRef: KMutableProperty<Throwable?> = ::<!UNRESOLVED_REFERENCE!>privateMutable<!>
+    val privFinRef: KProperty<JavaClass?> = ::<!INVISIBLE_REFERENCE!>privateFinal<!>
+    val privMutRef: KMutableProperty<Throwable?> = ::<!INVISIBLE_REFERENCE!>privateMutable<!>
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.fir.kt
index 07280bcb466..fc0641a74e3 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.fir.kt
@@ -22,6 +22,6 @@ object Local {
     fun baz(x: Int, y: Int = 0): Int = 0
 
     fun test() {
-        bar(::<!UNRESOLVED_REFERENCE!>baz<!>)
+        bar(::<!INAPPLICABLE_CANDIDATE!>baz<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.fir.kt
index 7c0b8f8f939..597c63f7b05 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.fir.kt
@@ -22,6 +22,6 @@ object Local {
     fun baz(x: Int, y: Int = 0): Int = 0
 
     fun test() {
-        bar(::<!UNRESOLVED_REFERENCE!>baz<!>)
+        bar(::<!INAPPLICABLE_CANDIDATE!>baz<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt
index 203670aacc0..3640c45fa0e 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt
@@ -5,4 +5,4 @@ import kotlin.reflect.KProperty0
 object A
 
 fun <TProperty> property0(property: KProperty0<TProperty>) = A
-val <K> K.key get() : A = property0(Map.Entry<K, *>::<!UNRESOLVED_REFERENCE!>key<!>) // should be forbidden
+val <K> K.key get() : A = property0(Map.Entry<K, *>::<!INAPPLICABLE_CANDIDATE!>key<!>) // should be forbidden
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt
index 69546dbdc88..0d91f681fe7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt
@@ -10,6 +10,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
-    baz(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
-    bar(::<!UNRESOLVED_REFERENCE!>fooB<!>, a)
+    baz(a, ::<!INAPPLICABLE_CANDIDATE!>fooB<!>)
+    bar(::<!INAPPLICABLE_CANDIDATE!>fooB<!>, a)
 }
diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt b/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt
index cedbdc38b5e..79ba936d589 100644
--- a/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt
@@ -26,7 +26,7 @@ infix fun filter(filter: (R, Any?) -> Boolean): Delegate<R, T>
 class GitLabChangesProcessor: DatabaseEntity {
     var buildProcessors by child_many(
         GitLabBuildProcessor::class.java,
-        GitLabBuildProcessor::<!UNRESOLVED_REFERENCE!>processor<!>
+        GitLabBuildProcessor::<!INAPPLICABLE_CANDIDATE!>processor<!>
     )
 }
 
diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt b/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt
index a00df2948db..a78904be132 100644
--- a/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt
@@ -27,7 +27,7 @@ infix fun filter(filter: (R, Any?) -> Boolean): Delegate<R, T>
 class GitLabChangesProcessor: DatabaseEntity {
     var buildProcessors by child_many(
         GitLabBuildProcessor::class.java,
-        GitLabBuildProcessor::<!UNRESOLVED_REFERENCE!>processor<!>
+        GitLabBuildProcessor::<!INAPPLICABLE_CANDIDATE!>processor<!>
     )
 }
 
diff --git a/compiler/testData/diagnostics/tests/fieldRename/javaProtectedFieldAndKotlinInvisiblePropertyReference.fir.kt b/compiler/testData/diagnostics/tests/fieldRename/javaProtectedFieldAndKotlinInvisiblePropertyReference.fir.kt
index 701de67cda4..5424fff8e69 100644
--- a/compiler/testData/diagnostics/tests/fieldRename/javaProtectedFieldAndKotlinInvisiblePropertyReference.fir.kt
+++ b/compiler/testData/diagnostics/tests/fieldRename/javaProtectedFieldAndKotlinInvisiblePropertyReference.fir.kt
@@ -56,7 +56,7 @@ class Derived : Intermediate() {
 
     fun bar() = a // Non-reference
 
-    fun baz() = this::<!UNRESOLVED_REFERENCE!>b<!> // Non-protected
+    fun baz() = this::<!INVISIBLE_REFERENCE!>b<!> // Non-protected
 }
 
 typealias Alias = Intermediate
@@ -90,5 +90,5 @@ class DirectlyDerived : BaseJava() {
 }
 
 fun test(d: Derived) {
-    d::<!UNRESOLVED_REFERENCE!>a<!> // Field is also invisible
+    d::<!INVISIBLE_REFERENCE!>a<!> // Field is also invisible
 }
diff --git a/compiler/testData/diagnostics/tests/inference/kt39220.fir.kt b/compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
index 4ada5ae2a3c..adcf17020ab 100644
--- a/compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
@@ -114,14 +114,14 @@ fun <T : Foo, R: Number, D: Int> main() {
     bar7(Foo::resolve) // OK
 
     // with LHS and sentension function expected type
-    bar10<D>(Int::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
+    bar10<D>(Int::<!INAPPLICABLE_CANDIDATE!>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
-        bar10<D>(::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
-        bar10<Int>(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
-        bar10(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
+        bar10<D>(::<!INAPPLICABLE_CANDIDATE!>x1<!>) // ERROR before the fix in NI
+        bar10<Int>(::<!INAPPLICABLE_CANDIDATE!>x1<!>) // OK
+        bar10(::<!INAPPLICABLE_CANDIDATE!>x1<!>) // OK
     }
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt b/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt
index 48c9bef96a7..63ce474ff44 100644
--- a/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt
+++ b/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> = <!INITIALIZER_TYPE_MISMATCH!>inv::<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>map<!><!>
-    take(inv::<!UNRESOLVED_REFERENCE!>map<!>)
+    take(inv::<!INAPPLICABLE_CANDIDATE!>map<!>)
 }
 
 fun take(f: ((String) -> String) -> Inv<String>) {}
diff --git a/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.fir.kt b/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.fir.kt
index 3536c68318e..063b6ce1cac 100644
--- a/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.fir.kt
+++ b/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.fir.kt
@@ -14,5 +14,5 @@ fun test() {
     foo2(42, ::bar2)
     foo2("str", ::bar2)
 
-    foo2(42, ::<!UNRESOLVED_REFERENCE!>bar1<!>)
+    foo2(42, ::<!INAPPLICABLE_CANDIDATE!>bar1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.fir.kt b/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.fir.kt
index a370fdbd428..a158ea76755 100644
--- a/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.fir.kt
@@ -20,9 +20,9 @@ fun test() {
     useStringArray(::stringVararg)
     useIntArray(::numberVararg)
     usePrimitiveIntArray(::intVararg)
-    useIntArray(::<!UNRESOLVED_REFERENCE!>intVararg<!>)
-    useMixedStringArgs1(::<!UNRESOLVED_REFERENCE!>stringVararg<!>)
-    useMixedStringArgs2(::<!UNRESOLVED_REFERENCE!>stringVararg<!>)
-    useMixedStringArgs3(::<!UNRESOLVED_REFERENCE!>stringVararg<!>)
-    useTwoStringArrays(::<!UNRESOLVED_REFERENCE!>stringVararg<!>)
+    useIntArray(::<!INAPPLICABLE_CANDIDATE!>intVararg<!>)
+    useMixedStringArgs1(::<!INAPPLICABLE_CANDIDATE!>stringVararg<!>)
+    useMixedStringArgs2(::<!INAPPLICABLE_CANDIDATE!>stringVararg<!>)
+    useMixedStringArgs3(::<!INAPPLICABLE_CANDIDATE!>stringVararg<!>)
+    useTwoStringArrays(::<!INAPPLICABLE_CANDIDATE!>stringVararg<!>)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.fir.kt
index 5360e356001..92f3d015856 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.fir.kt
@@ -10,7 +10,7 @@ suspend fun String.id(): String = this
 fun box() {
     val x = "f"
     builder {
-        go1(x::<!UNRESOLVED_REFERENCE!>id<!>)
-        go2(x::<!UNRESOLVED_REFERENCE!>id<!>)
+        go1(x::<!INAPPLICABLE_CANDIDATE!>id<!>)
+        go2(x::<!INAPPLICABLE_CANDIDATE!>id<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.fir.kt
index 56be7f1b012..ad4c2065b61 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.fir.kt
@@ -14,8 +14,8 @@ suspend fun bar(x: Int) {}
 
 fun test() {
     test0(::foo)
-    test1(::<!UNRESOLVED_REFERENCE!>foo<!>)
+    test1(::<!INAPPLICABLE_CANDIDATE!>foo<!>)
 
-    test0(::<!UNRESOLVED_REFERENCE!>bar<!>)
+    test0(::<!INAPPLICABLE_CANDIDATE!>bar<!>)
     test1(::bar)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt
index 7a0ea532842..672525b7cd7 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt
@@ -9,7 +9,7 @@ class ProcessorWithParent : Entity {
 }
 
 class ProcessorWithChildren : Entity {
-    var processors by children(ProcessorWithParent::class.java, ProcessorWithParent::<!UNRESOLVED_REFERENCE!>processor<!>)
+    var processors by children(ProcessorWithParent::class.java, ProcessorWithParent::<!INAPPLICABLE_CANDIDATE!>processor<!>)
 }
 
 class Processor2WithParent : Entity {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.txt b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.txt
index 0c43ed18384..98b2a44ddb6 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.txt
@@ -18,7 +18,7 @@ FILE: kt50994.fir.kt
             super<R|kotlin/Any|>()
         }
 
-        public final var processors: R|kotlin/collections/MutableCollection<ProcessorWithParent>|by this@R|/ProcessorWithChildren|.R|/children<Inapplicable(INAPPLICABLE): /children>#|<R|ProcessorWithChildren|, R|ProcessorWithParent|>(<getClass>(Q|ProcessorWithParent|).R|kotlin/jvm/java|<R|ProcessorWithParent|>, Q|ProcessorWithParent|::<Unresolved reference: processor>#)
+        public final var processors: R|kotlin/collections/MutableCollection<ProcessorWithParent>|by this@R|/ProcessorWithChildren|.R|/children<Inapplicable(INAPPLICABLE): /children>#|<R|ProcessorWithChildren|, R|ProcessorWithParent|>(<getClass>(Q|ProcessorWithParent|).R|kotlin/jvm/java|<R|ProcessorWithParent|>, Q|ProcessorWithParent|::<Inapplicable(INAPPLICABLE): /ProcessorWithParent.processor>#)
             public get(): R|kotlin/collections/MutableCollection<ProcessorWithParent>| {
                 ^ this@R|/ProcessorWithChildren|.D|/ProcessorWithChildren.processors|.R|SubstitutionOverride</Delegate.getValue: R|kotlin/collections/MutableCollection<ProcessorWithParent>|>|(this@R|/ProcessorWithChildren|, ::R|/ProcessorWithChildren.processors|)
             }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.2.fir.kt
index e625400b03d..c7cc1be185b 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.2.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.2.fir.kt
@@ -21,7 +21,7 @@ fun case1() {
     val x : Case1? = Case1()
     x.<!VAL_REASSIGNMENT!>x<!> = "0"
     x?.<!VAL_REASSIGNMENT!>x<!> = "0"
-    <!VARIABLE_EXPECTED!>x::<!UNRESOLVED_REFERENCE!>x<!><!> = TODO()
+    <!VARIABLE_EXPECTED!>x::x<!> = TODO()
 }
 
 class Case1{
@@ -37,7 +37,7 @@ fun case2() {
     val x : Case2? = Case2(null)
     x.<!VAL_REASSIGNMENT!>x<!> = "0"
     x?.<!VAL_REASSIGNMENT!>x<!> = "0"
-    <!VARIABLE_EXPECTED!>x::<!UNRESOLVED_REFERENCE!>x<!><!> = TODO()
+    <!VARIABLE_EXPECTED!>x::x<!> = TODO()
 }
 
 class Case2(val x: Any?) {}
@@ -50,7 +50,7 @@ fun case3() {
     val x : Case3? = Case3()
     x.<!VAL_REASSIGNMENT!>x<!> = "0"
     x?.<!VAL_REASSIGNMENT!>x<!> = "0"
-    <!VARIABLE_EXPECTED!>x::<!UNRESOLVED_REFERENCE!>x<!><!> = TODO()
+    <!VARIABLE_EXPECTED!>x::x<!> = TODO()
 }
 
 class Case3() {