Remove OI/NI attributes from test data

2021-05-24 12:42:39 +03:00
parent 2ecba6ac39
commit ddbdfafa79
441 changed files with 1005 additions and 1037 deletions
@@ -7,5 +7,5 @@ fun test1(l: List<Number>) {

    val i: Int = l.firstTyped()

-    val s: String = <!TYPE_MISMATCH{NI}!>l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!><!TYPE_MISMATCH{NI}!>firstTyped<!>()<!><!>
+    val s: String = <!TYPE_MISMATCH!>l.<!TYPE_MISMATCH!>firstTyped<!>()<!>
 }
@@ -16,6 +16,6 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {}

 fun usage(x: CX, y: CY) {
    <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x, y) // expected err, got err
-    <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>fooA<!>(x, y) // expected err, got ok
-    <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>fooB<!>(x, y) // expected err, got ok
+    <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooA<!>(x, y) // expected err, got ok
+    <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooB<!>(x, y) // expected err, got ok
 }
@@ -2,7 +2,7 @@
 // ISSUE: KT-29307

 fun test_1(map: Map<String, String>) {
-    val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>map[<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!>]<!> // OK
+    val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!> // OK
 }

 open class A
@@ -10,7 +10,7 @@ open class A
 class B : A()

 fun test_2(map: Map<A, String>) {
-    val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>map[<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!>]<!>
+    val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!>
 }

 fun test_3(m: Map<*, String>) {
@@ -10,6 +10,6 @@ public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boole


 fun test() {
-    val a: Boolean = listOf(1).<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>""<!>)
+    val a: Boolean = listOf(1).contains1(<!TYPE_MISMATCH!>""<!>)
    val b: Boolean = listOf(1).contains1(1)
 }
@@ -10,23 +10,23 @@ fun <T> @kotlin.internal.NoInfer T.test2(t1: T): T = t1
 fun <T> test3(t1: @kotlin.internal.NoInfer T): T = t1

 fun usage() {
-    <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>test1<!>(1, <!TYPE_MISMATCH!>"312"<!>)
-    <!TYPE_MISMATCH{OI}!>1<!>.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>test2<!>("")
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>test3<!>("")
+    test1(1, <!TYPE_MISMATCH!>"312"<!>)
+    1.test2("")
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test3<!>("")
 }

@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 fun <T> List<T>.contains1(e: @kotlin.internal.NoInfer T): Boolean = true

 fun test(i: Int?, a: Any, l: List<Int>) {
-    l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>a<!>)
-    l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>""<!>)
-    l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>i<!>)
+    l.contains1(<!TYPE_MISMATCH!>a<!>)
+    l.contains1(<!TYPE_MISMATCH!>""<!>)
+    l.contains1(<!TYPE_MISMATCH!>i<!>)
 }

@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 fun <T> assertEquals1(e1: T, e2: @kotlin.internal.NoInfer T): Boolean = true

 fun test(s: String) {
-    <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>assertEquals1<!>(s, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)
+    assertEquals1(s, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)
 }
@@ -17,7 +17,7 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
 public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!

 fun test(map: Map<Int, String>) {
-    val a: Int = <!TYPE_MISMATCH{NI}!>listOf(1).<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>("")<!><!>
+    val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>("")<!><!>
    val b: Boolean = listOf(1).contains1(1)

    val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>get1<!>("")
@@ -20,12 +20,12 @@ fun test(
    invOut.onlyOut(42)
    invOut.onlyOut(1L)

-    invOut.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>onlyOutUB<!>(<!TYPE_MISMATCH{NI}!>"str"<!>)
-    invStar.<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>onlyOutUB<!>(0)
+    invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
+    invStar.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>onlyOutUB<!>(0)
    invOut.onlyOutUB(42)
    invOut.onlyOutUB(1L)

-    invIn.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>onlyIn<!>(<!TYPE_MISMATCH{NI}!>"str"<!>)
+    invIn.onlyIn(<!TYPE_MISMATCH!>"str"<!>)
    invIn.onlyIn(42)
    invIn.onlyIn(1L)
 }
@@ -65,7 +65,7 @@ class Test5 {
        set(value) {
            if (value != null) {
                val a = a
-                require(a != null && <!DEBUG_INFO_SMARTCAST!>value<!> in <!DEBUG_INFO_SMARTCAST{OI}!>a<!>.children)
+                require(a != null && <!DEBUG_INFO_SMARTCAST!>value<!> in a.children)
            }
            field = value
        }
@@ -16,7 +16,7 @@ class Out<out T>
 // -------------------------------------------------------

 fun test_0(x: Inv2<in Number, out Number>, list: List<Inv2<Any, Int>>) {
-    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>foo<!>(x)
+    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x)
 }

 // ------------------------- Inv -------------------------
@@ -34,11 +34,11 @@ fun test_3(x: Inv<Number>, list: List<Inv<Any>>) {
 }

 fun test_4(x: Inv<in Number>, list: List<Inv<Any>>) {
-    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>(x)
+    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
 }

 fun test_5(x: Inv<in Number>, list: List<Inv<Number>>) {
-    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>(x)
+    list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
 }

 fun test_6(x: Inv<in Number>, list: List<Inv<Int>>) {
@@ -5,7 +5,7 @@
 class Inv<T>
 class Out<out T>
 fun <T> foo(i: Inv<in T>, o: Out<T>) {
-    <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>bar<!>(i, o)
+    <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>bar<!>(i, o)
 }

 fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv<out K>, o: Out<K>): K = TODO()