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
@@ -12,12 +12,12 @@ typealias YBar = <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>
 typealias ZBar = <!RECURSIVE_TYPEALIAS_EXPANSION!>YBar<!>

 fun Foo.foo(body: Foo.() -> Unit) = body()
-fun Foo.zbar(body: <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>.() -> Unit) = Bar().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{OI}!>body<!>()
+fun Foo.zbar(body: <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>.() -> Unit) = Bar().body()

 fun test() {
    Foo().foo {
        zbar {
-            <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo<!> {}
+            <!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!> {}
        }
    }
 }
@@ -1,10 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-        
+
 fun Int.invoke(i: Int, a: Any) {}
 fun Int.invoke(a: Any, i: Int) {}

 fun foo(i: Int) {
-    <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>i<!>(1, 1)
+    <!NONE_APPLICABLE!>i<!>(1, 1)

-    <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>5<!>(1, 2)
+    <!NONE_APPLICABLE!>5<!>(1, 2)
 }
@@ -7,7 +7,7 @@ operator fun <T> T.invoke(a: A<T>) {}
 fun foo(s: String, ai: A<Int>) {
    1(ai)

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>s<!>(<!TYPE_MISMATCH{NI}!>ai<!>)
+    s(<!TYPE_MISMATCH!>ai<!>)

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>""<!>(<!TYPE_MISMATCH{NI}!>ai<!>)
+    ""(<!TYPE_MISMATCH!>ai<!>)
 }
@@ -5,5 +5,5 @@ operator fun String.invoke(i: Int) {}
 fun foo(s: String?) {
    <!UNSAFE_CALL!>s<!>(1)

-    <!UNSAFE_CALL{OI}, UNSAFE_IMPLICIT_INVOKE_CALL{NI}!>(s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)<!>(1)
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)<!>(1)
 }
@@ -1,16 +1,15 @@
-
 fun test1() {
-    <!TYPE_MISMATCH{OI}!>1<!>. <!FUNCTION_EXPECTED{NI}!>(fun String.(i: Int) = i )<!>(1)
-    <!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(label@ fun String.(i: Int) = i )<!>(1)
+    1. <!FUNCTION_EXPECTED!>(fun String.(i: Int) = i )<!>(1)
+    1.<!FUNCTION_EXPECTED!>(label@ fun String.(i: Int) = i )<!>(1)
 }

 fun test2(f: String.(Int) -> Unit) {
-    <!TYPE_MISMATCH{OI}!>11<!>.<!FUNCTION_EXPECTED{NI}!>(f)<!>(1)
-    <!TYPE_MISMATCH{OI}!>11<!>.<!FUNCTION_EXPECTED{NI}!>(f)<!>(<!NO_VALUE_FOR_PARAMETER{OI}!>)<!>
+    11.<!FUNCTION_EXPECTED!>(f)<!>(1)
+    11.<!FUNCTION_EXPECTED!>(f)<!>()
 }

 fun test3() {
    fun foo(): String.(Int) -> Unit = {}

-    <!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(foo())<!>(1)
+    1.<!FUNCTION_EXPECTED!>(foo())<!>(1)
 }
@@ -18,5 +18,5 @@ fun foo(): A.() -> Int {
    val b: Int = foo()(A())
    val c: Int = (foo())(A())

-    <!UNREACHABLE_CODE{OI}!>return<!> null!!
+    return null!!
 }
@@ -11,7 +11,7 @@ class Cls {

    fun test(s: String) {
        if (s.ext is B)
-            take(<!SMARTCAST_IMPOSSIBLE{OI}!>s.ext<!>)
+            take(s.ext)
    }
 }

@@ -4,7 +4,7 @@ fun foo(i: Int) = i
 fun foo(s: String) = s

 fun test() {
-    <!NONE_APPLICABLE!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>())
+    <!NONE_APPLICABLE!>foo<!>(emptyList())
 }

 fun <T> emptyList(): List<T> {throw Exception()}
@@ -10,7 +10,7 @@ public class ResolutionTaskHolder<F, G : F> {
        tasks.add(ResolutionTask<F, G>(candidate))

        //todo the problem is the type of ResolutionTask is inferred as ResolutionTask<F, F> too early
-        tasks.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(ResolutionTask(candidate))
+        tasks.bar(ResolutionTask(candidate))
        tasks.add(ResolutionTask(candidate))
    }
 }
@@ -99,10 +99,10 @@ fun testTwoLambdas() {
        {}
        <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!>

-        return if (true) <!TYPE_MISMATCH{NI}!>{
-            <!TYPE_MISMATCH{OI}!>twoLambdaArgs({})
+        return if (true) <!TYPE_MISMATCH!>{
+            twoLambdaArgs({})
            {}
-            <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!><!>
+            <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!>
        }<!> else {
            {}
        }
@@ -112,6 +112,6 @@ fun testTwoLambdas() {
 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
    return { l1 ->
        <!TYPE_MISMATCH, TYPE_MISMATCH!>l1()
-        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>l2<!>()<!> }<!><!>
+        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!CANNOT_INFER_PARAMETER_TYPE!>l2<!> -> <!DEBUG_INFO_MISSING_UNRESOLVED!>l2<!>() }<!><!>
    }
 }
@@ -6,4 +6,4 @@ object X2
 fun <T1> foo(x: T1, f: (T1) -> T1) = X1
 fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2

