[TD] Update diagnostics test data due to new test runners

Update includes: - Changing syntax of `OI/`NI` tags from `<!NI;TAG!>` to `<!TAG{NI}!>` - Fix some incorrect directives - Change order of diagnostics in some places - Remove ignored diagnostics from FIR test data (previously `DIAGNOSTICS` didn't work) - Update FIR dumps in some places and add `FIR_IDENTICAL` if needed - Replace all JAVAC_SKIP with SKIP_JAVAC directive
2020-12-07 10:08:56 +03:00
parent 1d04fecd29
commit e6b5cb5216
1823 changed files with 3014 additions and 2662 deletions
@@ -3,4 +3,4 @@ import java.util.ArrayList

 <!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(1, 1)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
+<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 import java.util.ArrayList

-<!NI;NOT_AN_ANNOTATION_CLASS!>@<!OI;NONE_APPLICABLE!>ArrayList<!><Int>(<!NI;TOO_MANY_ARGUMENTS!>1<!>, <!NI;TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
+<!NOT_AN_ANNOTATION_CLASS{NI}!>@<!NONE_APPLICABLE{OI}!>ArrayList<!><Int>(<!TOO_MANY_ARGUMENTS{NI}!>1<!>, <!TOO_MANY_ARGUMENTS{NI}!>1<!>)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
+<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
@@ -7,4 +7,4 @@ class TopLevelClass<<!UNSUPPORTED!>@A1<!> <!UNSUPPORTED!>@A2(3)<!> <!UNSUPPORTED
            class InFun<<!UNSUPPORTED!>@A1<!> <!UNSUPPORTED!>@A2(3)<!> <!UNSUPPORTED!>@A2<!> <!UNSUPPORTED!>@A1(12)<!> <!UNSUPPORTED!>@A2("Test")<!> T>
        }
    }
-}
+}
@@ -9,4 +9,4 @@ class SomeClass {
    fun foo() {
        fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> innerFun() = 12
    }
-}
+}
@@ -11,4 +11,4 @@ class SomeClass {
    fun foo() {
        val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><<!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>(3)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!>(12)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>("Test")<!> T><!> <!UNUSED_VARIABLE!>localVal<!> = 12
    }
-}
+}
@@ -19,4 +19,4 @@ class C {
@Ann0
@Ann @Ann3
@Ann2(1)
-@Ann4<!SYNTAX!><!>
+@Ann4<!SYNTAX!><!>
@@ -19,4 +19,4 @@ class C {
@<!UNRESOLVED_REFERENCE!>Ann0<!>
@Ann @<!UNRESOLVED_REFERENCE!>Ann3<!>
@Ann2(<!TOO_MANY_ARGUMENTS!>1<!>)
-@<!UNRESOLVED_REFERENCE!>Ann4<!SYNTAX!><!><!>
+@<!UNRESOLVED_REFERENCE!>Ann4<!><!SYNTAX!><!>
@@ -1,2 +1,2 @@
 // Class constructor parameter CAN be recursively annotated
-class RecursivelyAnnotated(<!NOT_AN_ANNOTATION_CLASS!>@RecursivelyAnnotated(1)<!> val x: Int)
+class RecursivelyAnnotated(<!NOT_AN_ANNOTATION_CLASS!>@RecursivelyAnnotated(1)<!> val x: Int)
@@ -5,4 +5,4 @@ object SomeObject

 val some = SomeObject

-annotation class BadAnnotation(val s: String)
+annotation class BadAnnotation(val s: String)
@@ -12,4 +12,4 @@ enum class MyEnum {
 }

@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, TYPE_MISMATCH!>Test()<!>)
-class Test2
+class Test2
@@ -12,4 +12,4 @@ enum class MyEnum {
 }

@AnnE(<!TYPE_MISMATCH!>Test()<!>)
-class Test2
+class Test2
@@ -4,7 +4,7 @@

 fun f1(x: String) {}
 fun f2(f: () -> Unit) {}
-fun test1() = f2(<!TYPE_MISMATCH("() -> Unit", "KFunction1<String, Unit>")!>::f1<!>)
+fun test1() = f2(<!TYPE_MISMATCH("() -> Unit; KFunction1<String, Unit>")!>::f1<!>)


@Target(AnnotationTarget.TYPE_PARAMETER,  AnnotationTarget.TYPE)
@@ -13,14 +13,14 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!

 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!NI;TYPE_MISMATCH("Any", "Int"), NI;TYPE_MISMATCH("Any", "Int")!>a<!>)
+    val r: Array<in Int?> = <!OI{OI}, TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!TYPE_MISMATCH("Any; Int"), TYPE_MISMATCH("Any; Int")!>a<!>)
 }


 var test3: Int = 0
-    set(s: <!WRONG_SETTER_PARAMETER_TYPE("Int", "String")!>@Ann String<!>) {}
+    set(s: <!WRONG_SETTER_PARAMETER_TYPE("Int; String")!>@Ann String<!>) {}


 fun f4(fn: (@Ann Int, @Ann Int) -> Unit) {}

-val test4 = f4 <!NI;TYPE_MISMATCH("(Int, Int) -> Unit", "(Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2", "Int, Int")!>single<!> -> }<!>
+val test4 = f4 <!NI{OI}, TYPE_MISMATCH("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>
@@ -7,4 +7,4 @@ var bar : Int = 1
 val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}

 class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
-}
+}
@@ -37,4 +37,4 @@ fun foo(arg: Int) {
    bar(@FunAnn ::gav)
    // Function expression, ok
    fast(f)
-}
+}
@@ -34,7 +34,7 @@ fun foo(arg: Int) {
    val f = @FunAnn fun(): Int { return 42 }
    // But here, f and gav should be annotated instead
    bar(<!WRONG_ANNOTATION_TARGET!>@FunAnn<!> f)
-    bar(<!OI;WRONG_ANNOTATION_TARGET!>@<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>FunAnn<!><!> ::gav)
+    bar(<!WRONG_ANNOTATION_TARGET{OI}!>@<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>FunAnn<!><!> ::gav)
    // Function expression, ok
    fast(f)
-}
+}
@@ -28,7 +28,7 @@ abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: I
    fun foo() {}

    <!WRONG_ANNOTATION_TARGET!>@Field<!>
-    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>lazy<!> { 42 }
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>lazy<!> { 42 }
 }

 enum class Your {
@@ -7,9 +7,9 @@ annotation class A
@A
 open class B1 {
    @A
-    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>open<!> fun foo() {}
+    private open fun foo() {}
 }

 class D1 : B1() {
    override fun foo() {}
-}
+}
@@ -11,5 +11,5 @@ open class B1 {
 }

 class D1 : B1() {
-    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER("public open fun foo(): Unit defined in D1", "private open fun foo(): Unit defined in B1")!>override<!> fun foo() {}
-}
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER("public open fun foo(): Unit defined in D1; private open fun foo(): Unit defined in B1")!>override<!> fun foo() {}
+}
@@ -15,4 +15,4 @@ interface B {
    fun foo(@An b : @An Int)
 }

-interface C : A, B
+interface C : A, B
@@ -15,4 +15,4 @@ interface B {
    fun foo(@An b : @An Int)
 }

-<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES("public abstract fun foo(a: Int): Unit defined in A, public abstract fun foo(b: Int): Unit defined in B", "1")!>interface C<!> : A, B
+<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES("public abstract fun foo(a: Int): Unit defined in A, public abstract fun foo(b: Int): Unit defined in B; 1")!>interface C<!> : A, B
@@ -13,4 +13,4 @@ class C<T> {

 fun test(a: C<out CharSequence>) {
    <!INAPPLICABLE_CANDIDATE!>a[1] = 25<!>
-}
+}
@@ -12,5 +12,5 @@ class C<T> {
 }

 fun test(a: C<out CharSequence>) {
-    <!OI;MEMBER_PROJECTED_OUT("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>")!>a[1]<!> = <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH("integer", "Nothing")!>25<!>
-}
+    <!MEMBER_PROJECTED_OUT{OI}("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>"), OI{OI}!>a[1]<!> = <!CONSTANT_EXPECTED_TYPE_MISMATCH("integer; Nothing"), NI{OI}!>25<!>
+}
@@ -45,4 +45,4 @@ interface GI : G {
 }

 class AG1(val a: A, val g: G) : A by a, G by g
-class AG2() : AI, GI
+class AG2() : AI, GI
@@ -15,7 +15,7 @@ interface B {
    fun <T> a(@An arg: @An Int)
 }

-<!CONFLICTING_INHERITED_MEMBERS("C", "public abstract fun a(arg: Int): Unit defined in A, public abstract fun <T> a(arg: Int): Unit defined in B")!>interface C<!> : A, B
+<!CONFLICTING_INHERITED_MEMBERS("C; public abstract fun a(arg: Int): Unit defined in A, public abstract fun <T> a(arg: Int): Unit defined in B")!>interface C<!> : A, B

@An
 abstract class D {
@@ -23,8 +23,8 @@ abstract class D {
    abstract val d: @An Int
 }

-<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED("Class 'E'", "public abstract val d: Int defined in D")!>class E<!> : D(), A
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED("Class 'F'", "public abstract fun a(arg: Int): Unit defined in A")!>class F<!> : A
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED("Class 'E'; public abstract val d: Int defined in D")!>class E<!> : D(), A
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED("Class 'F'; public abstract fun a(arg: Int): Unit defined in A")!>class F<!> : A

@An
 interface G {
@@ -44,5 +44,5 @@ interface GI : G {
    override fun a(@An arg: @An Int) {}
 }

-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED("Class 'AG1'", "public open fun a(arg: Int): Unit defined in AG1")!>class AG1<!>(val a: A, val g: G) : A by a, G by g
-<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED("Class 'AG2'", "public open fun a(arg: Int): Unit defined in AI")!>class AG2<!>() : AI, GI
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED("Class 'AG1'; public open fun a(arg: Int): Unit defined in AG1")!>class AG1<!>(val a: A, val g: G) : A by a, G by g
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED("Class 'AG2'; public open fun a(arg: Int): Unit defined in AI")!>class AG2<!>() : AI, GI
@@ -15,4 +15,4 @@ class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
    a <!INAPPLICABLE_CANDIDATE!>+<!> y
-}
+}
@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + <!NI;TYPE_MISMATCH("Out<Nothing>", "Out<CharSequence>"), OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS("Out<Nothing>", "Out<CharSequence>", "C<out CharSequence>", "public final operator fun plus(x: Out<T>): C<T> defined in C")!>y<!>
-}
+    a + <!"C<out{OI}, "Out<CharSequence>"{OI}, "Out<Nothing>"{OI}, "public{OI}, :{OI}, C"{OI}, C<T>{OI}, CharSequence>"{OI}, NI{OI}, Out<T>{OI}, TYPE_MISMATCH("Out<Nothing>; Out<CharSequence>"), TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}, defined{OI}, final{OI}, fun{OI}, in{OI}, operator{OI}, plus{OI}, x:{OI}!>y<!>
+}
@@ -23,4 +23,4 @@ interface B : A {

 interface C : A {
    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
-}
+}
@@ -15,12 +15,12 @@ interface A {

@An
 interface B : A {
-    override val p1: <!PROPERTY_TYPE_MISMATCH_ON_OVERRIDE("p1", "public abstract val p1: String defined in A")!>Int<!>
+    override val p1: <!PROPERTY_TYPE_MISMATCH_ON_OVERRIDE("p1; public abstract val p1: String defined in A")!>Int<!>
    @An
-    override <!VAR_OVERRIDDEN_BY_VAL("public abstract val p2: String defined in B", "public abstract var p2: String defined in A")!>val<!> p2: @An String
-    override fun test(arg: String): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("test", "public abstract fun test(arg: String): String defined in A")!>Int<!>
+    override <!VAR_OVERRIDDEN_BY_VAL("public abstract val p2: String defined in B; public abstract var p2: String defined in A")!>val<!> p2: @An String
+    override fun test(arg: String): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("test; public abstract fun test(arg: String): String defined in A")!>Int<!>
 }

 interface C : A {
-    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE("p2", "public abstract var p2: String defined in A")!>Int<!>
-}
+    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE("p2; public abstract var p2: String defined in A")!>Int<!>
+}
@@ -1,5 +1,5 @@
 // !RENDER_DIAGNOSTICS_MESSAGES
-// JAVAC_SKIP
+// SKIP_JAVAC

 // FILE: A.java

@@ -1,5 +1,5 @@
 // !RENDER_DIAGNOSTICS_MESSAGES
-// JAVAC_SKIP
+// SKIP_JAVAC

 // FILE: A.java

@@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull;
 annotation class An

 class B : A {
-    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo", "@NotNull @MyTypeQualifier public abstract fun foo(): String defined in A")!>String?<!> = null
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo; @NotNull @MyTypeQualifier public abstract fun foo(): String defined in A")!>String?<!> = null
 }

@An
@@ -38,5 +38,5 @@ public interface C {
 }

 class D : C {
-    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo", "public abstract fun foo(): String defined in C")!>String?<!> = null
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo; public abstract fun foo(): String defined in C")!>String?<!> = null
 }
@@ -8,5 +8,5 @@ annotation class A
 fun test() {
    @A
    var b: @A Int = 0
-    <!UNUSED_VALUE("15", "var b: Int defined in test")!>b =<!> 15
+    <!UNUSED_VALUE("15; var b: Int defined in test")!>b =<!> 15
 }
@@ -6,4 +6,4 @@ class Foo<T> {
 class Bar<T : Annotation> {
    @<!NOT_A_CLASS!>T<!>
    fun foo() = 0
-}
+}