[FIR] Fix invalid diagnostic fir node sites and improved invalid type parameters count diagnostic report

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

@@ -30,17 +30,17 @@ class MyColor(val x: <!UNRESOLVED_REFERENCE!>Color.RED<!>, y: <!UNRESOLVED_REFER
     }
 }
 
-fun create(): <!UNRESOLVED_REFERENCE!>Array<Color.RED>?<!> = null
+fun create(): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>? = null
 
 interface Your<T : <!UNRESOLVED_REFERENCE!>Color.RED<!>>
 
-class His : <!UNRESOLVED_REFERENCE!>Your<Color.RED><!>
+class His : Your<<!UNRESOLVED_REFERENCE!>Color.RED<!>>
 
 fun <T : <!UNRESOLVED_REFERENCE!>Color.RED<!>> otherCreate(): Array<T>? = null
 
 typealias RedAlias = <!UNRESOLVED_REFERENCE!>Color.RED<!>
 
-typealias ArrayOfEnumEntry = <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>
+typealias ArrayOfEnumEntry = Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>
 
 typealias ArrayOfEnumEntryAlias = Array<RedAlias>
 
@@ -52,4 +52,4 @@ fun <T> foo() {
     <!INAPPLICABLE_CANDIDATE!>bar<!><<!UNRESOLVED_REFERENCE!>Color.RED<!>>(Color.RED)
 }
 
-fun <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>.foo(entries: <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>): <!UNRESOLVED_REFERENCE!>Array<Color.RED><!> = null!!
+fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!

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