-val test: X2 = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!>({ 0 }, { <!CANNOT_INFER_PARAMETER_TYPE{OI}!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1 })
+val test: X2 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>({ 0 }, { it -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1 })
@@ -14,6 +14,6 @@ fun <E> baz(x: String, y: E) {}
 fun bar(x: A<String>) {
    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>("")

-    x.<!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>baz<!>("", "")
-    <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>baz<!>("", "")
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>baz<!>("", "")
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>baz<!>("", "")
 }
@@ -6,4 +6,4 @@ fun <T2 : Closeable, R2> T2.myUse(f: (T2) -> R2): R2 = f(this)

 fun test1(x: Closeable) = x.myUse { 42 }
 fun test2(x: Closeable) = x.myUse<Closeable, Int> { 42 }
-fun test3(x: Closeable) = x.myUse<<!UPPER_BOUND_VIOLATED{OI}!>AutoCloseable<!>, Int> { 42 } // TODO KT-10681
+fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681
@@ -11,5 +11,5 @@ fun <T> B<T>.foo(block: (T) -> Unit) {
 }

 fun main() {
-    B("string").<!OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!> {  }
+    B("string").<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {  }
 }
@@ -21,5 +21,5 @@ import a.*
 import b.*

 fun test() {
-    <!OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!><A> { }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!><A> { }
 }
@@ -19,5 +19,5 @@ import a.*
 import b.*

 fun main() {
-    <!OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!><String> {  }
+    foo<String> {  }
 }
@@ -6,4 +6,4 @@ class A<T>
 <!CONFLICTING_OVERLOADS!>fun <T1> A<T1>.foo()<!> = X1
 <!CONFLICTING_OVERLOADS!>fun <T2> A<out T2>.foo()<!> = X2

-fun <T> A<out T>.test() = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!>() // TODO fix constraint system
+fun <T> A<out T>.test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>() // TODO fix constraint system
@@ -1,13 +1,13 @@
 // !DIAGNOSTICS: -USELESS_ELVIS

 fun test() {
-    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
+    bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
+        1
    } else {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
+        2
    }<!>)

-    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }

 fun bar(s: String) = s
@@ -13,7 +13,7 @@ fun testElvis(a: Int?, b: Int?) {
    if (a != null) {
        doInt(b ?: <!DEBUG_INFO_SMARTCAST!>a<!>)
    }
-    doList(getList() ?: <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyListOfA<!>()) //should be an error
+    doList(getList() ?: emptyListOfA()) //should be an error
    doList(getList() ?: strangeList { doInt(it) }) //lambda was not analyzed
 }

@@ -32,5 +32,5 @@ fun testDataFlowInfo2(a: Int?, b: Int?) {
 }

 fun testTypeMismatch(a: String?, b: Any) {
-    doInt(<!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>a<!> ?: <!TYPE_MISMATCH{OI}!>b<!><!>)
+    doInt(<!TYPE_MISMATCH!>a ?: b<!>)
 }
@@ -12,8 +12,8 @@ fun <T: A> emptyNullableListOfA(): List<T>? = null
 //-------------------------------

 fun testExclExcl() {
-    doList(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyNullableListOfA<!>()!!) //should be an error here
-    val l: List<Int> = <!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{NI}!>id<!>(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}, TYPE_MISMATCH{NI}!>emptyNullableListOfA<!>()<!TYPE_MISMATCH{NI}!>!!<!>)<!>
+    doList(emptyNullableListOfA()!!) //should be an error here
+    val l: List<Int> = <!TYPE_MISMATCH!><!TYPE_MISMATCH!>id<!>(<!TYPE_MISMATCH!>emptyNullableListOfA<!>()<!TYPE_MISMATCH!>!!<!>)<!>

    doList(strangeNullableList { doInt(it) }!!) //lambda should be analyzed (at completion phase)
 }
@@ -8,7 +8,7 @@ interface D: A, B
 interface E: A, B

 fun foo(c: C?, d: D?, e: E?) {
-    val test1: A? = <!TYPE_MISMATCH{OI}!>c ?: d<!> ?: e
+    val test1: A? = c ?: d ?: e

    val test2: B? = if (false) if (true) c else d else e

@@ -3,25 +3,25 @@ package b
 fun bar(i: Int) = i

 fun test(a: Int?, b: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else <!TYPE_MISMATCH{OI}!>b<!><!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) return else b<!>)
 }

 fun test(a: Int?, b: Int?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else if (b == null) return else <!TYPE_MISMATCH{OI}!>c<!><!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) return else if (b == null) return else c<!>)
 }

 fun test(a: Any?, b: Any?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) if (b == null) <!TYPE_MISMATCH{OI}!>c<!> else return else return<!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) if (b == null) c else return else return<!>)
 }

 fun test(a: Int?, b: Any?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) {
+    bar(<!TYPE_MISMATCH!>if (a == null) {
        return
    } else {
        if (b == null) {
            return
        } else {
-            <!TYPE_MISMATCH{OI}!>c<!>
+            c
        }
    }<!>)
 }
@@ -3,12 +3,12 @@
 fun <T> foo(t: T) = t

 fun test1() {
-    foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int, String><!>(<!TYPE_MISMATCH{OI}!>""<!>)
+    foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int, String><!>("")
 }


 fun <T, R> bar(t: T, r: R) {}

 fun test2() {
-    bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>(<!TYPE_MISMATCH{OI}!>""<!>, "")
+    bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>("", "")
 }