[FIR] Don't report duplicated errors on default accessor error type refs

compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt

@@ -1,7 +1,7 @@
 package rest
 
 abstract class Foo<T> {
-    abstract val x: <!TYPE_ARGUMENTS_NOT_ALLOWED, TYPE_ARGUMENTS_NOT_ALLOWED!>T<Int><!>
+    abstract val x: <!TYPE_ARGUMENTS_NOT_ALLOWED!>T<Int><!>
 
     abstract fun foo(): <!TYPE_ARGUMENTS_NOT_ALLOWED!>T<String><!>
 }

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

@@ -9,9 +9,9 @@ abstract class My<T : Some> {
 
     abstract fun foo(arg: T)
 
-    abstract val y: <!OTHER_ERROR, OTHER_ERROR!>My.T<!>
+    abstract val y: <!OTHER_ERROR!>My.T<!>
 
-    abstract val z: <!OTHER_ERROR, OTHER_ERROR!>test.My.T<!>
+    abstract val z: <!OTHER_ERROR!>test.My.T<!>
 
     class Some : <!UNRESOLVED_REFERENCE!>T<!>()
 }

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory0
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
+import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.diagnostics.*
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind.*
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
@@ -30,6 +31,10 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
     }
 
     override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: CheckerContext) {
+        if (data.containingDeclarations.lastOrNull() is FirDefaultPropertyAccessor) {
+            // It always uses the same type ref as the corresponding property
+            return
+        }
         val source = errorTypeRef.source ?: return
         runCheck { reportFirDiagnostic(errorTypeRef.diagnostic, source, it) }
     }

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

@@ -7,9 +7,9 @@ enum class Color {
     }
 }
 
