[TD] Update test data after previous commit

2020-12-15 12:58:53 +03:00
parent 49d9b85950
commit e1802fde29
306 changed files with 599 additions and 599 deletions
@@ -22,7 +22,7 @@ class B : A() {
    }

    fun g() {
-        super.<!ABSTRACT_SUPER_CALL!>f<!>()
+        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
        super.t()

        super.x
@@ -32,7 +32,7 @@ class B : A() {

 abstract class J : A() {
    fun r() {
-        super.<!ABSTRACT_SUPER_CALL!>f<!>()
+        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
        super.t()

        super.x
@@ -13,5 +13,5 @@ open class B {
 class A : IWithToString, B() {
    override fun toString(): String = super.toString() // resolve to Any.toString
    override fun foo(): String = super.foo() // resolve to B.foo()
-    override fun bar(): String = super.<!ABSTRACT_SUPER_CALL!>bar<!>() // should be an error
+    override fun bar(): String = super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>bar<!>()<!> // should be an error
 }
@@ -28,4 +28,4 @@ class Class {
    )<!>
 )
@Ann3(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arr<!>)
-fun test() {}
+fun test() {}
@@ -8,4 +8,4 @@ val foo = TestEnum.Foo
 var bar = TestEnum.Foo

@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST!>foo<!>, <!ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST!>bar<!>)
-fun test() {}
+fun test() {}
@@ -21,4 +21,4 @@ fun bar() = Foo::class
        <!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>bar()<!>
    ]
 )
-fun test1() {}
+fun test1() {}
@@ -1,7 +1,7 @@
 annotation class A() {
-    <!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: Nothing?)<!> {}<!>
+    <!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(s: Nothing?)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}<!>
    <!ANNOTATION_CLASS_MEMBER!>init {}<!>
    <!ANNOTATION_CLASS_MEMBER!>fun foo() {}<!>
    <!ANNOTATION_CLASS_MEMBER!>val bar: Nothing?<!>
    <!ANNOTATION_CLASS_MEMBER!>val baz get() = Unit<!>
-}
+}
@@ -14,4 +14,4 @@ fun A.test_2() {
    object : B by b {}
 }

-class D(val x: String, val y: String = <!NO_THIS!>this<!>.<!UNRESOLVED_REFERENCE!>x<!>) {}
+class D(val x: String, val y: String = <!NO_THIS!>this<!>.<!UNRESOLVED_REFERENCE!>x<!>) {}
@@ -2,4 +2,4 @@ class A

 interface C

-enum class B : C, <!CLASS_IN_SUPERTYPE_FOR_ENUM!>A<!>(), Any()
+enum class B : C, <!CLASS_IN_SUPERTYPE_FOR_ENUM!>A<!>(), Any()
@@ -49,7 +49,7 @@ fun lol(a: Array<Boolean>) {}
 <!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!>

 class M {
-    companion <!REDECLARATION!>object<!> {}
+    <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {}<!>
    <!REDECLARATION!>val Companion = object : Any {}<!>
 }

@@ -65,4 +65,4 @@ class mest

 fun() {}

-private fun() {}
+private fun() {}
@@ -1,7 +1,7 @@
-interface <!CONSTRUCTOR_IN_INTERFACE!>A(val s: String)<!>
+<!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>A(val s: String)<!><!>

-interface <!CONSTRUCTOR_IN_INTERFACE!>B constructor(val s: String)<!>
+<!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>B constructor(val s: String)<!><!>

 interface C {
-    <!CONSTRUCTOR_IN_INTERFACE!>constructor(val s: String)<!> {}
-}
+    <!CONSTRUCTOR_IN_INTERFACE{LT}!><!CONSTRUCTOR_IN_INTERFACE{PSI}!>constructor(val s: String)<!> {}<!>
+}
@@ -2,14 +2,14 @@ class B
 class C

 class A() {
-    constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>("test") {}
-    constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(10) {}
+    constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>("test")<!> {}
+    constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(10)<!> {}

-    constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>('\n') {}
-    constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(0.0) {}
-    constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(false) {}
+    constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>('\n')<!> {}
+    constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(0.0)<!> {}
+    constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(false)<!> {}

-    constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3.14159265) {}
+    constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3.14159265)<!> {}

    constructor(c: C) : this() {}
    constructor(a: List<Int>) : this(C()) {}
