FIR checker: skip error named reference if receiver is unresolved

Currently, FIR reports errors caused by previous resolution failure. For
example with unresolved `a` and `b` in code `a.b`, both `a` and `b` are
highlighted. FE1.0 only highlights `a` since it's the root cause. This
change applies this heuristics when reporting FirDiagnostics.

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

@@ -15,13 +15,13 @@ class CallBasedInExpressionGenerator(
     operatorReference: KtSimpleNameExpression
 ) : InExpressionGenerator {
     private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)
-    private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
+    private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.NOT_IN
 
     override fun generate(argument: StackValue): BranchedValue =
         gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
 
     private fun gen(argument: StackValue): BranchedValue =
-        object : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!>)<!> {
+        object : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ)<!> {
             override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) {
                 invokeFunction(v)
                 <!UNRESOLVED_REFERENCE!>coerceTo<!>(type, kotlinType, v)
@@ -29,7 +29,7 @@ class CallBasedInExpressionGenerator(
 
             override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
                 invokeFunction(v)
-                v.<!UNRESOLVED_REFERENCE!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)
+                v.<!UNRESOLVED_REFERENCE!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ else <!UNRESOLVED_REFERENCE!>Opcodes<!>.IFNE, jumpLabel)
             }
 
             private fun invokeFunction(v: InstructionAdapter) {

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

@@ -18,4 +18,4 @@ fun test() {
     B.foo()
 }
 
-val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+val bb = <!UNRESOLVED_REFERENCE!>B<!>.foo()

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

@@ -6,5 +6,5 @@ object A {
 
 object B
 
-val err = B.<!UNRESOLVED_REFERENCE!>A<!>.<!UNRESOLVED_REFERENCE!>B<!>
+val err = B.<!UNRESOLVED_REFERENCE!>A<!>.B
 val correct = A.B.A

compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt

@@ -23,7 +23,7 @@ fun main() {
         x <!UNRESOLVED_REFERENCE!>><!> 1
     }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> > 1 })
 
     val x = { x: Int -> x > 1 }
 

compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt

@@ -79,7 +79,7 @@ fun test_5(a: A, in1: In1<A>, in2: In1<in A>, in3: In1<out A>) {
 
 fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) {
     out1.value().foo()
-    out2.<!UNRESOLVED_REFERENCE!>value<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
+    out2.<!UNRESOLVED_REFERENCE!>value<!>().foo()
     out3.value().foo()
 }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt

@@ -34,17 +34,28 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
 
     override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: CheckerContext) {
         val source = errorNamedReference.source ?: return
-        val qualifiedAccessSource = data.qualifiedAccesses.lastOrNull()?.takeIf {
+        val qualifiedAccess = data.qualifiedAccesses.lastOrNull()?.takeIf {
             // Use the source of the enclosing FirQualifiedAccessExpression if it is exactly the call to the erroneous callee.
             it is FirQualifiedAccessExpression && it.calleeReference == errorNamedReference
-        }?.source
+        }
         // Don't report duplicated unresolved reference on annotation entry (already reported on its type)
         if (source.elementType == KtNodeTypes.ANNOTATION_ENTRY && errorNamedReference.diagnostic is ConeUnresolvedNameError) return
         // Already reported in FirConventionFunctionCallChecker
         if (source.kind == FirFakeSourceElementKind.ArrayAccessNameReference &&
             errorNamedReference.diagnostic is ConeUnresolvedNameError
         ) return
-        reportFirDiagnostic(errorNamedReference.diagnostic, source, reporter, data, qualifiedAccessSource)
+
+        // If the receiver cannot be resolved, we skip reporting any further problems for this call.
+        if (qualifiedAccess?.dispatchReceiver.hasUnresolvedNameError() || qualifiedAccess?.extensionReceiver.hasUnresolvedNameError() || qualifiedAccess?.explicitReceiver.hasUnresolvedNameError()) return
+
+        reportFirDiagnostic(errorNamedReference.diagnostic, source, reporter, data, qualifiedAccess?.source)
+    }
+
+    private fun FirExpression?.hasUnresolvedNameError(): Boolean {
+        return when ((this?.typeRef as? FirErrorTypeRef)?.diagnostic) {
+            is ConeUnresolvedNameError -> true
+            else -> false
+        }
     }
 
     override fun visitErrorExpression(errorExpression: FirErrorExpression, data: CheckerContext) {

compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt

@@ -6,8 +6,8 @@ fun test(c : Char) {
   <!UNRESOLVED_REFERENCE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>'<!>
   <!UNRESOLVED_REFERENCE!>test<!>(0<!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>'<!>
   <!UNRESOLVED_REFERENCE!>test<!>('\n')
-  <!UNRESOLVED_REFERENCE!>test<!>('\\')
+  test('\\')
-  <!UNRESOLVED_REFERENCE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>''<!>)
+  test(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>''<!>)
   test('\'')
   test('\"')
 }

compiler/testData/diagnostics/tests/CompareToWithErrorType.fir.kt

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun test() {
-  if (<!UNRESOLVED_REFERENCE!>x<!> <!UNRESOLVED_REFERENCE!>><!> 0) {
+  if (<!UNRESOLVED_REFERENCE!>x<!> > 0) {
 
   }
 }

compiler/testData/diagnostics/tests/DeferredTypes.fir.kt

@@ -1,5 +1,5 @@
 // NI_EXPECTED_FILE
 
 interface T {
-  val a = <!PROPERTY_INITIALIZER_IN_INTERFACE!><!UNRESOLVED_REFERENCE!>Foo<!>.<!UNRESOLVED_REFERENCE!>bar<!>()<!>
+  val a = <!PROPERTY_INITIALIZER_IN_INTERFACE!><!UNRESOLVED_REFERENCE!>Foo<!>.bar()<!>
-}
+}

compiler/testData/diagnostics/tests/PackageQualified.fir.kt

@@ -25,7 +25,7 @@ package foobar.a
 
 // FILE: d.kt
 package foobar
-val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>a<!>
+val x1 = <!UNRESOLVED_REFERENCE!>a<!>.a
 val x2 = foobar.a.a
 
 val y1 = foobar.a.b

compiler/testData/diagnostics/tests/Unresolved.fir.kt

@@ -22,11 +22,11 @@ fun testUnresolved() {
         is String -> <!UNRESOLVED_REFERENCE!>a<!>
     }
 
-    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (j in <!UNRESOLVED_REFERENCE!>collection<!>) {
+    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (j in <!UNRESOLVED_REFERENCE!>collection<!>) {
        var i: Int = j
        i += 1
        foo1(j)
     }<!>
 }
 
-fun foo1(i: Int) {}
+fun foo1(i: Int) {}

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

@@ -34,7 +34,7 @@ annotation class Ann8(val p1: Array<String>,
                       val p4: Array<Ann1>)
 
 annotation class Ann9(
-        val error: <!UNRESOLVED_REFERENCE!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.<!UNRESOLVED_REFERENCE!>VALUE<!>
+        val error: <!UNRESOLVED_REFERENCE!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.VALUE
 )
 
 

compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt

@@ -28,7 +28,7 @@ abstract class My(@Field arg: Int, @Field val w: Int) {
     fun foo() {}
 
     @Field
-    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 42 }
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.lazy { 42 }
 }
 
 enum class Your {

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

@@ -1 +1 @@
-fun test() = ("").<!UNRESOLVED_REFERENCE!>hashCode<!>::<!UNRESOLVED_REFERENCE!>hashCode<!>
+fun test() = ("").<!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<!>()::<!UNRESOLVED_REFERENCE!>bar<!>
+    fun f() = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::bar
 }
 
-val f: () -> Unit = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::<!UNRESOLVED_REFERENCE!>foo<!>
+val f: () -> Unit = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::foo

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

@@ -10,15 +10,15 @@ fun test1() {
 
     A::<!UNRESOLVED_REFERENCE!>bar<!>
 
-    <!UNRESOLVED_REFERENCE!>B<!>::<!UNRESOLVED_REFERENCE!>bar<!>
+    <!UNRESOLVED_REFERENCE!>B<!>::bar
 }
 
 fun test2() {
     fun foo(x: Any) {}
     fun foo() {}
 
-    <!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    <!UNRESOLVED_REFERENCE!>Unresolved<!>::foo
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::foo)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>unresolved<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved)
     ::<!UNRESOLVED_REFERENCE!>unresolved<!>
 }

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