-class MyColor(val x: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>, y: <!OTHER_ERROR!>Color.RED<!>) : <!OTHER_ERROR!>Color.RED<!> {
+class MyColor(val x: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>, y: <!OTHER_ERROR!>Color.RED<!>) : <!OTHER_ERROR!>Color.RED<!> {
 
-    var z: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!> = Color.RED
+    var z: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!> = Color.RED
     set(arg: Color.RED) { z = arg }
 
     fun foo(arg: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>): <!OTHER_ERROR!>Color.RED<!> = arg

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

@@ -6,14 +6,14 @@ package foobar.a
     import java.*
 
     val a : java.util.List<Int>? = null
-    val a2 : <!OTHER_ERROR, OTHER_ERROR!>util.List<Int>?<!> = null
+    val a2 : <!OTHER_ERROR!>util.List<Int>?<!> = null
-    val a3 : <!OTHER_ERROR, OTHER_ERROR!>LinkedList<Int>?<!> = null
+    val a3 : <!OTHER_ERROR!>LinkedList<Int>?<!> = null
 
 // FILE: b.kt
 package foobar
 
 abstract class Foo<T>() {
-    abstract val x : <!TYPE_ARGUMENTS_NOT_ALLOWED, TYPE_ARGUMENTS_NOT_ALLOWED!>T<Int><!>
+    abstract val x : <!TYPE_ARGUMENTS_NOT_ALLOWED!>T<Int><!>
 }
 
 // FILE: b.kt
@@ -21,7 +21,7 @@ package foobar.a
     import java.util.*
 
     val b : List<Int>? = a
-    val b1 : <!OTHER_ERROR, OTHER_ERROR!>util.List<Int>?<!> = a
+    val b1 : <!OTHER_ERROR!>util.List<Int>?<!> = a
 
 // FILE: b.kt
 package foobar

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: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.<!UNRESOLVED_REFERENCE!>VALUE<!>
+        val error: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.<!UNRESOLVED_REFERENCE!>VALUE<!>
 )
 
 

compiler/testData/diagnostics/tests/dataClasses/errorTypesInDataClasses.fir.kt

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
-data class A(val i: Int, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
+data class A(val i: Int, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
-data class B(val i: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
+data class B(val i: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
 
 
 fun fa(a: A) {

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/withErrorTypes.fir.kt

@@ -1,4 +1,4 @@
 interface T {
-    val x: <!OTHER_ERROR, OTHER_ERROR!>ErrorType<!>
+    val x: <!OTHER_ERROR!>ErrorType<!>
     fun getX(): <!OTHER_ERROR!>ErrorType1<!>
 }

compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt

@@ -12,10 +12,10 @@ inline class ULong(private val l: Long)
 
 // FILE: test.kt
 
-annotation class AnnoUB(val ub0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UByte<!>, val ub1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UByte<!>)
+annotation class AnnoUB(val ub0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UByte<!>, val ub1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UByte<!>)
-annotation class AnnoUS(val us0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UShort<!>, val us1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UShort<!>)
+annotation class AnnoUS(val us0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UShort<!>, val us1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UShort<!>)
-annotation class AnnoUI(val ui0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui2: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui3: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>)
+annotation class AnnoUI(val ui0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui2: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>, val ui3: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt<!>)
-annotation class AnnoUL(val ul0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>ULong<!>, val ul1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>ULong<!>)
+annotation class AnnoUL(val ul0: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>ULong<!>, val ul1: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>ULong<!>)
 
 const val ub0 = <!UNRESOLVED_REFERENCE!>UByte<!>(1)
 const val us0 = <!UNRESOLVED_REFERENCE!>UShort<!>(2)
@@ -37,8 +37,8 @@ fun f2() {}
 @AnnoUL(ul0, <!UNRESOLVED_REFERENCE!>ULong<!>(5))
 fun f3() {}
 
-const val explicit: <!OTHER_ERROR, OTHER_ERROR!>UInt<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(2)
+const val explicit: <!OTHER_ERROR!>UInt<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(2)
 
-const val nullable: <!OTHER_ERROR, OTHER_ERROR!>UInt?<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(3)
+const val nullable: <!OTHER_ERROR!>UInt?<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(3)
 
-annotation class NullableAnno(val u: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt?<!>)
+annotation class NullableAnno(val u: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>UInt?<!>)

compiler/testData/diagnostics/tests/generics/innerClasses/outerArgumentsRequired.fir.kt

@@ -15,9 +15,9 @@ class A<T> {
         val y: B<String>.C<String>? = null
         val z: B<String>.D? = null
 
-        val c: <!OTHER_ERROR, OTHER_ERROR!>C<Int>?<!> = null
+        val c: <!OTHER_ERROR!>C<Int>?<!> = null
-        val d: <!OTHER_ERROR, OTHER_ERROR!>D?<!> = null
+        val d: <!OTHER_ERROR!>D?<!> = null
 
-        val innerMost: <!OTHER_ERROR, OTHER_ERROR!>Innermost<String>?<!> = null
+        val innerMost: <!OTHER_ERROR!>Innermost<String>?<!> = null
     }
 }

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

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

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

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

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

@@ -9,19 +9,19 @@ interface B {
 }
 
 class X: A {
-    val a: <!OTHER_ERROR, OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
+    val a: <!OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
     val b: A.A_ = A.A_()
 
     companion object {
-        val a: <!OTHER_ERROR, OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
+        val a: <!OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
     }
 }
 
 class Y: B {
-    val a: <!OTHER_ERROR, OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
+    val a: <!OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
     val b: B.B_ = B.B_()
 
     companion object {
-        val b: <!OTHER_ERROR, OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
+        val b: <!OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
     }
 }

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

@@ -7,14 +7,14 @@ open class A {
 }
 
 class C: A() {
-    val b: <!OTHER_ERROR, OTHER_ERROR!>B<!> = null!!
+    val b: <!OTHER_ERROR!>B<!> = null!!
 
     init {
         <!UNRESOLVED_REFERENCE!>B<!>()
     }
 
     object O {
-        val b: <!OTHER_ERROR, OTHER_ERROR!>B<!> = null!!
+        val b: <!OTHER_ERROR!>B<!> = null!!
 
         init {
             <!UNRESOLVED_REFERENCE!>B<!>()
@@ -22,7 +22,7 @@ class C: A() {
     }
 
     class K {
-        val b: <!OTHER_ERROR, OTHER_ERROR!>B<!> = null!!
+        val b: <!OTHER_ERROR!>B<!> = null!!
 
         init {
             <!UNRESOLVED_REFERENCE!>B<!>()
@@ -30,7 +30,7 @@ class C: A() {
     }
 
     inner class I {
-        val b: <!OTHER_ERROR, OTHER_ERROR!>B<!> = null!!
+        val b: <!OTHER_ERROR!>B<!> = null!!
 
         init {
             <!UNRESOLVED_REFERENCE!>B<!>()

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

@@ -23,7 +23,7 @@ public class C extends B implements A {
 // FILE: 1.kt
 
 class X: A {
-    val a_s: <!OTHER_ERROR, OTHER_ERROR!>A_S<!> = null!!
+    val a_s: <!OTHER_ERROR!>A_S<!> = null!!
 
     init {
         <!UNRESOLVED_REFERENCE!>A_S<!>()
@@ -32,7 +32,7 @@ class X: A {
     }
 
     object xD {
-        val a_: <!OTHER_ERROR, OTHER_ERROR!>A_S<!> = null!!
+        val a_: <!OTHER_ERROR!>A_S<!> = null!!
 
         init {
             <!UNRESOLVED_REFERENCE!>A_S<!>()
@@ -66,7 +66,7 @@ class Y: B() {
 }
 
 class Z: C() {
-    val a_s: <!OTHER_ERROR, OTHER_ERROR!>A_S<!> = null!!
+    val a_s: <!OTHER_ERROR!>A_S<!> = null!!
     val b_: B_ = null!!
     val b_s: B_S = null!!
 
@@ -77,7 +77,7 @@ class Z: C() {
     }
 
     object X {
-        val a_s: <!OTHER_ERROR, OTHER_ERROR!>A_S<!> = null!!
+        val a_s: <!OTHER_ERROR!>A_S<!> = null!!
         val b_: B_ = null!!
         val b_s: B_S = null!!
 

compiler/testData/diagnostics/tests/typealias/inheritedNestedTypeAlias.kt

@@ -16,6 +16,6 @@ class Derived : Base<Int>() {
     val x1: InnerCell = InnerCell(42)
     val x2: Base<Int>.InnerCell = InnerCell(42)
 
-    val test1: <!OTHER_ERROR, OTHER_ERROR!>CT<!> = Cell(42)
+    val test1: <!OTHER_ERROR!>CT<!> = Cell(42)
     val test2: Base<Int>.CT = Cell(42)
 }

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

@@ -33,11 +33,11 @@ val seeAlsoDerivedFoo: String = JDerived.foo()
 
 // Referencing nested classes via type alias should be prohibited
 // (in type position and in expression position)
-val testNested1: <!OTHER_ERROR, OTHER_ERROR!>JT.Nested<!> = JT.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val testNested1: <!OTHER_ERROR!>JT.Nested<!> = JT.<!UNRESOLVED_REFERENCE!>Nested<!>()
-val testNested2: <!OTHER_ERROR, OTHER_ERROR!>KT.Nested<!> = KT.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val testNested2: <!OTHER_ERROR!>KT.Nested<!> = KT.<!UNRESOLVED_REFERENCE!>Nested<!>()
-val testNested3: <!OTHER_ERROR, OTHER_ERROR!>IT.Nested<!> = IT.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val testNested3: <!OTHER_ERROR!>IT.Nested<!> = IT.<!UNRESOLVED_REFERENCE!>Nested<!>()
-val testInner1: <!OTHER_ERROR, OTHER_ERROR!>JT.Inner<!> = JT.<!UNRESOLVED_REFERENCE!>Inner<!>()
+val testInner1: <!OTHER_ERROR!>JT.Inner<!> = JT.<!UNRESOLVED_REFERENCE!>Inner<!>()
-val testInner2: <!OTHER_ERROR, OTHER_ERROR!>KT.Inner<!> = KT.<!UNRESOLVED_REFERENCE!>Inner<!>()
+val testInner2: <!OTHER_ERROR!>KT.Inner<!> = KT.<!UNRESOLVED_REFERENCE!>Inner<!>()
 fun testNestedAsTypeArgument1(x: <!OTHER_ERROR!>List<JT.Nested><!>) {}
 fun testNestedAsTypeArgument2(x: <!OTHER_ERROR!>List<KT.Nested><!>) {}
 fun testNestedAsTypeArgument3(x: <!OTHER_ERROR!>List<IT.Nested><!>) {}

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

@@ -4,7 +4,7 @@ class Cell<TC>(val x: TC)
 
 fun <T> id(x: T): T {
     typealias C = Cell<T>
-    class Local(val cell: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>C<!>)
+    class Local(val cell: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>C<!>)
     val cx = <!UNRESOLVED_REFERENCE!>C<!>(x)
     val c: <!OTHER_ERROR, OTHER_ERROR!>C<!> = Local(cx).cell
     return c.<!UNRESOLVED_REFERENCE!>x<!>

compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt

@@ -38,10 +38,10 @@ interface Test<in I, out O, P> {
     var neOk22: Inv<out O>
     var neOk23: Inv<out I>
 
-    var neOk30: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Pair<I, ><!>
+    var neOk30: <!OTHER_ERROR, OTHER_ERROR!>Pair<I, ><!>
-    var neOk31: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Pair<I, Inv><!>
+    var neOk31: <!OTHER_ERROR, OTHER_ERROR!>Pair<I, Inv><!>
-    var neOk32: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Inv<!>
+    var neOk32: <!OTHER_ERROR, OTHER_ERROR!>Inv<!>
     var neOk33: Inv<<!SYNTAX!><!>>
-    var neOk34: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Inv<C><!>
+    var neOk34: <!OTHER_ERROR, OTHER_ERROR!>Inv<C><!>
-    var neOk35: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS, WRONG_NUMBER_OF_TYPE_ARGUMENTS, WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
+    var neOk35: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS, WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
 }

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

@@ -10,6 +10,6 @@ package kotlin.sequences
 import p.*
 
 interface I {
-    val <!EXPOSED_PROPERTY_TYPE!>v1<!>: <!OTHER_ERROR, OTHER_ERROR!>FilteringSequence<!>
+    val <!EXPOSED_PROPERTY_TYPE!>v1<!>: <!OTHER_ERROR!>FilteringSequence<!>
     val <!EXPOSED_PROPERTY_TYPE!>v2<!>: IndexingSequence<String>
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/callableReferenceOnUnresolvedLHS.fir.kt

@@ -3,7 +3,7 @@
 interface Inv
 class Impl : Inv
 
-class Scope<InterfaceT, ImplementationT : InterfaceT>(private val implClass: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>j.Class<ImplementationT><!>) {
+class Scope<InterfaceT, ImplementationT : InterfaceT>(private val implClass: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>j.Class<ImplementationT><!>) {
     fun foo(c: Collection<InterfaceT>) {
         val hm = c.asSequence()
             .<!INAPPLICABLE_CANDIDATE!>filter<!>(<!UNRESOLVED_REFERENCE!>implClass::isInstance<!>)

compiler/testData/diagnostics/testsWithStdLib/regression/kt37727.fir.kt

@@ -1,4 +1,4 @@
-data class A(val x: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Set<CLassNotFound><!> = setOf()) {
+data class A(val x: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Set<CLassNotFound><!> = setOf()) {
     fun with(x: <!OTHER_ERROR, OTHER_ERROR!>Set<CLassNotFound>?<!> = null) {
         A(x ?: this.x)
     }