[FIR] Fix positioning and detecting of WRONG_NUMBER_OF_TYPE_ARGUMENTS

Refactor code and fix compilation errors caused by changes to symbol.fir
2021-07-06 22:23:04 +03:00
parent 345152d198
commit dd54338ec0
49 changed files with 377 additions and 301 deletions
@@ -3,7 +3,7 @@ package unresolved
 class Pair<A, B>(val a: A, val b: B)

 fun testGenericArgumentsCount() {
-    val p1: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<Int><!> = Pair(2, 2)
+    val p1: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = Pair(2, 2)
    val p2: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<!> = Pair(2, 2)
 }

@@ -1,8 +1,7 @@
 interface A0<T : A0<T>>
 interface A1<T : A1<*>>
 interface A2<T : A2<out T>>
-// StackOverflowError
-//interface A3<T : A3<in T>>
+interface A3<T : A3<in T>>
 interface A4<T : A4<*>?>

 interface B0<T : B1<*>>
@@ -11,7 +10,7 @@ interface B1<T : B0<*>>
 interface AA<T: AA<*>>
 interface BB<S : List<AA<*>>>

-interface A<T: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>List<T, T, T><!>>
+interface A<T: List<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T, T, T><!>>

 class X<Y>
-class D<T : X<in X<out X<T>>>>
+class D<T : X<in X<out X<T>>>>
@@ -1,8 +1,7 @@
 interface A0<T : A0<T>>
 interface A1<<!FINITE_BOUNDS_VIOLATION!>T : A1<*><!>>
 interface A2<<!FINITE_BOUNDS_VIOLATION!>T : A2<out T><!>>
-// StackOverflowError
-//interface A3<T : A3<in T>>
+interface A3<<!FINITE_BOUNDS_VIOLATION!>T : A3<in T><!>>
 interface A4<<!FINITE_BOUNDS_VIOLATION!>T : A4<*>?<!>>

 interface B0<<!FINITE_BOUNDS_VIOLATION!>T : B1<*><!>>
@@ -14,4 +13,4 @@ interface BB<S : List<AA<*>>>
 interface A<T: List<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T, T, T><!>>

 class X<Y>
-class D<T : X<in X<out X<T>>>>
+class D<T : X<in X<out X<T>>>>
@@ -24,6 +24,12 @@ public interface A2</*0*/ T : A2<out T>> {
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

+public interface A3</*0*/ T : A3<in T>> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
 public interface A4</*0*/ T : A4<*>?> {
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -1,7 +1,7 @@
 package p

 public fun foo(a: Any) {
-    a is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!>
+    a is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>
    a is <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!>
    a is Map<out Any?, Any?>
    a is Map<*, *>
@@ -11,4 +11,4 @@ public fun foo(a: Any) {
    a is Int

    (a as <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!>) is Int
-}
+}
@@ -1,6 +1,6 @@
 public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
    when (a) {
-        is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!> -> {}
+        is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> -> {}
        is <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!> -> {}
        is Map<out Any?, Any?> -> {}
        is Map<*, *> -> {}
@@ -10,4 +10,4 @@ public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
        is Int -> {}
        else -> {}
    }
-}
+}
@@ -23,14 +23,14 @@ fun test() {
    Foo<String>.Bar.Baz::class

    a<Foo<String>.Bar>()
-    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar.Baz<!>>()
+    a<Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar.Baz>()

    a<Foo.Bar<Int>>()
-    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo.Bar<Int>.Baz<!>>()
+    a<Foo.Bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>.Baz>()
 }

 fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
 fun Foo<String>.Bar.ext() {}

-fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {
+fun ex1(a: Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String>): Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String> {
 }
@@ -1,20 +0,0 @@
-class Outer<E> {
-    inner class Inner<F, G> {
-        inner abstract class Inner2Base
-        inner class Inner2 : Inner2Base()
-
-        inner abstract class Inner3Base<B>
-        inner class Inner3<H> : Inner3Base<H>()
-    }
-
-    fun foo(x: Outer<*>.Inner<*, *>.Inner2Base) {
-        if (x is Inner.Inner2) return
-    }
-}
-
-fun bare(x: Outer<*>.Inner<*, *>.Inner2Base, y: Outer<*>.Inner<*, *>.Inner3Base<Int>) {
-    if (x is Outer.Inner.Inner2) return
-    if (y is Outer.Inner.Inner3) return
-    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<String>.Inner.Inner3<!>) return
-    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<String, Int>.Inner3<Double><!>) return
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Outer<E> {
    inner class Inner<F, G> {
        inner abstract class Inner2Base
@@ -3,7 +3,7 @@

 class Outer<T> {
    inner class Inner
-    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<!>, z: Inner) {
+    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner, z: Inner) {
        var inner = Inner()
        x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
        x.checkType { _<Outer<String>.Inner>() }
@@ -40,12 +40,12 @@ fun ok5(): test.Outer.Obj.Nested2<A>.Inner5<B> = null!!
 // All arguments are resolved
 fun errorTypeWithArguments(): <!UNRESOLVED_REFERENCE!>Q<A>.W<B, C, D>.R.M<!> = null!!

-fun error1(): Outer<A>.Inner<B>.Inner3<C, D> = null!!
-fun error2(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Inner<B, C, D>.Inner2<!> = null!!
-fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<A, B>.Inner3<C><!> = null!!
+fun error1(): Outer<A>.Inner<B>.Inner3<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><C, D><!> = null!!
+fun error2(): Outer<A>.Inner<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><B, C, D><!>.Inner2 = null!!
+fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner<A, B>.Inner3<C> = null!!

-fun error4(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Nested<B>.Inner4<C><!> = null!!
-fun error5(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Obj.Nested2<B>.Inner5<C><!> = null!!
-fun error6(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Obj<A>.Nested2<B>.Inner5<C><!> = null!!
+fun error4(): Outer<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Nested<B>.Inner4<C> = null!!
+fun error5(): Outer<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Obj.Nested2<B>.Inner5<C> = null!!
+fun error6(): Outer.Obj<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Nested2<B>.Inner5<C> = null!!

-fun error7(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>test<String>.Outer.Obj.Nested2<A>.Inner5<B><!> = null!!
+fun error7(): test<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Outer.Obj.Nested2<A>.Inner5<B> = null!!
@@ -1,19 +0,0 @@
-class A
-interface I0<T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>>
-interface I1<T> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-interface I2<<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-
-fun <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> foo0() {}
-fun <E> foo1() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
-fun <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> foo2() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
-
-val <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> E.p1: Int
-        get() = 1
-val <E> E.p2: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-        get() = 1
-val <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> E.p3: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-        get() = 1
-
-// See KT-8200
-interface X
-public class EnumAttribute<<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>X<T><!><!>>(val klass: Class<T>) where T : Enum<T>
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A
 interface I0<T : A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>>
 interface I1<T> where T : A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>
@@ -6,7 +6,7 @@ package p

 public class A<X, Y>
 public class M1 {
-    public val a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> = A<Int, Int>()
+    public val a: A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = A<Int, Int>()
 }

 // MODULE: m2
@@ -16,7 +16,7 @@ package p

 public class A<X, Y>

-public fun foo(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>) {
+public fun foo(a: A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>) {
 }

 // MODULE: m3(m1, m2)
@@ -27,4 +27,4 @@ import p.*
 fun test() {
    foo(M1().a)
    foo(1) // error type on the declaration site
-}
+}
@@ -1,3 +0,0 @@
-class B {}
-
-val b : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>B<*><!> = 1
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class B {}

 val b : B<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><*><!> = 1
@@ -1,14 +0,0 @@
-// KT-9620 AssertionError in checkBounds
-
-interface E1<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><String><!>, D>
-
-interface A
-interface B
-interface D<X>
-interface E2<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><A><!>, D<!SYNTAX!><<!><!SYNTAX!>B<!><!SYNTAX!>><!><!SYNTAX!>><!>
-
-// KT-11354 AE from DescriptorResolver
-
-open class L<E>()
-
-class M<C> : L<C<!TYPE_ARGUMENTS_NOT_ALLOWED!><C><!>>()
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-9620 AssertionError in checkBounds

 interface E1<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><String><!>, D>
@@ -5,6 +5,6 @@ class OuterClass<T1> {
    typealias NestedType<T> = NestedClass<T>
 }

-typealias ON1<T1, T2> = <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>OuterClass<T1>.NestedClass<T2><!>
+typealias ON1<T1, T2> = OuterClass<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T1><!>.NestedClass<T2>
 typealias ON2<T1, T2> = OuterClass<T1>.NestedType<T2>
-typealias ON3<T2> = OuterClass.NestedType<T2>
+typealias ON3<T2> = OuterClass.NestedType<T2>
@@ -41,10 +41,10 @@ interface Test<in I, out O, P> {
    fun neOk11(i: Inv<in <!TYPE_VARIANCE_CONFLICT("I; in; out; Inv<in I>")!>I<!>>)
    fun neOk12(i: Inv<out <!TYPE_VARIANCE_CONFLICT("O; out; in; Inv<out O>")!>O<!>>)

-    fun neOk30(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<O, ><!>)
+    fun neOk30(i: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><O, ><!>)
    fun neOk31(i: Pair<<!TYPE_VARIANCE_CONFLICT("O; out; in; Pair<O, ERROR CLASS: Wrong number of type arguments>")!>O<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>)
    fun neOk32(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>)
    fun neOk33(i: Inv<<!SYNTAX!><!>>)
    fun neOk34(i: Inv<<!UNRESOLVED_REFERENCE!>C<!>>)
-    fun neOk35(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>)
+    fun neOk35(i: Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>)
 }
@@ -38,10 +38,10 @@ interface Test<in I, out O, P> {
    var neOk22: Inv<out <!TYPE_VARIANCE_CONFLICT("O; out; invariant; Inv<out O>")!>O<!>>
    var neOk23: Inv<out <!TYPE_VARIANCE_CONFLICT("I; in; invariant; Inv<out I>")!>I<!>>

-    var neOk30: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    var neOk30: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><I, ><!>
    var neOk31: Pair<<!TYPE_VARIANCE_CONFLICT("I; in; invariant; Pair<I, ERROR CLASS: Wrong number of type arguments>")!>I<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
    var neOk32: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
    var neOk33: Inv<<!SYNTAX!><!>>
    var neOk34: Inv<<!UNRESOLVED_REFERENCE!>C<!>>
-    var neOk35: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
+    var neOk35: Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>
 }
@@ -33,10 +33,10 @@ interface Test<in I, out O, P> {
    fun neOk10(): Inv<in <!TYPE_VARIANCE_CONFLICT("O; out; in; Inv<in O>")!>O<!>>
    fun neOk11(): Inv<out <!TYPE_VARIANCE_CONFLICT("I; in; out; Inv<out I>")!>I<!>>

-    fun neOk30(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    fun neOk30(): Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><I, ><!>
    fun neOk31(): Pair<<!TYPE_VARIANCE_CONFLICT("I; in; out; Pair<I, ERROR CLASS: Wrong number of type arguments>")!>I<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
    fun neOk32(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
    fun neOk33(): Inv<<!SYNTAX!><!>>
    fun neOk34(): Inv<<!UNRESOLVED_REFERENCE!>C<!>>
-    fun neOk35(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
+    fun neOk35(): Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>
 }