@@ -3,8 +3,8 @@ package unresolved
 class Pair<A, B>(val a: A, val b: B)
 
 fun testGenericArgumentsCount() {
-    val p1: Pair<Int> = Pair(2, 2)
-    val p2: Pair = Pair(2, 2)
+    val p1: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<Int><!> = Pair(2, 2)
+    val p2: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<!> = Pair(2, 2)
 }
 
 fun testUnresolved() {

compiler/testData/diagnostics/tests/cast/bare/ErrorsInSubstitution.fir.kt

@@ -3,7 +3,7 @@
 interface B<T>
 interface G<T>: B<T>
 
-fun f(p: <!UNRESOLVED_REFERENCE!>B<Foo><!>): Any {
+fun f(p: B<<!UNRESOLVED_REFERENCE!>Foo<!>>): Any {
     val v = p as G
     return checkSubtype<G<*>>(v)
 }

compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt

@@ -4,4 +4,4 @@
 interface Tr
 interface G<T>
 
-fun test(tr: Tr) = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G>(tr)
+fun test(tr: Tr) = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(tr)

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

@@ -1,9 +0,0 @@
-// !LANGUAGE: +BareArrayClassLiteral
-
-val a01 = Array::class
-val a02 = Array<Array>::class
-val a03 = Array<Any?>::class
-val a04 = Array<Array<Any?>?>::class
-val a05 = Array<IntArray?>::class
-val a06 = kotlin.Array::class
-val a07 = kotlin.Array<IntArray?>::class

compiler/testData/diagnostics/tests/classLiteral/arrays.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +BareArrayClassLiteral
 
 val a01 = Array::class

compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt

@@ -1,7 +1,7 @@
 package p
 
 public fun foo(a: Any) {
-    a is Map<Int>
+    a is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!>
     a is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>
     a is Map<out Any?, Any?>
     a is Map<*, *>

compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt

@@ -1,6 +1,6 @@
-public fun foo(a: Any, b: Map) {
+public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
     when (a) {
-        is Map<Int> -> {}
+        is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!> -> {}
         is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!> -> {}
         is Map<out Any?, Any?> -> {}
         is Map<*, *> -> {}

compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.fir.kt

@@ -55,7 +55,7 @@ object MessageManager10 : <!UNRESOLVED_REFERENCE!>Message5<Int><!>() {
     fun <T : Int> execute() {}
 }
 
-class MessageManager11<A> : <!UNRESOLVED_REFERENCE!>Message5<Message5<A>><!>() {
+class MessageManager11<A> : <!UNRESOLVED_REFERENCE!>Message5<<!UNRESOLVED_REFERENCE!>Message5<A><!>><!>() {
     fun <T : <!UNRESOLVED_REFERENCE!>Message5<A><!>> execute() {}
 }
 

compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt

@@ -23,13 +23,13 @@ fun test() {
     Foo<String>.Bar.Baz::class
 
     a<Foo<String>.Bar>()
-    a<Foo<String>.Bar.Baz>()
+    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar.Baz<!>>()
 
     a<Foo.Bar<Int>>()
-    a<Foo.Bar<Int>.Baz>()
+    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo.Bar<Int>.Baz<!>>()
 }
 
-fun <T: <!UNRESOLVED_REFERENCE!>Foo<String.Bar><!>> x() {}
+fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
 fun Foo<String>.Bar.ext() {}
 
 fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {

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

@@ -15,6 +15,6 @@ class Outer<E> {
 fun bare(x: Outer<*>.Inner<*, *>.Inner2Base, y: Outer<*>.Inner<*, *>.Inner3Base<Int>) {
     if (x is Outer.Inner.Inner2) return
     if (y is Outer.Inner.Inner3) return
-    if (y is Outer<String>.Inner.Inner3) return
-    if (y is Outer.Inner<String, Int>.Inner3<Double>) return
+    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<String>.Inner.Inner3<!>) return
+    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<String, Int>.Inner3<Double><!>) return
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt

@@ -10,7 +10,7 @@ private fun <E> foobar() = {
             fun a() = A<E, X, Y, Z>()
         }
 
-        typealias LocalAlias<W> = <!UNRESOLVED_REFERENCE!>A<E, X, Y, W><!>
+        typealias LocalAlias<W> = A<<!UNRESOLVED_REFERENCE!>E<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
     }
 
     class Derived : LocalOuter<Double, Short>() {
@@ -27,7 +27,7 @@ private fun noParameters() = {
             fun a() = A<Any, X, Y, Z>()
         }
 
-        typealias LocalAlias2<W> = <!UNRESOLVED_REFERENCE!>A<Any, X, Y, W><!>
+        typealias LocalAlias2<W> = A<<!UNRESOLVED_REFERENCE!>Any<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
     }
 
     class Derived2 : LocalOuter2<Double, Short>() {

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt

@@ -12,7 +12,7 @@ class Outer<T> {
                     fun a() = A<T, F, E, X, Y, Z>()
                 }
 
-                typealias LocalAlias<W> = <!UNRESOLVED_REFERENCE!>A<T, F, E, X, Y, W><!>
+                typealias LocalAlias<W> = A<<!UNRESOLVED_REFERENCE!>T<!>, <!UNRESOLVED_REFERENCE!>F<!>, <!UNRESOLVED_REFERENCE!>E<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
             }
 
             class Derived : LocalOuter<Double, Short>() {
@@ -29,7 +29,7 @@ class Outer<T> {
                     fun a() = A<T, F, Any, X, Y, Z>()
                 }
 
-                typealias LocalAlias2<W> = <!UNRESOLVED_REFERENCE!>A<T, F, Any, X, Y, W><!>
+                typealias LocalAlias2<W> = A<<!UNRESOLVED_REFERENCE!>T<!>, <!UNRESOLVED_REFERENCE!>F<!>, <!UNRESOLVED_REFERENCE!>Any<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
             }
 
             class Derived2 : LocalOuter2<Double, Short>() {

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

@@ -17,4 +17,4 @@ class Outer<E> {
 
 class E
 
-fun bar(x: Inner) {}
+fun bar(x: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inner<!>) {}

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: C<Int>? = null
-        val d: D? = null
+        val c: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>C<Int>?<!> = null
+        val d: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>D?<!> = null
 
-        val innerMost: Innermost<String>? = null
+        val innerMost: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Innermost<String>?<!> = null
     }
 }

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

@@ -4,7 +4,7 @@
 
 class Outer<T> {
     inner class Inner
-    fun foo(x: Outer<String>.Inner, y: Outer.Inner, z: Inner) {
+    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<!>, z: Inner) {
         var inner = Inner()
         x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
         x.checkType { _<Outer<String>.Inner>() }

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

@@ -42,7 +42,7 @@ fun errorTypeWithArguments(): <!UNRESOLVED_REFERENCE!>Q<A>.W<B, C, D>.R.M<!> = n
 
 fun error1(): Outer<A>.Inner<B>.Inner3<C, D> = null!!
 fun error2(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Inner<B, C, D>.Inner2<!> = null!!
-fun error3(): Outer.Inner<A, B>.Inner3<C> = null!!
+fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<A, B>.Inner3<C><!> = null!!
 
 fun error4(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Nested<B>.Inner4<C><!> = null!!
 fun error5(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Obj.Nested2<B>.Inner5<C><!> = null!!

compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.fir.kt

@@ -1,19 +1,19 @@
 class A
-interface I0<T : A<Int>>
-interface I1<T> where T : A<Int>
-interface I2<T : A<Int>> where T : A<Int>
+interface I0<T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>>
+interface I1<T> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
+interface I2<T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
 
-fun <E : A<Int>> foo0() {}
-fun <E> foo1() where E : A<Int> {}
-fun <E : A<Int>> foo2() where E : A<Int> {}
+fun <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> foo0() {}
+fun <E> foo1() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
+fun <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> foo2() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
 
-val <E : A<Int>> E.p1: Int
+val <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> E.p1: Int
         get() = 1
-val <E> E.p2: Int where E : A<Int>
+val <E> E.p2: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
         get() = 1
-val <E : A<Int>> E.p3: Int where E : A<Int>
+val <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> E.p3: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
         get() = 1
 
 // See KT-8200
 interface X
-public class EnumAttribute<T : X<T>>(val klass: Class<T>) where T : Enum<T>
+public class EnumAttribute<T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>X<T><!>>(val klass: Class<T>) where T : Enum<T>

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

@@ -19,7 +19,7 @@ fun test1() {
     }
 }
 
-fun test2(l: <!UNRESOLVED_REFERENCE!>List<AA><!>) {
+fun test2(l: List<<!UNRESOLVED_REFERENCE!>AA<!>>) {
     l.<!UNRESOLVED_REFERENCE!>map<!> {
         <!UNRESOLVED_REFERENCE!>it<!>!!
     }

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

@@ -8,14 +8,14 @@ fun <T> consume(x: Foo<out T>, y: Foo<out T>) {}
 fun <T> materialize() = null as T
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>consume<!>(
-        materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>(),
-        materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>()
+    consume(
+        materialize<Foo<Bar<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>>(),
+        materialize<Foo<Bar<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>>()
     )
 
     <!INAPPLICABLE_CANDIDATE!>consume<!>(
-        materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>(),
-        materialize<<!UNRESOLVED_REFERENCE!>Foo<ErrorType><!>>()
+        materialize<Foo<Bar<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>>(),
+        materialize<Foo<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>()
     )
 
 }

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

@@ -3,11 +3,11 @@ interface P<U, Y>
 class A<T> {
     class B {
         fun test() {
-            class C<W>() : <!UNRESOLVED_REFERENCE!>P<W, T><!> {
-                companion object : <!UNRESOLVED_REFERENCE!>P<W, T><!> {
+            class C<W>() : P<W, <!UNRESOLVED_REFERENCE!>T<!>> {
+                companion object : P<W, <!UNRESOLVED_REFERENCE!>T<!>> {
                 }
 
-                inner class D : <!UNRESOLVED_REFERENCE!>P<W, T><!>
+                inner class D : P<W, <!UNRESOLVED_REFERENCE!>T<!>>
             }
         }
     }

compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt

@@ -6,7 +6,7 @@ package p
 
 public class A<X, Y>
 public class M1 {
-    public val a: A<Int> = A<Int, Int>()
+    public val a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> = A<Int, Int>()
 }
 
 // MODULE: m2
@@ -16,7 +16,7 @@ package p
 
 public class A<X, Y>
 
-public fun foo(a: A<Int>) {
+public fun foo(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>) {
 }
 
 // MODULE: m3(m1, m2)

compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnErrorType.fir.kt

@@ -3,5 +3,5 @@ interface G<T> {
     val bar: Int
 }
 
-fun G.foo() {}
-val G.bar: Int get() = 42
+fun <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>.foo() {}
+val <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>.bar: Int get() = 42

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

@@ -1,3 +1,3 @@
 class B {}
 
-val b : B<*> = 1
+val b : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>B<*><!> = 1

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

@@ -1,3 +1,3 @@
-class Class1<T : <!UNRESOLVED_REFERENCE!>Class2<Class1<X>><!>>
+class Class1<T : Class2<Class1<<!UNRESOLVED_REFERENCE!>X<!>>>>
 
-class Class2<T : <!UNRESOLVED_REFERENCE!>Class1<Class2<X>><!>>
+class Class2<T : Class1<Class2<<!UNRESOLVED_REFERENCE!>X<!>>>>

compiler/testData/diagnostics/tests/scopes/classHeader/classParents.fir.kt

@@ -2,7 +2,7 @@
 
 interface I<F, G, H>
 
-class A(impl: Interface) : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by impl, <!UNRESOLVED_REFERENCE!>Inner<!>, <!UNRESOLVED_REFERENCE!>I<Nested, Interface, Inner><!> {
+class A(impl: Interface) : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by impl, <!UNRESOLVED_REFERENCE!>Inner<!>, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>, <!UNRESOLVED_REFERENCE!>Inner<!>> {
 
     class Nested
 

compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.fir.kt

@@ -3,7 +3,7 @@ interface I<F, G>
 val aImpl: A.Interface
     get() = null!!
 
-object A : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by aImpl, <!UNRESOLVED_REFERENCE!>I<Nested, Interface><!> {
+object A : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
 
     class Nested
 

compiler/testData/diagnostics/tests/subtyping/kt304.fir.kt

@@ -1,6 +1,6 @@
 //KT-304: Resolve supertype reference to class anyway
 
-open class Foo() : Bar() {
+open class Foo() : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Bar<!>() {
 }
 
 open class Bar<T>() {

compiler/testData/diagnostics/tests/thisAndSuper/Super.fir.kt

@@ -50,7 +50,7 @@ class CG : G<Int> {
     fun test() {
         super<G>.foo() // OK
         super<G<Int>>.foo() // Warning
-        super<G<E>>.<!UNRESOLVED_REFERENCE!>foo<!>() // Error
+        super<G<E>>.foo() // Error
         super<G<String>>.foo() // Error
     }
 }

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

@@ -17,13 +17,13 @@ class Outer<TO> {
 
 fun <TF> foo() {
     class Local<TL> {
-        typealias LTF = <!UNRESOLVED_REFERENCE!>List<TF><!>
-        typealias LTL = <!UNRESOLVED_REFERENCE!>List<TL><!>
+        typealias LTF = <!UNRESOLVED_REFERENCE!>List<<!UNRESOLVED_REFERENCE!>TF<!>><!>
+        typealias LTL = <!UNRESOLVED_REFERENCE!>List<<!UNRESOLVED_REFERENCE!>TL<!>><!>
     }
 
     fun <TLF> localfun() =
             object {
-                typealias LTF = <!UNRESOLVED_REFERENCE!>List<TF><!>
-                typealias LTLF = <!UNRESOLVED_REFERENCE!>List<TLF><!>
+                typealias LTF = List<<!UNRESOLVED_REFERENCE!>TF<!>>
+                typealias LTLF = List<<!UNRESOLVED_REFERENCE!>TLF<!>>
             }
 }

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

@@ -38,9 +38,9 @@ val testNested2: <!UNRESOLVED_REFERENCE!>KT.Nested<!> = KT.<!UNRESOLVED_REFERENC
 val testNested3: <!UNRESOLVED_REFERENCE!>IT.Nested<!> = IT.<!UNRESOLVED_REFERENCE!>Nested<!>()
 val testInner1: <!UNRESOLVED_REFERENCE!>JT.Inner<!> = JT.<!UNRESOLVED_REFERENCE!>Inner<!>()
 val testInner2: <!UNRESOLVED_REFERENCE!>KT.Inner<!> = KT.<!UNRESOLVED_REFERENCE!>Inner<!>()
-fun testNestedAsTypeArgument1(x: <!UNRESOLVED_REFERENCE!>List<JT.Nested><!>) {}
-fun testNestedAsTypeArgument2(x: <!UNRESOLVED_REFERENCE!>List<KT.Nested><!>) {}
-fun testNestedAsTypeArgument3(x: <!UNRESOLVED_REFERENCE!>List<IT.Nested><!>) {}
-fun testInnerAsTypeArgument1(x: <!UNRESOLVED_REFERENCE!>List<JT.Inner><!>) {}
-fun testInnerAsTypeArgument2(x: <!UNRESOLVED_REFERENCE!>List<KT.Inner><!>) {}
+fun testNestedAsTypeArgument1(x: List<<!UNRESOLVED_REFERENCE!>JT.Nested<!>>) {}
+fun testNestedAsTypeArgument2(x: List<<!UNRESOLVED_REFERENCE!>KT.Nested<!>>) {}
+fun testNestedAsTypeArgument3(x: List<<!UNRESOLVED_REFERENCE!>IT.Nested<!>>) {}
+fun testInnerAsTypeArgument1(x: List<<!UNRESOLVED_REFERENCE!>JT.Inner<!>>) {}
+fun testInnerAsTypeArgument2(x: List<<!UNRESOLVED_REFERENCE!>KT.Inner<!>>) {}
 

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

@@ -2,6 +2,6 @@
 
 fun outer() {
     typealias Test1 = <!UNRESOLVED_REFERENCE!>Test1<!>
-    typealias Test2 = <!UNRESOLVED_REFERENCE!>List<Test2><!>
-    typealias Test3<T> = <!UNRESOLVED_REFERENCE!>List<Test3<T>><!>
+    typealias Test2 = List<<!UNRESOLVED_REFERENCE!>Test2<!>>
+    typealias Test3<T> = List<<!UNRESOLVED_REFERENCE!>Test3<<!UNRESOLVED_REFERENCE!>T<!>><!>>
 }

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

@@ -41,10 +41,10 @@ interface Test<in I, out O, P> {
     fun neOk11(i: Inv<in I>)
     fun neOk12(i: Inv<out O>)
 
-    fun neOk30(i: Pair<O, >)
-    fun neOk31(i: Pair<O, Inv>)
-    fun neOk32(i: Inv)
+    fun neOk30(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<O, ><!>)
+    fun neOk31(i: Pair<O, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>)
+    fun neOk32(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>)
     fun neOk33(i: Inv<<!SYNTAX!><!>>)
-    fun neOk34(i: <!UNRESOLVED_REFERENCE!>Inv<C><!>)
+    fun neOk34(i: Inv<<!UNRESOLVED_REFERENCE!>C<!>>)
     fun neOk35(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>)
 }

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: Pair<I, >
-    var neOk31: Pair<I, Inv>
-    var neOk32: Inv
+    var neOk30: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    var neOk31: Pair<I, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
+    var neOk32: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
     var neOk33: Inv<<!SYNTAX!><!>>
-    var neOk34: <!UNRESOLVED_REFERENCE!>Inv<C><!>
+    var neOk34: Inv<<!UNRESOLVED_REFERENCE!>C<!>>
     var neOk35: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
 }

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

@@ -33,10 +33,10 @@ interface Test<in I, out O, P> {
     fun neOk10(): Inv<in O>
     fun neOk11(): Inv<out I>
 
-    fun neOk30(): Pair<I, >
-    fun neOk31(): Pair<I, Inv>
-    fun neOk32(): Inv
+    fun neOk30(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    fun neOk31(): Pair<I, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
+    fun neOk32(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
     fun neOk33(): Inv<<!SYNTAX!><!>>
-    fun neOk34(): <!UNRESOLVED_REFERENCE!>Inv<C><!>
+    fun neOk34(): Inv<<!UNRESOLVED_REFERENCE!>C<!>>
     fun neOk35(): <!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 v1: FilteringSequence
+    val v1: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>FilteringSequence<!>
     val <!EXPOSED_PROPERTY_TYPE!>v2<!>: IndexingSequence<String>
 }

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

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