@@ -4,22 +4,22 @@
 fun foo() {}
 
 fun main() {
-    val x1 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
+    val x1 = <!UNRESOLVED_REFERENCE!>logger<!>::info?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x2 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
+    val x2 = <!UNRESOLVED_REFERENCE!>logger<!>?::info?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x3 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>::<!UNRESOLVED_REFERENCE!>print<!>
+    val x3 = <!UNRESOLVED_REFERENCE!>logger<!>?::info::<!UNRESOLVED_REFERENCE!>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 x4 = <!UNRESOLVED_REFERENCE!>logger<!>?::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!>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!>logger<!>::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!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
     val x7 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
     val x8 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
     val x9 = <!UNRESOLVED_REFERENCE!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
-    val x10 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::print!!::<!UNRESOLVED_REFERENCE!>print<!>
+    val x10 = <!UNRESOLVED_REFERENCE!>logger<!>::info?::print!!::<!UNRESOLVED_REFERENCE!>print<!>
     val x11 = <!UNRESOLVED_REFERENCE!>logger<!>!!::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
     val x12 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
     val x13 = 42?::<!UNRESOLVED_REFERENCE!>unresolved<!>?::<!UNRESOLVED_REFERENCE!>print<!>
 
     val x14 = <!UNRESOLVED_REFERENCE!>logger<!><!SYNTAX!>?!!::info?::print?::print<!>
-    val x15 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!><!SYNTAX!>?!!::print?::print<!>
+    val x15 = <!UNRESOLVED_REFERENCE!>logger<!>::info<!SYNTAX!>?!!::print?::print<!>
     val x16 = <!UNRESOLVED_REFERENCE!>logger<!>!!?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
     val x17 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
 

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.fir.kt

@@ -43,7 +43,7 @@ fun f() {
     A.Obj
     A.Companion.Obj2
     A.<!UNRESOLVED_REFERENCE!>Obj2<!>
-    A.<!UNRESOLVED_REFERENCE!>Obj2<!>.<!UNRESOLVED_REFERENCE!>c<!>
+    A.<!UNRESOLVED_REFERENCE!>Obj2<!>.c
     A.<!UNRESOLVED_REFERENCE!>Nested2<!>
 
     O.O

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_after.fir.kt

@@ -38,7 +38,7 @@ fun f() {
     C.E2.B()
 
     C.E2.<!UNRESOLVED_REFERENCE!>O<!>
-    C.E3.<!UNRESOLVED_REFERENCE!>O<!>.<!UNRESOLVED_REFERENCE!>InO<!>
+    C.E3.<!UNRESOLVED_REFERENCE!>O<!>.InO
 
     C.O
     C.O.InO

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_before.fir.kt

@@ -38,7 +38,7 @@ fun f() {
     C.E2.B()
 
     C.E2.<!UNRESOLVED_REFERENCE!>O<!>
-    C.E3.<!UNRESOLVED_REFERENCE!>O<!>.<!UNRESOLVED_REFERENCE!>InO<!>
+    C.E3.<!UNRESOLVED_REFERENCE!>O<!>.InO
 
     C.O
     C.O.InO

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt

@@ -24,24 +24,24 @@ fun bar(aInstance: A, bInstance: B) {
 
     foo(bInstance) {
         (a, b): A, (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }
 
     foo(bInstance) {
         (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }
 
     foo<A, B>(bInstance) {
         (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.fir.kt

@@ -23,7 +23,7 @@ fun bar() {
     }
 
     foo { (a, b), (c, b) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.fir.kt

@@ -36,8 +36,8 @@ fun bar() {
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.fir.kt

@@ -8,35 +8,35 @@ fun foo(block: (A) -> Unit) { }
 
 fun bar() {
     foo { (_, b) ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
         b checkType { _<String>() }
     }
 
     foo { (a, _) ->
         a checkType { _<Int>() }
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
     }
 
     foo { (_, _) ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
     }
 
     foo { (_: Int, b: String) ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
         b checkType { _<String>() }
     }
 
     foo { (a: Int, _: String) ->
         a checkType { _<Int>() }
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
     }
 
     foo { (_: Int, _: String) ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
     }
 
     foo { (_, _): A ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
     }
 
     foo { (`_`, _) ->
@@ -52,12 +52,12 @@ fun bar() {
     }
 
     foo { (_: String, b) ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
         b checkType { _<String>() }
     }
 
     <!INAPPLICABLE_CANDIDATE!>foo<!> { (_, b): B ->
-        <!UNRESOLVED_REFERENCE!>_<!>.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        <!UNRESOLVED_REFERENCE!>_<!>.hashCode()
         b checkType { _<Short>() }
     }
 }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.fir.kt

@@ -32,12 +32,12 @@ fun bar() {
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         d checkType { _<Short>() }
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
     }
 }

compiler/testData/diagnostics/tests/imports/ClassClashStarImport.fir.kt

@@ -71,6 +71,6 @@ fun test(b: B) {
     val b_3 = B()
     b_3.m2()
 
-    val b_4 = <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>B<!>()
+    val b_4 = <!UNRESOLVED_REFERENCE!>a<!>.B()
     b_4.<!UNRESOLVED_REFERENCE!>m2<!>()
 }

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

@@ -3,18 +3,18 @@
 fun test1() {
     if (<!UNRESOLVED_REFERENCE!>rr<!>) {
         if (<!UNRESOLVED_REFERENCE!>l<!>) {
-            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>q<!>()
+            <!UNRESOLVED_REFERENCE!>a<!>.q()
         }
         else {
-            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>w<!>()
+            <!UNRESOLVED_REFERENCE!>a<!>.w()
         }
     }
     else {
         if (<!UNRESOLVED_REFERENCE!>n<!>) {
-            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>t<!>()
+            <!UNRESOLVED_REFERENCE!>a<!>.t()
         }
         else {
-            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>u<!>()
+            <!UNRESOLVED_REFERENCE!>a<!>.u()
         }
     }
 }

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.fir.kt

@@ -4,5 +4,5 @@ package bar
 fun main() {
     class Some
 
-    Some[<!SYNTAX!><!>] <!UNRESOLVED_REFERENCE!>names<!> <!SYNTAX!>=<!> <!NO_GET_METHOD!>["ads"]<!>
+    Some[<!SYNTAX!><!>] names <!SYNTAX!>=<!> <!NO_GET_METHOD!>["ads"]<!>
 }

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt

@@ -1,50 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
-
-fun println(x: String) {
-}
-
-fun run(block: () -> Unit) {}
-
-val propertyNameOnTheNextLine = 1
-
-fun foo() {
-    val<!SYNTAX!><!>
-    println("abc")
-
-    val<!SYNTAX!><!>
-    run {
-        println("abc")
-    }
-
-    val<!SYNTAX!><!>
-    if (1 == 1) {
-
-    }
-
-    val<!SYNTAX!><!>
-    (1 + 2)
-
-    // `propertyNameOnTheNextLine` parsed as simple name expression
-    val<!SYNTAX!><!>
-    propertyNameOnTheNextLine
-
-    val<!SYNTAX!><!>
-    // comment
-    propertyNameOnTheNextLine
-
-    val<!SYNTAX!><!> /* comment */
-    propertyNameOnTheNextLine
-
-    // Correct properties
-    val
-    property1 = 1
-
-    val
-    propertyWithBy by <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 1 }
-
-    val
-    propertyWithType: Int
-
-    val
-    (a, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>1<!>
-}

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 
 fun println(x: String) {

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

@@ -1,7 +1,7 @@
 package b
 
 fun foo() {
-    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (i in <!UNRESOLVED_REFERENCE!>collection<!>) {
+    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (i in <!UNRESOLVED_REFERENCE!>collection<!>) {
         {
          break
     }

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

@@ -1,4 +1,4 @@
 fun foo(a: Int) {
-    <!UNRESOLVED_REFERENCE!>!<!><!UNRESOLVED_REFERENCE!>bbb<!>
+    !<!UNRESOLVED_REFERENCE!>bbb<!>
     <!UNRESOLVED_REFERENCE!>bbb<!> + a
-}
+}

compiler/testData/diagnostics/tests/infos/SmartCasts.fir.kt

@@ -89,17 +89,17 @@ fun f13(a : A?) {
   }
   else {
     a?.foo()
-    <!UNRESOLVED_REFERENCE!>c<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
   }
 
   a?.foo()
   if (!(a is B)) {
     a?.foo()
-    <!UNRESOLVED_REFERENCE!>c<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
   }
   else {
     a.foo()
-    <!UNRESOLVED_REFERENCE!>c<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
   }
 
   a?.foo()
@@ -109,7 +109,7 @@ fun f13(a : A?) {
   }
   else {
     a?.foo()
-    <!UNRESOLVED_REFERENCE!>c<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
   }
 
   if (!(a is B) || !(a is C)) {

compiler/testData/diagnostics/tests/inline/nonPublicMember/kt14887.fir.kt

@@ -1,6 +1,6 @@
 inline fun foo() {
-    <!UNRESOLVED_REFERENCE!>unresolved<!>().<!UNRESOLVED_REFERENCE!>another<!>
+    <!UNRESOLVED_REFERENCE!>unresolved<!>().another
-    <!UNRESOLVED_REFERENCE!>unresolved<!>().<!UNRESOLVED_REFERENCE!>another<!>()
+    <!UNRESOLVED_REFERENCE!>unresolved<!>().another()
 }
 
 fun main() {

compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.fir.kt

@@ -27,27 +27,27 @@ fun test(with: WithClassObject, without: WithoutClassObject, obj: Obj) {
     with.<!UNRESOLVED_REFERENCE!>Nested<!>()
     with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>
     with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.foo()
-    with.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.<!UNRESOLVED_REFERENCE!>A<!>
+    with.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.A
     with.<!UNRESOLVED_REFERENCE!>NestedObj<!>
     with.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
-    with.<!UNRESOLVED_REFERENCE!>NestedObj<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    with.<!UNRESOLVED_REFERENCE!>NestedObj<!>.foo()
 
     without.<!UNRESOLVED_REFERENCE!>Nested<!>()
     without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>
     without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.foo()
-    without.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.<!UNRESOLVED_REFERENCE!>A<!>
+    without.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.A
     without.<!UNRESOLVED_REFERENCE!>NestedObj<!>
     without.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
-    without.<!UNRESOLVED_REFERENCE!>NestedObj<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    without.<!UNRESOLVED_REFERENCE!>NestedObj<!>.foo()
 
     obj.<!UNRESOLVED_REFERENCE!>Nested<!>()
     obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>
     obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>.foo()
-    obj.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.<!UNRESOLVED_REFERENCE!>A<!>
+    obj.<!UNRESOLVED_REFERENCE!>NestedEnum<!>.A
     obj.<!UNRESOLVED_REFERENCE!>NestedObj<!>
     obj.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
-    obj.<!UNRESOLVED_REFERENCE!>NestedObj<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    obj.<!UNRESOLVED_REFERENCE!>NestedObj<!>.foo()
 }

compiler/testData/diagnostics/tests/j+k/differentFilename.fir.kt

@@ -22,5 +22,5 @@ fun main(x: A) {
     x.b().<!UNRESOLVED_REFERENCE!>bar<!>()
     x.f().<!UNRESOLVED_REFERENCE!>foobaz<!>()
 
-    <!UNRESOLVED_REFERENCE!>D<!>().<!UNRESOLVED_REFERENCE!>baz<!>()
+    <!UNRESOLVED_REFERENCE!>D<!>().baz()
 }

compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt

@@ -22,6 +22,6 @@ fun test() {
     bar(1, z = "", y = 2)
     <!INAPPLICABLE_CANDIDATE!>bar<!>(z = "", 1)
     <!INAPPLICABLE_CANDIDATE!>bar<!>(1, zz = "",
-           <!UNRESOLVED_REFERENCE!>zz<!>.<!UNRESOLVED_REFERENCE!>foo<!>
+           <!UNRESOLVED_REFERENCE!>zz<!>.foo
            )
-}
+}

compiler/testData/diagnostics/tests/objects/ObjectsLocal.fir.kt

@@ -22,4 +22,4 @@ fun test() {
     B.foo()
 }
 
-val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+val bb = <!UNRESOLVED_REFERENCE!>B<!>.foo()

compiler/testData/diagnostics/tests/objects/ObjectsNested.fir.kt

@@ -26,4 +26,4 @@ val a = A
 val b = B
 val c = A.B
 val d = A.B.A
-val e = B.<!UNRESOLVED_REFERENCE!>A<!>.<!UNRESOLVED_REFERENCE!>B<!>
+val e = B.<!UNRESOLVED_REFERENCE!>A<!>.B

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!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::foo
-    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::foo
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo
-    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo
 
     // INVISIBLE: "cousin" supertypes themselves
-    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::foo
-    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::foo
-    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::foo
 
     // DEPRECATED: classifiers from "cousin" superclasses
-    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo
-    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::foo
-    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::foo
 
     // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
-    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo
-    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo
-    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo
 
     // DEPRECATED: Classifiers from supertypes of our own companion
-    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::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!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::foo
-    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::foo
 
     // DEPRECATED: Classifiers from companions of direct superclasses
-    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo
-    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo
 
     // INVISIBLE: "cousin" supertypes themselves
-    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::foo
-    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::foo
-    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::foo
 
     // DEPRECATED: classifiers from "cousin" superclasses
-    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo
-    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::foo
-    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::foo
 
     // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
-    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo
-    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo
-    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo
 
     // DEPRECATED: Classifiers from supertypes of our own companion
-    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::foo
 }

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

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

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.fir.kt

@@ -61,7 +61,7 @@ fun test() {
     takeNotNull(J.getNAny() ?: J())
 
     val x = <!UNRESOLVED_REFERENCE!>unresolved<!> ?: null
-    val y = <!UNRESOLVED_REFERENCE!>unresolved<!>.<!UNRESOLVED_REFERENCE!>foo<!> ?: return
+    val y = <!UNRESOLVED_REFERENCE!>unresolved<!>.foo ?: return
 }
 
 fun takeNotNull(s: J) {}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.fir.kt

@@ -19,5 +19,5 @@ class C(p: Any, val v: Any) {
 
     var test5
         get() { return <!UNRESOLVED_REFERENCE!>p<!> }
-        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.<!INAPPLICABLE_CANDIDATE!>let<!> {} }
+        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.let {} }
-}
+}

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!>sdf<!>()<!>()<!><out Any>::<!UNRESOLVED_REFERENCE!>unwrap<!>
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><<!UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::unwrap

compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.fir.kt

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun import() {
-    <!UNRESOLVED_REFERENCE!>import<!> <!UNRESOLVED_REFERENCE!>a<!><!SYNTAX!>.<!><!UNRESOLVED_REFERENCE!>*<!><!SYNTAX!><!>
+    <!UNRESOLVED_REFERENCE!>import<!> a<!SYNTAX!>.<!><!UNRESOLVED_REFERENCE!>*<!><!SYNTAX!><!>
 }
 
 fun composite() {
@@ -8,9 +8,9 @@ fun composite() {
 }
 
 fun html() {
-    <!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>/<!><!UNRESOLVED_REFERENCE!>html<!>><!SYNTAX!><!>
+    <!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>html<!>><!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>/<!><!UNRESOLVED_REFERENCE!>html<!>><!SYNTAX!><!>
 }
 
 fun html1() {
-    <!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>/<!><!UNRESOLVED_REFERENCE!>html<!>><!UNRESOLVED_REFERENCE!>html<!>
+    <!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>html<!>><!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>/<!><!UNRESOLVED_REFERENCE!>html<!>><!UNRESOLVED_REFERENCE!>html<!>
 }

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!>?<!>::<!UNRESOLVED_REFERENCE!>toString<!>
+    text.<!UNRESOLVED_REFERENCE!>map<!> Any<!SYNTAX!>?<!>::<!UNRESOLVED_REFERENCE!>toString<!>
 }

compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt

@@ -59,7 +59,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        (<!UNRESOLVED_REFERENCE!>b.<!UNRESOLVED_REFERENCE!>foo<!><!>)()
+        (b.<!UNRESOLVED_REFERENCE!>foo<!>)()
 
         foo(b)
         (foo)(b)

compiler/testData/diagnostics/tests/resolve/resolveTypeArgsForUnresolvedCall.fir.kt

@@ -1,4 +1,4 @@
 fun foo() {
-    <!UNRESOLVED_REFERENCE!>x<!>.<!UNRESOLVED_REFERENCE!>yyy<!><<!UNRESOLVED_REFERENCE!>XXX<!>>()
+    <!UNRESOLVED_REFERENCE!>x<!>.yyy<<!UNRESOLVED_REFERENCE!>XXX<!>>()
-    <!UNRESOLVED_REFERENCE!>x<!>.<!UNRESOLVED_REFERENCE!>yyy<!><Int>()
+    <!UNRESOLVED_REFERENCE!>x<!>.yyy<Int>()
-}
+}

compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt

@@ -22,9 +22,9 @@ public interface J {
 
 // FILE: 1.kt
 fun test(j: J) {
-    j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     j.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt

@@ -21,9 +21,9 @@ interface K {
 }
 
 fun test(k: K) {
-    k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     k.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt

@@ -28,7 +28,7 @@ open class A {
 class Simple: A() {
     init {
         Y().A_Y()
-        <!UNRESOLVED_REFERENCE!>Z<!>().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+        <!UNRESOLVED_REFERENCE!>Z<!>().A_C_Z()
     }
 }
 

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt

@@ -42,6 +42,6 @@ class Y: C() {
     init {
         Y().A_Y()
 
-        <!UNRESOLVED_REFERENCE!>Z<!>().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+        <!UNRESOLVED_REFERENCE!>Z<!>().A_C_Z()
     }
 }

compiler/testData/diagnostics/tests/scopes/kt900.fir.kt

@@ -5,11 +5,11 @@ package a
 
 fun foo() {
     val b : <!UNRESOLVED_REFERENCE!>B<!> = <!UNRESOLVED_REFERENCE!>B<!>() //only B() is unresolved, but in ": B" and "B.foo()" B should also be unresolved
-    <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!UNRESOLVED_REFERENCE!>B<!>.foo()
 
-    <!UNRESOLVED_REFERENCE!>P<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!UNRESOLVED_REFERENCE!>P<!>.foo()
 
-    <!UNRESOLVED_REFERENCE!>M<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>M<!>.bar()
 }
 
 class A() {

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.fir.kt

@@ -6,6 +6,6 @@ class Outer {
     }
 
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().<!UNRESOLVED_REFERENCE!>prop<!>) :
+    constructor(x: Int, y: Int, z: Int = x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop) :
-        this(x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().<!UNRESOLVED_REFERENCE!>prop<!>)
+        this(x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop)
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt

@@ -33,6 +33,6 @@ fun test() {
         x.baz(1).checkType { _<Unit>() }
         x.<!INAPPLICABLE_CANDIDATE!>baz<!>(1, 2)
 
-        x.<!UNRESOLVED_REFERENCE!>foobar<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.<!UNRESOLVED_REFERENCE!>foobar<!>().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     }
 }

compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.fir.kt

@@ -12,4 +12,4 @@ typealias CA = C
 val test1 = CA
 val test2 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>
 val test3 = CA.x
-val test4 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>.<!UNRESOLVED_REFERENCE!>x<!>
+val test4 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>.x

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

@@ -7,5 +7,5 @@ val <T : Any> KClass<T>.java: Class<T> get() = null!!
 
 val <T : Any> KClass<T>.javaObjectType: Class<T>
     get() {
-        return java.<!UNRESOLVED_REFERENCE!>lang<!>.<!UNRESOLVED_REFERENCE!>Class<!>::class.<!INAPPLICABLE_CANDIDATE!>java<!> as Class<T>
+        return java.<!UNRESOLVED_REFERENCE!>lang<!>.Class::class.<!INAPPLICABLE_CANDIDATE!>java<!> as Class<T>
     }

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<!>::<!UNRESOLVED_REFERENCE!>hashCode<!>
+        return java.<!UNRESOLVED_REFERENCE!>lang<!>.Integer::hashCode
     }

compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt

@@ -7,7 +7,7 @@ interface A : MutableCollection<String> {
 }
 
 fun foo(x: MutableCollection<Int>, y: Collection<String>, z: A) {
-    x.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>(1).<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    x.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>(1).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     y.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>("")
     z.nonExistingMethod("")
 }

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

@@ -13,9 +13,9 @@ class C {
     }
 }
 
-val c = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>Self<!>()
+val c = C.<!UNRESOLVED_REFERENCE!>Self<!>.Self()
-val n = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val n = C.<!UNRESOLVED_REFERENCE!>Self<!>.Nested()
-val x = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>X<!>
+val x = C.<!UNRESOLVED_REFERENCE!>Self<!>.X
-val n2 = C.Nested.<!UNRESOLVED_REFERENCE!>Root<!>.<!UNRESOLVED_REFERENCE!>Nested<!>.<!UNRESOLVED_REFERENCE!>N2<!>()
+val n2 = C.Nested.<!UNRESOLVED_REFERENCE!>Root<!>.Nested.N2()
-val ic = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>InCompanion<!>()
+val ic = C.<!UNRESOLVED_REFERENCE!>Self<!>.InCompanion()
-val ok = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>ok<!>
+val ok = C.<!UNRESOLVED_REFERENCE!>Self<!>.ok

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

@@ -53,7 +53,7 @@ fun foo(
     test.ClassAlias::func
 
     test.ClassSample.Nested::func
-    test.ClassAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::<!UNRESOLVED_REFERENCE!>func<!>
+    test.ClassAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
 
     test.ObjectSample::Nested
     test.ObjectAlias::Nested
@@ -62,7 +62,7 @@ fun foo(
     test.ObjectAlias::func
 
     test.ObjectSample.Nested::func
-    test.ObjectAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::<!UNRESOLVED_REFERENCE!>func<!>
+    test.ObjectAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
 
     test.EnumSample::Nested
     test.EnumAlias::Nested
@@ -71,5 +71,5 @@ fun foo(
     test.EnumAlias::func
 
     test.EnumSample.Nested::func
-    test.EnumAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::<!UNRESOLVED_REFERENCE!>func<!>
+    test.EnumAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
 }

compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/recursiveContractCustomContractFunction.fir.kt

@@ -32,7 +32,7 @@ fun case4() {
             run {
                 <!UNRESOLVED_REFERENCE!>s<!> = "hello"
             }
-            <!UNRESOLVED_REFERENCE!>s<!>.<!UNRESOLVED_REFERENCE!>length<!>
+            <!UNRESOLVED_REFERENCE!>s<!>.length
         }
     }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt

@@ -14,6 +14,6 @@ suspend fun fib(n: Long) =
     async {
         when {
             n < 2 -> n
-            else -> fib(n - 1).<!UNRESOLVED_REFERENCE!>await<!>() <!AMBIGUITY!>+<!> fib(n - 2).<!UNRESOLVED_REFERENCE!>await<!>()
+            else -> fib(n - 1).<!UNRESOLVED_REFERENCE!>await<!>() + fib(n - 2).<!UNRESOLVED_REFERENCE!>await<!>()
         }
     }

compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt

@@ -3,7 +3,7 @@ abstract class KFunctionKt9005WorkAround<out R: Any?>(private val _functionInsta
     private val _reflectedFunction: kotlin.reflect.KFunction<R> = _functionInstance.<!UNRESOLVED_REFERENCE!>reflect<!>() ?: throw IllegalStateException("")
 
     private val _parameters: List<kotlin.reflect.KParameter> = run {
-        _functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.<!AMBIGUITY!>map<!> {
+        _functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.map {
             <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : kotlin.reflect.KParameter {
                 override val index: Int = 0
             }

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.2.fir.kt

@@ -5,25 +5,25 @@ val value_1 = <!UNRESOLVED_REFERENCE!>E0<!>
 val value_2 = <!UNRESOLVED_REFERENCE!>e000<!>
 
 // TESTCASE NUMBER: 3
-val value_3 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>+<!>0
+val value_3 = <!UNRESOLVED_REFERENCE!>E<!>+0
 
 // TESTCASE NUMBER: 4
 val value_4 = <!UNRESOLVED_REFERENCE!>e00<!>
 
 // TESTCASE NUMBER: 5
-val value_5 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>+<!>1
+val value_5 = <!UNRESOLVED_REFERENCE!>e<!>+1
 
 // TESTCASE NUMBER: 6
 val value_6 = <!UNRESOLVED_REFERENCE!>e22<!>
 
 // TESTCASE NUMBER: 7
-val value_7 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>-<!>333
+val value_7 = <!UNRESOLVED_REFERENCE!>E<!>-333
 
 // TESTCASE NUMBER: 8
 val value_8 = <!UNRESOLVED_REFERENCE!>e4444<!>
 
 // TESTCASE NUMBER: 9
-val value_9 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>-<!>55555
+val value_9 = <!UNRESOLVED_REFERENCE!>e<!>-55555
 
 // TESTCASE NUMBER: 10
 val value_10 = <!UNRESOLVED_REFERENCE!>e666666<!>
@@ -32,7 +32,7 @@ val value_10 = <!UNRESOLVED_REFERENCE!>e666666<!>
 val value_11 = <!UNRESOLVED_REFERENCE!>E7777777<!>
 
 // TESTCASE NUMBER: 12
-val value_12 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>-<!>88888888
+val value_12 = <!UNRESOLVED_REFERENCE!>e<!>-88888888
 
 // TESTCASE NUMBER: 13
-val value_13 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>+<!>999999999
+val value_13 = <!UNRESOLVED_REFERENCE!>E<!>+999999999

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.3.fir.kt

@@ -5,25 +5,25 @@ val value_1 = <!UNRESOLVED_REFERENCE!>E0f<!>
 val value_2 = <!UNRESOLVED_REFERENCE!>e000F<!>
 
 // TESTCASE NUMBER: 3
-val value_3 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>+<!>0f
+val value_3 = <!UNRESOLVED_REFERENCE!>E<!>+0f
 
 // TESTCASE NUMBER: 4
 val value_4 = <!UNRESOLVED_REFERENCE!>e00f<!>
 
 // TESTCASE NUMBER: 5
-val value_5 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>+<!>1F
+val value_5 = <!UNRESOLVED_REFERENCE!>e<!>+1F
 
 // TESTCASE NUMBER: 6
 val value_6 = <!UNRESOLVED_REFERENCE!>e22F<!>
 
 // TESTCASE NUMBER: 7
-val value_7 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>-<!>333F
+val value_7 = <!UNRESOLVED_REFERENCE!>E<!>-333F
 
 // TESTCASE NUMBER: 8
 val value_8 = <!UNRESOLVED_REFERENCE!>e4444f<!>
 
 // TESTCASE NUMBER: 9
-val value_9 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>-<!>55555f
+val value_9 = <!UNRESOLVED_REFERENCE!>e<!>-55555f
 
 // TESTCASE NUMBER: 10
 val value_10 = <!UNRESOLVED_REFERENCE!>e666666F<!>
@@ -32,7 +32,7 @@ val value_10 = <!UNRESOLVED_REFERENCE!>e666666F<!>
 val value_11 = <!UNRESOLVED_REFERENCE!>E7777777f<!>
 
 // TESTCASE NUMBER: 12
-val value_12 = <!UNRESOLVED_REFERENCE!>e<!><!AMBIGUITY!>-<!>88888888F
+val value_12 = <!UNRESOLVED_REFERENCE!>e<!>-88888888F
 
 // TESTCASE NUMBER: 13
-val value_13 = <!UNRESOLVED_REFERENCE!>E<!><!AMBIGUITY!>+<!>999999999F
+val value_13 = <!UNRESOLVED_REFERENCE!>E<!>+999999999F

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt

@@ -191,7 +191,7 @@ fun case_13(x: <!UNRESOLVED_REFERENCE!>otherpackage.Case13?<!>) =
 class Case14 {
     val x: <!UNRESOLVED_REFERENCE!>otherpackage.Case14?<!>
     init {
-        x = <!UNRESOLVED_REFERENCE!>otherpackage<!>.<!UNRESOLVED_REFERENCE!>Case14<!>()
+        x = <!UNRESOLVED_REFERENCE!>otherpackage<!>.Case14()
     }
 }
 

idea/testData/checker/LocalObjects.fir.kt

@@ -0,0 +1,21 @@
+  object A {
+    val x : Int = 0
+  }
+
+  open class Foo {
+    fun foo() : Int = 1
+  }
+
+  fun test() {
+    A.x
+    val b = object : Foo() {
+    }
+    b.foo()
+
+    <error descr="[LOCAL_OBJECT_NOT_ALLOWED] Named object 'B' is a singleton and cannot be local. Try to use anonymous object instead">object B</error> {
+      fun foo() {}
+    }
+    B.foo()
+  }
+
+  val bb = <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: B">B</error>.foo()

idea/testData/checker/LocalObjects.kt

@@ -1,5 +1,3 @@
-// FIR_IDENTICAL
-// FIR_COMPARISON
   object A {
     val x : Int = 0
   }
@@ -20,4 +18,4 @@
     B.foo()
   }
 
-  val bb = <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: B">B</error>.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: foo">foo</error>()
+  val bb = <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: B">B</error>.<error descr="[DEBUG] Reference is not resolved to anything, but is not marked unresolved">foo</error>()

idea/testData/checker/NestedObjects.fir.kt

@@ -25,4 +25,4 @@ package nestedObjects
   val b = B
   val c = A.B
   val d = A.B.A
-  val e = B.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: A">A</error>.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: B">B</error>
+  val e = B.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: A">A</error>.B

idea/testData/checker/Unresolved.fir.kt

@@ -23,11 +23,11 @@ fun testUnresolved() {
         else -> <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: a">a</error>
     }
 
-    <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: hasNext"><error descr="[UNRESOLVED_REFERENCE] Unresolved reference: iterator"><error descr="[UNRESOLVED_REFERENCE] Unresolved reference: next">for (j in <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: collection">collection</error>) {
+    <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: hasNext"><error descr="[UNRESOLVED_REFERENCE] Unresolved reference: next">for (j in <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: collection">collection</error>) {
        var i: Int = j
        i += 1
        foo1(j)
-    }</error></error></error>
+    }</error></error>
 }
 
 fun foo1(i: Int) {}

idea/testData/checker/infos/SmartCasts.fir.kt

@@ -103,7 +103,7 @@ fun f13(a : A?) {
   }
   else {
     a?.foo()
-    <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: c">c</error>.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: bar">bar</error>()
+    <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: c">c</error>.bar()
   }
 
   a?.foo()