@@ -17,7 +17,7 @@ class A() {

 class D {
    constructor(i: Boolean) {}
-    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {}
+    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
 }

 class E<T> {
@@ -25,7 +25,7 @@ class E<T> {
    // selection of the proper constructor
    // but a type mismatch for the first
    // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {}
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!> {}
 }

 class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
    // selection of the proper constructor
    // but a type mismatch for the first
    // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10)
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!>
 }

 class J<T> {
@@ -42,20 +42,20 @@ class J<T> {
 }

 class F(s: String) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(i: Boolean)<!> {}
-    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {}
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(i: Boolean)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
+    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
 }

 class G(x: Int) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!> {}
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
 }

 class H(x: Int) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!>
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
 }

 class K(x: Int) {
-    constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>() {}
+    constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>()<!> {}
 }

 class M {
@@ -63,5 +63,5 @@ class M {
 }

 class U : M {
-    <!INAPPLICABLE_CANDIDATE!>constructor()<!>
+    <!INAPPLICABLE_CANDIDATE{PSI}!>constructor()<!><!INAPPLICABLE_CANDIDATE{LT}!><!>
 }
@@ -6,4 +6,4 @@ interface B : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by a {

 val test = A()

-interface C : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by test
+interface C : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by test
@@ -1,6 +1,6 @@
 enum class A {
    A(1), B(2), C("test");

-    constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>()
+    constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{LT}!><!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{PSI}!>super<!>()<!>
    constructor(t: String) : this(10)
-}
+}
@@ -3,16 +3,16 @@ class A(x: Int) {
 }

 class B : A {
-    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
    constructor(z: String) : this()
 }

 <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class C : A(20) {
-    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
    constructor(z: String) : this()
 }<!>

 class D() : A(20) {
-    <!NONE_APPLICABLE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!>
+    <!NONE_APPLICABLE{PSI}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(x: Int)<!><!NONE_APPLICABLE{LT}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
    constructor(z: String) : this()
-}
+}
@@ -35,4 +35,4 @@ fun rest() {
    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit var i: Int<!>
    lateinit var a: A
    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit var b: B<String> = B()<!>
-}
+}
@@ -28,4 +28,4 @@ private abstract class M : K()
 class X {
    <!INCOMPATIBLE_MODIFIERS!>inner<!> <!INCOMPATIBLE_MODIFIERS!>data<!> class Y(val i: Int)
    <!INCOMPATIBLE_MODIFIERS!>sealed<!> <!INCOMPATIBLE_MODIFIERS!>inner<!> class Z
-}
+}
@@ -1,5 +1,5 @@
 class A {
-    constructor(x: Int = <!UNRESOLVED_REFERENCE!>getSomeInt<!>(), other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
+    constructor(x: Int = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSomeInt<!>()<!>, other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
    fun getSomeInt() = 10
    var keker = "test"
 }
@@ -7,10 +7,10 @@ class A {
 class B(other: B = <!NO_THIS!>this<!>)

 class C() {
-    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({
+    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>({
        val a = 10
        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
-    }) {}
+    })<!> {}
 }

 class D {
@@ -5,4 +5,4 @@ interface B : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A
 interface C
 class D

-interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A<!>(), C, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>()
+interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A<!>(), C, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>()
@@ -2,7 +2,7 @@ fun foo() {
    <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Ann<!>

    @Ann class Local {
-        // There should also be NESTED_CLASS_NOT_ALLOWED report here.
-        <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Nested<!>
+        <!LOCAL_ANNOTATION_CLASS_ERROR{LT}!>// There should also be NESTED_CLASS_NOT_ALLOWED report here.
+        <!LOCAL_ANNOTATION_CLASS_ERROR{PSI}!>annotation class Nested<!><!>
    }
 }
@@ -6,19 +6,19 @@ object A {
    interface X

    val a = object : Any() {
-        <!LOCAL_OBJECT_NOT_ALLOWED!>object D<!> {
+        <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object D<!> {
            <!LOCAL_OBJECT_NOT_ALLOWED!>object G<!>
            <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Z<!>
-        }
+        }<!>

        <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Y<!>
    }

    fun b() {
-        <!LOCAL_OBJECT_NOT_ALLOWED!>object E<!> {
+        <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object E<!> {
            <!LOCAL_OBJECT_NOT_ALLOWED!>object F<!>
            <!LOCAL_INTERFACE_NOT_ALLOWED!>interface M<!>
-        }
+        }<!>

        <!LOCAL_INTERFACE_NOT_ALLOWED!>interface N<!>

@@ -28,4 +28,4 @@ object A {
            <!LOCAL_INTERFACE_NOT_ALLOWED!>interface U<!>
        }
    }
-}
+}
@@ -1,11 +1,11 @@
 class A {
-    companion <!REDECLARATION!>object<!> {
+    <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {

-    }
+    }<!>

-    companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {
+    <!MANY_COMPANION_OBJECTS{LT}, REDECLARATION{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}, REDECLARATION{PSI}!>object<!> {

-    }
+    }<!>
 }

 class B {
@@ -13,7 +13,7 @@ class B {

    }

-    companion <!MANY_COMPANION_OBJECTS!>object B<!> {
+    <!MANY_COMPANION_OBJECTS{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}!>object B<!> {

-    }
-}
+    }<!>
+}
@@ -22,4 +22,4 @@ interface D {
    override operator fun toString(): String
    override operator fun equals(other: Any?): Boolean
    override operator fun hashCode(): Int
-}
+}
@@ -10,4 +10,4 @@ const val cnst = 2
        <!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>foo + cnst.toString()<!>
    )<!>
 )
