[FIR] Report UPPER_BOUND_VIOLATED only on checkers stage, fix detection of missing cases and testData

2021-06-09 18:31:48 +03:00
parent ada14413e0
commit 5741374883
46 changed files with 203 additions and 208 deletions
@@ -20,10 +20,10 @@ package boundsWithSubstitutors

  class Pair<A, B>

-  abstract class C<T : B<Int>, X :  (B<Char>) -> Pair<B<Any>, B<A>>>() : <!UPPER_BOUND_VIOLATED!>B<Any><!>() { // 2 errors
+  abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X :  (B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Char<!>>) -> Pair<B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>>>() : B<<!UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
    val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error

-    abstract val x :  (B<Char>) -> B<Any>
+    abstract val x :  (B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Char<!>>) -> B<<!UPPER_BOUND_VIOLATED!>Any<!>>
  }


@@ -45,7 +45,7 @@ class Foo() {}

 class Bar<T : <!FINAL_UPPER_BOUND!>Foo<!>>

-class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<Int><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
+class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<<!UPPER_BOUND_VIOLATED!>Int<!>><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>

 class X<T : <!FINAL_UPPER_BOUND!>Foo<!>>
 class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!>> where T : <!FINAL_UPPER_BOUND!>Foo<!>, T : <!FINAL_UPPER_BOUND, ONLY_ONE_CLASS_BOUND_ALLOWED!>Bar<Foo><!>
@@ -62,8 +62,8 @@ fun <T> test2(t : T)
  t.bar()
 }

-val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
-val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
+val t1 = test2<<!UPPER_BOUND_VIOLATED!>A<!>>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
+val t2 = test2<<!UPPER_BOUND_VIOLATED!>B<!>>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())

 val <<!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>T<!>, <!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>B : T<!>> x : Int = 0
@@ -8,7 +8,7 @@ val <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test4<!> get() = T::

 fun <T> test5() = listOf(T::class)

-fun <T> test6(): kotlin.reflect.KClass<T> = <!TYPE_MISMATCH!>T<!>::class
+fun <T> test6(): kotlin.reflect.KClass<<!UPPER_BOUND_VIOLATED!>T<!>> = <!TYPE_MISMATCH!>T<!>::class
 fun <T> test7(): kotlin.reflect.KClass<*> = <!TYPE_MISMATCH!>T<!>::class
 fun test8() = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>String?::class<!>

@@ -21,9 +21,9 @@ interface<!SYNTAX!><!> {

 }

