[FIR-TEST] Add new testdata generated after changes in previous commit

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -0,0 +1,9 @@
+// http://youtrack.jetbrains.net/issue/KT-20
+
+class A() {
+    val x = 1
+
+    companion object {
+        val y = <!UNRESOLVED_REFERENCE!>x<!>
+    }
+}
@@ -0,0 +1,30 @@
+package foo
+
+fun test() {
+  A.d
+  A.Companion.<!INAPPLICABLE_CANDIDATE!>f<!>
+  B.D
+  CCC
+  CCC.classObjectVar
+}
+
+class A() {
+  public companion object {
+    val d = 3
+    private object f {
+
+    }
+  }
+}
+
+class B {
+    class D {
+        private companion object
+    }
+}
+
+class CCC() {
+  private companion object {
+    val classObjectVar = 3
+  }
+}
@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
+package Jet86
+
+class A {
+  companion object {
+    val x = 1
+  }
+  companion object {
+    val x = 1
+  }
+}
+
+class AA {
+  companion object {
+    val x = 1
+  }
+  companion object A {
+    val x = 1
+  }
+    companion object AA {
+    val x = 1
+  }
+}
+
+class B() {
+  val x = 12
+}
+
+object b {
+  companion object {
+    val x = 1
+  } // error
+}
+
+val a = A.x
+val c = B.<!UNRESOLVED_REFERENCE!>x<!>
+val d = b.<!UNRESOLVED_REFERENCE!>x<!>
+
+val s = System  // error
+fun test() {
+  System.out.println()
+  java.lang.System.out.println()
+}
@@ -0,0 +1,51 @@
+package a
+
+class A {
+    class Nested
+    inner class Inner
+
+
+    companion object {
+
+        class Nested2
+
+        val c: Int = 1
+
+        object Obj2 {
+            val c: Int = 1
+        }
+    }
+
+    object Obj
+}
+
+object O {
+    class A
+
+    object O
+}
+
+fun f() {
+    A.c
+    A.hashCode()
+    A().Nested
+    A.Nested()
+    A().Inner()
+    A.Companion.<!UNRESOLVED_REFERENCE!>Nested<!>
+    A.Companion.<!UNRESOLVED_REFERENCE!>Inner<!>
+    A.Inner
+    A.Companion.c
+    A.Companion.Obj2
+    A.Companion.Obj2.c
+
+    A.Companion.Nested2()
+    A.Companion.c
+    A.Obj
+    A.Companion.Obj2
+    A.Obj2
+    A.Obj2.c
+    A.Nested2
+
+    O.O
+    O.A()
+}
@@ -0,0 +1,50 @@
+// !LANGUAGE: +NestedClassesInEnumEntryShouldBeInner
+
+package a
+
+
+enum class C {
+    E1, E2, E3 {
+        object O_O
+
+        fun b() {
+            O_O
+        }
+
+        class G
+    },
+
+    E4 {
+        fun c() {
+            this.<!UNRESOLVED_REFERENCE!>B<!>()
+
+            C.A()
+            A()
+            //TODO: should be resolved with error
+            this.<!UNRESOLVED_REFERENCE!>A<!>()
+        }
+    };
+
+    class A
+    inner class B
+    object O {
+        object InO
+    }
+}
+
+fun f() {
+    C.E1.A
+    C.E1.A()
+    C.E2.B()
+
+    C.E2.O
+    C.E3.O.InO
+
+    C.O
+    C.O.InO
+    C.A()
+    C.<!UNRESOLVED_REFERENCE!>B<!>()
+
+    C.E3.O_O
+    C.E3.G()
+}
@@ -0,0 +1,50 @@
+// !LANGUAGE: -NestedClassesInEnumEntryShouldBeInner
+
+package a
+
+
+enum class C {
+    E1, E2, E3 {
+        object O_O
+
+        fun b() {
+            O_O
+        }
+
+        class G
+    },
+
+    E4 {
+        fun c() {
+            this.<!UNRESOLVED_REFERENCE!>B<!>()
+
+            C.A()
+            A()
+            //TODO: should be resolved with error
+            this.<!UNRESOLVED_REFERENCE!>A<!>()
+        }
+    };
+
+    class A
+    inner class B
+    object O {
+        object InO
+    }
+}
+
+fun f() {
+    C.E1.A
+    C.E1.A()
+    C.E2.B()
+
+    C.E2.O
+    C.E3.O.InO
+
+    C.O
+    C.O.InO
+    C.A()
+    C.<!UNRESOLVED_REFERENCE!>B<!>()
+
+    C.E3.O_O
+    C.E3.G()
+}
@@ -0,0 +1,25 @@
+// http://youtrack.jetbrains.net/issue/KT-449
+
+class A {
+    inner class B {
+        companion object { }
+    }
+}
+
+class B {
+    companion object {
+        class B {
+            companion object {
+                class C {
+                    companion object { }
+                }
+            }
+        }
+    }
+}
+
+class C {
+    class D {
+        companion object { }
+    }
+}
@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun box(): String {
+    try {
+        // Objects
+        val i = Int
+        val d = Double
+        val f = Float
+        val l = Long
+        val sh = Short
+        val b = Byte
+        val ch = Char
+        val st = String
+
+        test(Int)
+        test(Double)
+        test(Float)
+        test(Long)
+        test(Short)
+        test(Byte)
+        test(String)
+        test(Char)
+
+        // Common Double
+        Double.POSITIVE_INFINITY
+        Double.NEGATIVE_INFINITY
+        Double.NaN
+
+        // Common Float
+        Float.POSITIVE_INFINITY
+        Float.NEGATIVE_INFINITY
+        Float.NaN
+    }
+    catch (e: Throwable) {
+        return "Error: \n" + e
+    }
+
+    return "OK"
+}
+
+fun test(a: Any) {}
+
+
@@ -0,0 +1,9 @@
+package test
+
+open class ToResolve<SomeClass>(f : (Int) -> Int)
+fun testFun(a : Int) = 12
+
+class TestSome<P> {
+    companion object : ToResolve<P>({testFun(it)}) {
+    }
+}
@@ -0,0 +1,9 @@
+fun test() {
+    class A {
+        companion object {}
+    }
+
+    object {
+        companion object {}
+    }
+}
@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
+package test
+
+class A {
+    object Companion
+
+    companion object
+}
+
+class B {
+    companion object Named
+
+    object Named
+}
+
+class C {
+    class Named
+
+    companion object Named
+}
@@ -0,0 +1,19 @@
+package test
+
+fun use() {
+    Default.create()
+
+    Explicit.create()
+}
+
+private class Default {
+    companion object {
+        fun create() = Default()
+    }
+}
+
+private class Explicit {
+    private companion object {
+        fun create() = Explicit()
+    }
+}
@@ -0,0 +1,11 @@
+package f
+
+import f.A.Companion.B
+
+class A {
+    companion object {
+        class B
+    }
+}
+
+fun test() = B()
@@ -0,0 +1,51 @@
+//FILE:a.kt
+package a
+
+class A {
+    companion object {
+        fun foo() {}
+    }
+}
+
+private class B {
+    companion object {
+        fun bar() {}
+    }
+}
+
+class C {
+    private companion object {
+        fun baz() {}
+    }
+}
+
+private class D {
+    private companion object {
+        fun quux() {}
+    }
+}
+
+//FILE:b.kt
+package b
+
+import a.A
+import a.B
+import a.C
+import a.D
+
+fun test() {
+    f(A)
+    f(<!INAPPLICABLE_CANDIDATE!>B<!>)
+    f(C)
+    f(<!INAPPLICABLE_CANDIDATE!>D<!>)
+
+    A.foo()
+    <!INAPPLICABLE_CANDIDATE!>B<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
+    C.baz()
+    <!INAPPLICABLE_CANDIDATE!>D<!>.<!UNRESOLVED_REFERENCE!>quux<!>()
+
+    a.A.foo()
+    a.C.baz()
+}
+
+fun f(unused: Any) {}
@@ -0,0 +1,20 @@
+open class C {
+}
+
+fun C.foo() {}
+
+open class X {
+    companion object : C() {}
+}
+
+open class Y {
+    companion object : C() {}
+}
+
+fun bar() {
+    val x = X
+    x.foo()
+    X.foo()
+    (X as C).foo()
+    ((if (1<2) X else Y) as C).foo()
+}
@@ -0,0 +1,17 @@
+class A {
+    inner class I {
+        companion object A
+
+        companion object B
+
+        companion object C
+    }
+}
+
+object O {
+    companion object A
+
+    companion object B
+
+    companion object C
+}
@@ -0,0 +1,15 @@
+class A {
+    private companion object {
+        class B {
+            class C {
+                companion object {
+                    fun foo() {}
+                }
+            }
+        }
+    }
+}
+
+fun f1() = A.<!INAPPLICABLE_CANDIDATE!>Companion<!>.<!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>C<!>
+
+fun f2() = A.<!INAPPLICABLE_CANDIDATE!>Companion<!>.<!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>C<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
@@ -0,0 +1,9 @@
+package test
+
+class Test {
+  fun test(): Int = 12
+
+  companion object {
+    val a = <!UNRESOLVED_REFERENCE!>test<!>() // Check if resolver will be able to infer type of a variable
+  }
+}
@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE!
+// ISSUE: KT-28999
+
+fun case_1() {
+    val x = object<T> { } // type of x is <anonymous object><T>
+}
+
+fun case_2() {
+    val x = object<T : Number, K: Comparable<K>> { }
+}
+
+fun case_3() {
+    val x = object<T> <!SYNTAX!>where T : Comparable<T><!> { } // ERROR: Where clause is not allowed for objects
+}
+
+val x = object<T, K: Comparable<K>> {
+    fun test() = 10 as T // OK
+}
+
+fun case_4() {
+    val x = object<T> {
+        fun test() = 10 as T
+    }
+
+    val y = x.test() // type y is T
+}
+
+inline fun <reified T> case_5() {
+    val x = object<T> {
+        fun test() = 10 as T
+    }
+
+    val z = x.test()
+
+    if (z is T) {
+        // z is {T!! & T!!} (smart cast from T)
+        <!UNRESOLVED_REFERENCE!>println<!>(z)
+    }
+}
@@ -0,0 +1,40 @@
+// !LANGUAGE: +ProhibitTypeParametersInAnonymousObjects
+// !DIAGNOSTICS: -UNUSED_VARIABLE!
+// ISSUE: KT-28999
+
+fun case_1() {
+    val x = object<T> { } // type of x is <anonymous object><T>
+}
+
+fun case_2() {
+    val x = object<T : Number, K: Comparable<K>> { }
+}
+
+fun case_3() {
+    val x = object<T> <!SYNTAX!>where T : Comparable<T><!> { } // ERROR: Where clause is not allowed for objects
+}
+
+val x = object<T, K: Comparable<K>> {
+    fun test() = 10 as T // OK
+}
+
+fun case_4() {
+    val x = object<T> {
+        fun test() = 10 as T
+    }
+
+    val y = x.test() // type y is T
+}
+
+inline fun <reified T> case_5() {
+    val x = object<T> {
+        fun test() = 10 as T
+    }
+
+    val z = x.test()
+
+    if (z is T) {
+        // z is {T!! & T!!} (smart cast from T)
+        <!UNRESOLVED_REFERENCE!>println<!>(z)
+    }
+}
@@ -0,0 +1,21 @@
+object A<T>
+object B<in T, out R>
+object C<T : Comparable<T>>
+
+class D {
+    companion object<T>
+}
+
+class E {
+    companion object<in T, out R>
+}
+
+class F {
+    companion object C<T : Comparable<T>>
+}
+
+class G {
+    companion object F<T>
+}
+
+object H<T, R>()