-fun test() {}
+fun test() {}
@@ -4,7 +4,7 @@ class A {

 class B : A {
    fun g() {
-        <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE!>f<!>()
+        <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>f<!>()<!>
        super<A>.f()
    }
-}
+}
@@ -6,4 +6,4 @@ data class A {}

 <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data class C {
    constructor(x: Int)
-}<!>
+}<!>
@@ -26,7 +26,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
    override var rest: E = balue
 }

-class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
    override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
 }

@@ -31,4 +31,4 @@ class Test2 : IDerived<String>, AliasedIBase {
        super<IDerived>.bar()
        super<IDerived>.qux()
    }
-}
+}
@@ -1,2 +1,2 @@
 <!REDUNDANT_MODIFIER!>open<!> abstract class A
-<!REDUNDANT_MODIFIER!>abstract<!> sealed class B
+<!REDUNDANT_MODIFIER!>abstract<!> sealed class B
@@ -14,4 +14,4 @@ enum <!REPEATED_MODIFIER!>enum<!> class C {

 open class E(private <!REPEATED_MODIFIER!>private<!> val int: Int = 5) {
    protected <!REPEATED_MODIFIER!>protected<!> var double = int + 8.0
-}
+}
@@ -27,7 +27,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
    override fun rest(): E = balue
 }

-class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
    override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
 }

@@ -66,4 +66,4 @@ open class GoodDerrived : Base<Y, W>() {

 open class BadDerrived : Base<Y, W>() {
    override fun kek(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>String<!> = "test"
-}
+}
@@ -1,3 +1,3 @@
 sealed class A

-val b = <!SEALED_CLASS_CONSTRUCTOR_CALL!>A<!>()
+val b = <!SEALED_CLASS_CONSTRUCTOR_CALL{LT}!><!SEALED_CLASS_CONSTRUCTOR_CALL{PSI}!>A<!>()<!>
@@ -28,13 +28,13 @@ sealed class P {

 class K : P()

-<!REDECLARATION!>object B<!> {
+<!REDECLARATION{LT}!><!REDECLARATION{PSI}!>object B<!> {
    class I : <!SEALED_SUPERTYPE!>P<!>()
-}
+}<!>

 fun test() {
    class L : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>()
    val a = object : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>() {

    }
-}
+}
@@ -9,4 +9,4 @@ class C(a: A) : B(a) {
        // Should be resolved to delegated B.foo (no error)
        super.foo()
    }
-}
+}
@@ -4,7 +4,7 @@ class B: A() {
    fun act() {
        <!SUPER_IS_NOT_AN_EXPRESSION!>super<!>()

-        <!UNRESOLVED_REFERENCE!>invoke<!>()
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!>

        <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
            println(<!ILLEGAL_CONST_EXPRESSION!>'weird'<!>)
@@ -1,20 +1,20 @@
 fun String.f() {
-    <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+    <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
 }

 fun foo() {
    <!SUPER_NOT_AVAILABLE!>super<!>
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
-    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
 }

 class A {
    fun act() {
-        <!UNRESOLVED_REFERENCE!>println<!>("Test")
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!>
    }

    fun String.fact() {
-        <!UNRESOLVED_REFERENCE!>println<!>("Fest")
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Fest")<!>
    }
-}
+}
@@ -6,4 +6,4 @@ interface ATrait : <!INTERFACE_WITH_SUPERCLASS!>A<!> {
    override fun foo() {
        <!SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE!>super<A><!>.foo()
    }
-}
+}
@@ -10,4 +10,4 @@ interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A

 interface F : A, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>B<!>(), <!INTERFACE_WITH_SUPERCLASS!>C<!>, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>(), <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>Any<!>() {

-}
+}
@@ -8,4 +8,4 @@ class F() : C(10)

 <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class G : C(10) {
    constructor() : super(1)
-}<!>
+}<!>
@@ -19,4 +19,4 @@ package simulation
 )
 class KotlinImporterComponent {
    class State(var directories: List<String> = ArrayList())
-}
+}
@@ -17,11 +17,11 @@ object Best {

 }