-<!UPPER_BOUND_VIOLATED!>enum class<!SYNTAX!><!> {
+enum class<!SYNTAX!><!> {

-}<!>
+}

 annotation class<!SYNTAX!><!> {

@@ -48,9 +48,9 @@ class Outer {

    }

-    <!UPPER_BOUND_VIOLATED!>enum class<!SYNTAX!><!> {
+    enum class<!SYNTAX!><!> {

-    }<!>
+    }

    annotation class<!SYNTAX!><!> {

@@ -2,7 +2,7 @@
 // FILE: test.kt
 enum class MyEnum(): <!CLASS_IN_SUPERTYPE_FOR_ENUM!>MyClass<!>() {}
 enum class MyEnum2(): MyTrait {}
-enum class MyEnum3(): <!UPPER_BOUND_VIOLATED{LT}!><!CLASS_IN_SUPERTYPE_FOR_ENUM, FINAL_SUPERTYPE, UPPER_BOUND_VIOLATED{PSI}!>MyEnumBase<!>()<!> {}
+enum class MyEnum3(): <!CLASS_IN_SUPERTYPE_FOR_ENUM, FINAL_SUPERTYPE!>MyEnumBase<!>() {}

 open class MyClass() {}

@@ -1,3 +0,0 @@
-open class C<T : C<T>>
-class TestOK : C<TestOK>()
-class TestFail : <!UPPER_BOUND_VIOLATED!>C<C<TestFail>><!>()
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 open class C<T : C<T>>
 class TestOK : C<TestOK>()
 class TestFail : C<<!UPPER_BOUND_VIOLATED!>C<<!UPPER_BOUND_VIOLATED!>TestFail<!>><!>>()
@@ -1 +0,0 @@
-class D<A : D<A, String>, B : D<A, B>>
@@ -1 +1,2 @@
+// FIR_IDENTICAL
 class D<A : D<A, <!UPPER_BOUND_VIOLATED!>String<!>>, B : D<A, B>>
@@ -1,5 +0,0 @@
-class Outer<E : Any> {
-    inner class Inner<F, G>
-}
-
-val x: Outer<String?>.Inner<String, Int> = null!!
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Outer<E : Any> {
    inner class Inner<F, G>
 }
@@ -1,13 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-interface A<T : CharSequence>
-
-fun <S : CharSequence?> foo1(a: A<S>) {}
-
-class B1<E : String?> : A<E>
-class B2<E : CharSequence?> : A<E>
-class B3<E> : A<E>
-
-class B4<E : CharSequence> : A<E>
-
-fun <X : CharSequence, Y1 : X, Y2: Y1?> foo(a: A<X>, b: A<Y1>, c: A<Y2>) {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER

 interface A<T : CharSequence>
@@ -7,10 +7,10 @@ fun <E : CharSequence> E.foo2() {}

 fun <F : String?> bar(x: F) {
    A(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
-    A<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    A<<!UPPER_BOUND_VIOLATED!>F<!>>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)

    foo1(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
-    foo1<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    foo1<<!UPPER_BOUND_VIOLATED!>F<!>>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)

    x<!UNSAFE_CALL!>.<!>foo2()
    x.<!INAPPLICABLE_CANDIDATE!>foo2<!><F>()
@@ -16,7 +16,7 @@ class A<F> {
        val x2 = foo2(x)
        x2.checkType { _<F>() }

-        foo1<F?>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+        foo1<<!UPPER_BOUND_VIOLATED!>F?<!>>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
        foo1(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
        foo2<F?>(y)

@@ -36,13 +36,13 @@ class A<F> {
        val x5 = foo2(z)
        x4.checkType { _<Z>() }

-        foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
+        foo1<<!UPPER_BOUND_VIOLATED!>W<!>>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
        foo1(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
        foo2<W>(w)

        val x6 = foo2(w)
        x6.checkType { _<W>() }

-        foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
+        foo1<<!UPPER_BOUND_VIOLATED!>W<!>>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
    }
 }
@@ -17,7 +17,7 @@ class A<F> {
    fun <Z : F, W : Z?> bar() {
        // F
        fooInv1<Inv<F>>(Inv<F>())
-        fooInv2<Inv<F>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
+        fooInv2<<!UPPER_BOUND_VIOLATED!>Inv<F><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
        fooInv1(Inv<F>())
        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)

@@ -32,13 +32,13 @@ class A<F> {
        fooOut2(Out<F>())

        // Z
-        fooInv1<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
-        fooInv2<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
+        fooInv1<<!UPPER_BOUND_VIOLATED!>Inv<Z><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
+        fooInv2<<!UPPER_BOUND_VIOLATED!>Inv<Z><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
        fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)

-        fooIn1<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
-        fooIn2<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
+        fooIn1<<!UPPER_BOUND_VIOLATED!>In<Z?><!>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
+        fooIn2<<!UPPER_BOUND_VIOLATED!>In<Z?><!>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
        fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
        fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)

@@ -48,17 +48,17 @@ class A<F> {
        fooOut2(Out<Z>())

        // W
-        fooInv1<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
-        fooInv2<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
+        fooInv1<<!UPPER_BOUND_VIOLATED!>Inv<W><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
+        fooInv2<<!UPPER_BOUND_VIOLATED!>Inv<W><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
        fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)

-        fooIn1<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
-        fooIn2<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
+        fooIn1<<!UPPER_BOUND_VIOLATED!>In<W?><!>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
+        fooIn2<<!UPPER_BOUND_VIOLATED!>In<W?><!>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
        fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
        fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)

-        fooOut1<Out<W>>(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
+        fooOut1<<!UPPER_BOUND_VIOLATED!>Out<W><!>>(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
        fooOut2<Out<W>>(Out<W>())
        fooOut1(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
        fooOut2(Out<W>())
@@ -13,14 +13,14 @@ class A<T> {

 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>Out<CharSequence>()<!>)
-    a.foo1<Out<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Out()<!>)
+    a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(<!ARGUMENT_TYPE_MISMATCH!>Out()<!>)

    a.foo1(Out())
    a.foo1(Out<Nothing>())

    a.foo2(Inv())
    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    a.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
+    a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)

    a.foo3(In())
    a.foo3(In<CharSequence>())
@@ -32,11 +32,11 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {

    b.foo2(Inv())
    b.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    b.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
+    b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)


    b.foo3(<!ARGUMENT_TYPE_MISMATCH!>In<CharSequence>()<!>)
-    b.foo3<In<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>In()<!>)
+    b.foo3<<!UPPER_BOUND_VIOLATED!>In<CharSequence><!>>(<!ARGUMENT_TYPE_MISMATCH!>In()<!>)

    b.foo3(In<Any?>())
    b.foo3(In())
@@ -1,9 +0,0 @@
-interface Trait<N : Number>
-
-object O1 : Trait<Int>
-
-object O2 : Trait<String>
-
-class C {
-    companion object : Trait<IntRange>
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface Trait<N : Number>

 object O1 : Trait<Int>
@@ -1,5 +1,4 @@
 // FIR_IDENTICAL
-// FIR_IDE_IGNORE
 // !DIAGNOSTICS: -REDECLARATION -DUPLICATE_CLASS_NAMES

 class C {
@@ -21,6 +21,6 @@ object<!SYNTAX!><!> {

 }

-<!UPPER_BOUND_VIOLATED!>enum class<!SYNTAX!><!> {}<!>
+enum class<!SYNTAX!><!> {}

 annotation class<!SYNTAX!><!> {}
@@ -7,7 +7,7 @@ abstract class Wrapper<T: A>(protected val t: T)
 class MyWrapper(a: A): Wrapper<A>(a)

 // This wrapper is not legal
-class TheirWrapper(e: E): Wrapper<E>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
+class TheirWrapper(e: E): Wrapper<<!UPPER_BOUND_VIOLATED!>E<!>>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)

 data class Pair<out T>(val a: T, val b: T)

@@ -17,7 +17,7 @@ class E
 class MyWrapper(a: A): Wrapper<A>(a)

 // This wrapper is not legal
-class TheirWrapper(e: E): Wrapper<E>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
+class TheirWrapper(e: E): Wrapper<<!UPPER_BOUND_VIOLATED!>E<!>>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)

 data class Pair<out T>(val a: T, val b: T)

@@ -10,7 +10,7 @@ fun testA(a: A<*, *>) {
    a.t().checkType { _<A<*, *>>() }
 }

-interface B<R, T: B<List<R>, T>> {
+interface B<R, T: B<List<R>, <!UPPER_BOUND_VIOLATED!>T<!>>> {
    fun r(): R
    fun t(): T
 }
@@ -3,7 +3,7 @@ class Num<T: Number>(val x: T)
 typealias N<T> = Num<T>
 typealias N2<T> = N<T>

-val x1 = Num<String>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+val x1 = Num<<!UPPER_BOUND_VIOLATED!>String<!>>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 val x2 = N<String>("")
 val x3 = N2<String>("")

@@ -12,6 +12,6 @@ class TColl<T, C : Collection<T>>
 typealias TC<T, C> = TColl<T, C>
 typealias TC2<T, C> = TC<T, C>

-val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>()
+val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED!>Any<!>>()
 val y2 = TC<Any, Any>()
 val y3 = TC2<Any, Any>()