-val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
-val b = Best.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
+val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>
+val b = Best.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>

 class B<E>
-class C<F<!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!> <!SYNTAX!>:<!> <!SYNTAX!>B<!><!SYNTAX!><<!><!SYNTAX!>F<!><!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!><!SYNTAX!>(<!><!SYNTAX!>)<!>
+class C<F<!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!> <!SYNTAX{PSI}!>:<!> <!SYNTAX{PSI}!>B<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>F<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>(<!><!SYNTAX{PSI}!>)<!>

 fun <G> gest() {}

@@ -31,4 +31,4 @@ fun <T> fest() {
    gest<T>()
    val c: List<List<List<<!TYPE_ARGUMENTS_NOT_ALLOWED!>T<String><!>>>>
    gest<List<List<<!TYPE_ARGUMENTS_NOT_ALLOWED!>T<Boolean><!>>>>()
-}
+}
@@ -20,4 +20,4 @@ annotation class Ann2(
    val p4: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Array<Int>?<!>,
    val p5: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Ann1?<!>,
    val p6: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Enum?<!>
-)
+)
@@ -1,3 +1,3 @@
 enum class A<<!TYPE_PARAMETERS_IN_ENUM!>B<!>, C : B, D>

-enum class B
+enum class B
@@ -1,15 +1,15 @@
-<!TYPE_PARAMETERS_IN_OBJECT!>object A<!><T, K : T> {
-    <!TYPE_PARAMETERS_IN_OBJECT!>object B<!><L>
-}
+<!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object A<!><T, K : T> {
+    <!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object B<!><L><!>
+}<!>

 class N {
-    companion <!TYPE_PARAMETERS_IN_OBJECT!>object<!><T> {
+    <!TYPE_PARAMETERS_IN_OBJECT{LT}!>companion <!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object<!><T> {

-    }
+    }<!>
 }

 fun test() {
-    <!LOCAL_OBJECT_NOT_ALLOWED, TYPE_PARAMETERS_IN_OBJECT!>object M<!><H> {
+    <!LOCAL_OBJECT_NOT_ALLOWED{LT}, TYPE_PARAMETERS_IN_OBJECT{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}, TYPE_PARAMETERS_IN_OBJECT{PSI}!>object M<!><H> {

-    }
-}
+    }<!>
+}
@@ -45,4 +45,4 @@ val test8 = NL<String>()

 class NumberPhile<T: Number>(x: T)
 val np1 = NumberPhile(10)
-val np2 = <!INAPPLICABLE_CANDIDATE!>NumberPhile<!>("Test")
+val np2 = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>NumberPhile<!>("Test")<!>
@@ -1,4 +1,4 @@
 annotation class A(
-    <!VAR_ANNOTATION_PARAMETER!>var<!> a: Int,
+    <!VAR_ANNOTATION_PARAMETER{LT}!><!VAR_ANNOTATION_PARAMETER{PSI}!>var<!> a: Int<!>,
    <!MISSING_VAL_ON_ANNOTATION_PARAMETER!>b: String<!>
-)
+)