[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,3 @@
+package abstract
+
+abstract enum class MyAbstractEnum() {}
@@ -0,0 +1,47 @@
+package abstract
+
+
+enum class MyEnum() {
+    INSTANCE;
+    //properties
+    val a: Int
+    val a1: Int = 1
+    abstract val a2: Int
+    abstract val a3: Int = 1
+
+    var b: Int                private set
+    var b1: Int = 0;                         private set
+    abstract var b2: Int      private set
+    abstract var b3: Int = 0; private set
+
+    var c: Int                set(v: Int) { field = v }
+    var c1: Int = 0;                         set(v: Int) { field = v }
+    abstract var c2: Int                     set(v: Int) { field = v }
+    abstract var c3: Int = 0; set(v: Int) { field = v }
+
+    val e: Int                               get() = a
+    val e1: Int = 0;          get() = a
+    abstract val e2: Int                     get() = a
+    abstract val e3: Int = 0; get() = a
+
+    //methods
+    fun f()
+    fun g() {}
+    abstract fun h()
+    abstract fun j() {}
+
+    //property accessors
+    var i: Int                       abstract get  abstract set
+    var i1: Int = 0;  abstract get  abstract set
+
+    var j: Int                       get() = i;    abstract set
+    var j1: Int = 0;  get() = i;    abstract set
+
+    var k: Int        abstract set
+    var k1: Int = 0;                 abstract set
+
+    var l: Int                       abstract get  abstract set
+    var l1: Int = 0;   abstract get  abstract set
+
+    var n: Int                       abstract get abstract set(v: Int) {}
+}
@@ -0,0 +1,12 @@
+enum class E : T {
+    ENTRY {
+        override fun f() {
+        }
+    };
+
+    abstract override fun f()
+}
+
+interface T {
+    fun f()
+}
@@ -0,0 +1,10 @@
+// KT-7753: attempt to call enum constructor explicitly
+enum class A(val c: Int) {
+    ONE(1),
+    TWO(2);    
+}
+
+fun createA(): A {
+    // Error should be here!
+    return <!INAPPLICABLE_CANDIDATE!>A<!>(10)
+}
@@ -0,0 +1,10 @@
+// KT-7753: attempt to call enum constructor explicitly
+enum class A(val c: Int) {
+    ONE(1),
+    TWO(2);
+    
+    fun createA(): A {
+        // Error should be here!
+        return A(10)
+    }
+}
@@ -0,0 +1,15 @@
+// KT-7753: attempt to call enum constructor explicitly
+enum class A(val c: Int) {
+    ONE(1) {
+        override fun selfOrFriend(): A {
+            return this
+        }
+    },
+    TWO(2) {
+        override fun selfOrFriend(): A {
+            return A(42)
+        }
+    };
+    
+    abstract fun selfOrFriend(): A
+}
@@ -0,0 +1,13 @@
+// KT-7753: attempt to call enum constructor explicitly
+enum class A(val c: Int) {
+    ONE(1),
+    TWO(2),
+    THREE(3),
+    FORTY_TWO();
+
+    var last: A? = null
+
+    constructor(): this(42) {
+        last = A(13)
+    }
+}
@@ -0,0 +1,7 @@
+enum class E public constructor(val x: Int) {
+    FIRST();
+
+    internal constructor(): this(42)
+
+    constructor(y: Int, z: Int): this(y + z)
+}
@@ -0,0 +1,9 @@
+// KT-7753 false positive: enum constructor can be called from secondary constructor
+enum class A(val c: Int) {
+    ONE(1),
+    TWO(2),
+    THREE(3),
+    FORTY_TWO();
+
+    constructor(): this(42)   
+}
@@ -0,0 +1,9 @@
+enum class E {
+    ENTRY;
+
+    companion object {
+        fun entry() = ENTRY
+    }
+}
+
+fun bar() = E.entry()
@@ -0,0 +1,10 @@
+enum class E {
+    ENTRY;
+
+    private companion object
+}
+
+fun foo() = E.values()
+fun bar() = E.valueOf("ENTRY")
+fun baz() = E.ENTRY
+fun quux() = E
@@ -0,0 +1,7 @@
+// KT-5943 StackOverflowError from commonSupertype of two enums
+// NI_EXPECTED_FILE
+
+enum class A { A }
+enum class B { B }
+
+val x = if (true) A.A else B.B
@@ -0,0 +1,16 @@
+// FILE: JavaEnumA.java
+
+public enum JavaEnumA {}
+
+// FILE: JavaEnumB.java
+
+public enum JavaEnumB {}
+
+// FILE: test.kt
+
+enum class KotlinEnumA
+enum class KotlinEnumB
+
+fun jj(a: JavaEnumA, b: JavaEnumB) = a == b
+fun jk(a: JavaEnumA, b: KotlinEnumB) = a == b
+fun kk(a: KotlinEnumA, b: KotlinEnumB) = a == b
@@ -0,0 +1,21 @@
+enum class TestOk(val x: String = "OK") {
+    TEST1,
+    TEST2(),
+    TEST3("Hello")
+}
+
+enum class TestErrors(val x: String) {
+    TEST1,
+    TEST2<!INAPPLICABLE_CANDIDATE!><!>(),
+    TEST3("Hello")
+}
+
+enum class TestMultipleConstructors(val x: String = "", val y: Int = 0) {
+    TEST;
+    constructor(x: String = "") : this(x, 0)
+}
+
+enum class TestVarargs(val x: Int) {
+    TEST;
+    constructor(vararg xs: Any) : this(xs.size)
+}
@@ -0,0 +1,16 @@
+// !LANGUAGE: +NestedClassesInEnumEntryShouldBeInner
+
+enum class E {
+    FIRST,
+    SECOND {
+        class A
+    };
+}
+
+val foo: Any.() -> Unit = {}
+
+fun f1() = E.FIRST.<!UNRESOLVED_REFERENCE!>foo<!>()
+fun f2() = E.FIRST.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+fun f3() = E.SECOND.<!UNRESOLVED_REFERENCE!>foo<!>()
+fun f4() = E.SECOND.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+fun f5() = E.SECOND.A()
@@ -0,0 +1,16 @@
+// !LANGUAGE: -NestedClassesInEnumEntryShouldBeInner
+
+enum class E {
+    FIRST,
+    SECOND {
+        class A
+    };
+}
+
+val foo: Any.() -> Unit = {}
+
+fun f1() = E.FIRST.<!UNRESOLVED_REFERENCE!>foo<!>()
+fun f2() = E.FIRST.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+fun f3() = E.SECOND.<!UNRESOLVED_REFERENCE!>foo<!>()
+fun f4() = E.SECOND.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+fun f5() = E.SECOND.A()
@@ -0,0 +1,4 @@
+enum class E {
+    A; // no constructor call needed
+    constructor()
+}
@@ -0,0 +1,9 @@
+enum class E {
+    E1,
+    E2
+}
+
+fun foo() {
+    var e = E.E1
+    e = E.E2
+}
@@ -0,0 +1,11 @@
+enum class E {
+    FIRST,
+
+    SECOND {
+        companion object {
+            fun foo() = 42
+        }
+    };
+}
+
+fun f() = E.SECOND.<!UNRESOLVED_REFERENCE!>foo<!>()
@@ -0,0 +1,13 @@
+enum class EnumClass {
+    E1 {
+        override fun foo() = 1
+        override val bar: String = "a"
+    },
+
+    E2 {
+
+    };
+
+    abstract fun foo(): Int
+    abstract val bar: String
+}
@@ -0,0 +1,21 @@
+interface T1 {
+    fun foo()
+}
+
+enum class EnumImplementingTraitWithFun: T1 {
+    E1 {
+        override fun foo() {}
+    },
+    E2
+}
+
+interface T2 {
+    val bar: Int
+}
+
+enum class EnumImplementingTraitWithVal: T2 {
+    E1 {
+        override val bar = 1
+    },
+    E2
+}
@@ -0,0 +1,11 @@
+// FILE: test.kt
+enum class MyEnum(): MyClass() {}
+enum class MyEnum2(): MyTrait {}
+enum class MyEnum3(): <!INAPPLICABLE_CANDIDATE!>MyEnumBase<!>() {}
+
+open class MyClass() {}
+
+enum class MyEnumBase() {}
+
+interface MyTrait {}
+
@@ -0,0 +1,14 @@
+import java.lang.annotation.RetentionPolicy
+
+enum class E {
+    ENTRY
+}
+
+// Test resolve from source
+val a: Enum<E> = E.ENTRY
+
+// Test Java resolve
+val b: Enum<RetentionPolicy> = RetentionPolicy.RUNTIME
+
+// Test deserialized resolve
+val c: Enum<AnnotationTarget> = AnnotationTarget.CLASS
@@ -0,0 +1,6 @@
+// Error: name should present
+enum class<!SYNTAX!><!>(val rgb : Int) {
+    RED(0xFF000),
+    GREEN(0x00FF00),
+    BLUE(0x0000FF)
+}
@@ -0,0 +1,15 @@
+enum class B {}
+
+class A {
+   enum companion object {}
+}
+
+enum object O {}
+
+enum interface T {}
+
+enum fun f() = 0
+
+enum val x = 0
+
+enum var y = 0
@@ -0,0 +1,20 @@
+// FILE: enum.kt
+
+package enum
+
+enum class HappyEnum {
+    CASE1,
+    CASE2
+}
+
+// FILE: user.kt
+
+import enum.HappyEnum
+import enum.HappyEnum.*
+
+fun f(e: HappyEnum) {
+    when (e) {
+        CASE1 -> throw UnsupportedOperationException() // unresolved reference
+        CASE2 -> throw UnsupportedOperationException() // unresolved references
+    }
+}
@@ -0,0 +1,40 @@
+// See KT-14705
+
+enum class En { A, B, С }
+
+fun foo() {
+    // nullable variable
+    val en2: Any? = En.A
+    if (en2 is En) {
+        when (en2) {
+            En.A -> {}
+            En.B -> {}
+            En.С -> {}
+        }
+    }
+
+    // not nullable variable
+    val en1: Any = En.A
+    if (en1 is En) {
+        when (en1) {
+            En.A -> {}
+            En.B -> {}
+            En.С -> {}
+        }
+    }
+}
+
+enum class En2 { D, E, F }
+
+fun useEn(x: En) = x
+fun useEn2(x: En2) = x
+
+fun bar(x: Any) {
+    if (x is En && x is En2) {
+        when (x) {
+            En.A -> useEn(x)
+            En2.D -> useEn2(x)
+            else -> {}
+        }
+    }
+}
@@ -0,0 +1,3 @@
+annotation enum class E {
+    D
+}
@@ -0,0 +1,2 @@
+enum class<!SYNTAX!><!> {
+}
@@ -0,0 +1,9 @@
+class Test1 : Enum<Test1>("", 0)
+
+class Outer {
+    class Test2 : Enum<Test2>("", 0)
+}
+
+fun outer() {
+    class Test3 : Enum<Test3>("", 0)
+}
@@ -0,0 +1,8 @@
+enum class E {
+    entry
+}
+
+val Int.entry: Int get() = 42
+val Long.entry: Int get() = 239
+
+val e = E.entry
@@ -0,0 +1,6 @@
+enum class MyEnum {
+    FIRST,
+    SECOND
+}
+
+fun foo(me: MyEnum): Boolean = if (me is MyEnum.FIRST) true else false
@@ -0,0 +1,7 @@
+// FILE: test.kt
+
+package test
+
+import java.util.concurrent.TimeUnit.*
+
+val c = SECONDS
@@ -0,0 +1,90 @@
+interface I {
+    fun foo()
+}
+
+enum class E1 : I {
+    A {
+        override fun foo() {
+            this == E2.A
+
+            val q = this
+            when (q) {
+                this -> {}
+                E1.A -> {}
+                E1.B -> {}
+                E2.A -> {}
+                E2.B -> {}
+                else -> {}
+            }
+        }
+    },
+    B {
+        override fun foo() {
+
+        }
+    }
+}
+
+enum class E2 : I {
+    A {
+        override fun foo() {
+
+        }
+    },
+    B {
+        override fun foo() {
+
+        }
+    }
+}
+
+fun foo1(e1: E1, e2: E2) {
+    e1 == e2
+    e1 != e2
+
+    e1 == E2.A
+    E1.B == e2
+
+    E1.A == E2.B
+
+    e1 == E1.A
+    E1.A == e1
+    e2 == E2.B
+    E2.B == e2
+}
+
+fun foo2(e1: E1, e2: E2) {
+    when (e1) {
+        E1.A -> {}
+        E2.A -> {}
+        E2.B -> {}
+        e1 -> {}
+        e2 -> {}
+        else -> {}
+    }
+}
+
+fun foo3(e1: Enum<E1>, e2: Enum<E2>, e: Enum<*>) {
+    e1 == e
+    e1 == e2
+
+    e1 == E1.A
+    e1 == E2.A
+
+    when (e1) {
+        e1 -> {}
+        e2 -> {}
+        e -> {}
+        E1.A -> {}
+        E2.A -> {}
+        else -> {}
+    }
+
+    when (e) {
+        e -> {}
+        e2 -> {}
+        E1.A -> {}
+        E2.A -> {}
+        else -> {}
+    }
+}
@@ -0,0 +1,145 @@
+// !LANGUAGE: -ProhibitComparisonOfIncompatibleEnums
+
+enum class E1 {
+    A, B
+}
+
+enum class E2 {
+    A, B
+}
+
+fun foo1(e1: E1, e2: E2) {
+    e1 == e2
+    e1 != e2
+
+    e1 == E2.A
+    E1.B == e2
+
+    E1.A == E2.B
+
+    e1 == E1.A
+    E1.A == e1
+    e2 == E2.B
+    E2.B == e2
+}
+
+fun foo2(e1: E1, e2: E2) {
+    when (e1) {
+        E1.A -> {}
+        E2.A -> {}
+        E2.B -> {}
+        e1 -> {}
+        e2 -> {}
+        else -> {}
+    }
+}
+
+fun foo3(e1: Enum<E1>, e2: Enum<E2>, e: Enum<*>) {
+    e1 == e
+    e1 == e2
+
+    e1 == E1.A
+    e1 == E2.A
+
+    when (e1) {
+        e1 -> {}
+        e2 -> {}
+        e -> {}
+        E1.A -> {}
+        E2.A -> {}
+        else -> {}
+    }
+
+    when (e) {
+        e -> {}
+        e2 -> {}
+        E1.A -> {}
+        E2.A -> {}
+        else -> {}
+    }
+}
+
+interface MyInterface
+open class MyOpenClass
+
+fun foo4(e1: E1, i: MyInterface, c: MyOpenClass) {
+    e1 == i
+    i == e1
+
+    e1 == c
+    c == e1
+
+    when (e1) {
+        i -> {}
+        c -> {}
+        else -> {}
+    }
+}
+
+enum class E3 : MyInterface { X, Y }
+
+fun foo5(i: MyInterface, a: Any) {
+    E3.X == E3.Y
+    E3.X == i
+    E3.X == a
+}
+
+fun foo6(e1: E1?, e2: E2) {
+    E1.A == null
+    null == E1.A
+    e1 == null
+    null == e1
+
+    e1 == E2.A
+    E2.A == e1
+    e1 == e2
+    e2 == e1
+
+    e2 == null
+    null == e2
+    E1.A == null
+    null == E1.A
+}
+
+fun foo7(e1: E1?, e2: E2?) {
+    e1 == e2 // There should be an IDE-inspection for such cases
+}
+
+fun <T> foo8(e1: E1?, e2: E2, t: T) {
+    e1 == t
+    t == e1
+
+    e2 == t
+    t == e2
+
+    E1.A == t
+    t == E1.A
+}
+
+fun <T, K> foo9(e1: E1?, e2: E2, t: T, k: K) where T : MyInterface, T : MyOpenClass, K : MyInterface {
+    e1 == t
+    t == e1
+
+    e2 == t
+    t == e2
+
+    E1.A == t
+    t == E1.A
+
+    E3.X == t
+
+    E3.X == k
+    k == E3.X
+}
+
+interface Inv<T>
+
+enum class E4 : Inv<Int> { A }
+
+fun foo10(e4: E4, invString: Inv<String>) {
+    e4 == invString
+    invString == e4
+
+    E4.A == invString
+    invString == E4.A
+}
@@ -0,0 +1,145 @@
+// !LANGUAGE: +ProhibitComparisonOfIncompatibleEnums
+
+enum class E1 {
+    A, B
+}
+
+enum class E2 {
+    A, B
+}
+
+fun foo1(e1: E1, e2: E2) {
+    e1 == e2
+    e1 != e2
+
+    e1 == E2.A
+    E1.B == e2
+
+    E1.A == E2.B
+
+    e1 == E1.A
+    E1.A == e1
+    e2 == E2.B
+    E2.B == e2
+}
+
+fun foo2(e1: E1, e2: E2) {
+    when (e1) {
+        E1.A -> {}
+            E2.A -> {}
+            E2.B -> {}
+        e1 -> {}
+            e2 -> {}
+        else -> {}
+    }
+}
+
+fun foo3(e1: Enum<E1>, e2: Enum<E2>, e: Enum<*>) {
+    e1 == e
+    e1 == e2
+
+    e1 == E1.A
+    e1 == E2.A
+
+    when (e1) {
+        e1 -> {}
+        e2 -> {}
+        e -> {}
+        E1.A -> {}
+            E2.A -> {}
+        else -> {}
+    }
+
+    when (e) {
+        e -> {}
+        e2 -> {}
+        E1.A -> {}
+        E2.A -> {}
+        else -> {}
+    }
+}
+
+interface MyInterface
+open class MyOpenClass
+
+fun foo4(e1: E1, i: MyInterface, c: MyOpenClass) {
+    e1 == i
+    i == e1
+
+    e1 == c
+    c == e1
+
+    when (e1) {
+            i -> {}
+            c -> {}
+        else -> {}
+    }
+}
+
+enum class E3 : MyInterface { X, Y }
+
+fun foo5(i: MyInterface, a: Any) {
+    E3.X == E3.Y
+    E3.X == i
+    E3.X == a
+}
+
+fun foo6(e1: E1?, e2: E2) {
+    E1.A == null
+    null == E1.A
+    e1 == null
+    null == e1
+
+    e1 == E2.A
+    E2.A == e1
+    e1 == e2
+    e2 == e1
+
+    e2 == null
+    null == e2
+    E1.A == null
+    null == E1.A
+}
+
+fun foo7(e1: E1?, e2: E2?) {
+    e1 == e2 // There should be an IDE-inspection for such cases
+}
+
+fun <T> foo8(e1: E1?, e2: E2, t: T) {
+    e1 == t
+    t == e1
+
+    e2 == t
+    t == e2
+
+    E1.A == t
+    t == E1.A
+}
+
+fun <T, K> foo9(e1: E1?, e2: E2, t: T, k: K) where T : MyInterface, T : MyOpenClass, K : MyInterface {
+    e1 == t
+    t == e1
+
+    e2 == t
+    t == e2
+
+    E1.A == t
+    t == E1.A
+
+    E3.X == t
+
+    E3.X == k
+    k == E3.X
+}
+
+interface Inv<T>
+
+enum class E4 : Inv<Int> { A }
+
+fun foo10(e4: E4, invString: Inv<String>) {
+    e4 == invString
+    invString == e4
+
+    E4.A == invString
+    invString == E4.A
+}
@@ -0,0 +1,5 @@
+enum class E {
+    ENTRY
+}
+
+class A : E.ENTRY
@@ -0,0 +1,13 @@
+// FILE: MyJavaEnum.java
+public enum MyJavaEnum {}
+
+// FILE: test.kt
+open enum class MyEnum() {
+    A()
+}
+
+enum class MyEnum2() {}
+
+class MyClass(): <!INAPPLICABLE_CANDIDATE!>MyEnum2<!>() {}
+
+class MyClass2(): <!UNRESOLVED_REFERENCE!>MyJavaEnum<!>() {}
@@ -0,0 +1,3 @@
+enum class My {
+    inline
+}
@@ -0,0 +1,19 @@
+class A {
+    enum class E {
+        ENTRY
+    }
+    
+    companion object {
+    }
+}
+
+
+
+class B {
+    companion object {
+    }
+    
+    enum class E {
+        ENTRY
+    }
+}
@@ -0,0 +1,5 @@
+class A {
+    enum class E {
+        ENTRY
+    }
+}
@@ -0,0 +1,7 @@
+class A {
+    companion object {
+        enum class E {
+            ENTRY
+        }
+    }
+}
@@ -0,0 +1,7 @@
+enum class E {
+    ABC;
+    
+    enum class F {
+        DEF
+    }
+}
@@ -0,0 +1,9 @@
+// !LANGUAGE: +NestedClassesInEnumEntryShouldBeInner
+
+enum class E {
+    ABC {
+        enum class F {
+            DEF
+        }
+    }
+}
@@ -0,0 +1,9 @@
+// !LANGUAGE: -NestedClassesInEnumEntryShouldBeInner
+
+enum class E {
+    ABC {
+        enum class F {
+            DEF
+        }
+    }
+}
@@ -0,0 +1,7 @@
+class A {
+    inner class B {
+        enum class E {
+            ENTRY
+        }
+    }
+}
@@ -0,0 +1,5 @@
+object A {
+    enum class E {
+        ENTRY
+    }
+}
@@ -0,0 +1,5 @@
+interface A {
+    enum class E {
+        ENTRY
+    }
+}
@@ -0,0 +1,11 @@
+class A {
+    enum class E {
+        ENTRY
+    }
+    
+    companion object {
+        enum class E {
+            ENTRY2
+        }
+    }
+}
@@ -0,0 +1,4 @@
+class A {
+    enum class E { ABC }
+    enum class F { DEF }
+}
@@ -0,0 +1,9 @@
+class A {
+    companion object {
+        enum class E { ENTRY }  // OK
+    }
+    
+    inner class B {
+        enum class E { ENTRY }
+    }
+}
@@ -0,0 +1,8 @@
+enum interface Some {
+    // Enum part
+    D;
+
+    // Interface like part
+    fun test()
+    val foo: Int
+}
@@ -0,0 +1,6 @@
+enum class MyEnum {
+    FIRST,
+    SECOND
+}
+
+fun foo(me: MyEnum): Boolean = me is MyEnum.FIRST
@@ -0,0 +1,10 @@
+// !CHECK_TYPE
+// FILE: A.java
+public enum A {
+    ENTRY;
+}
+
+// FILE: test.kt
+fun main() {
+    checkSubtype<A>(A.valueOf("ENTRY"))
+}
@@ -0,0 +1,11 @@
+// !CHECK_TYPE
+// FILE: A.java
+public enum A {
+    ENTRY,
+    ANOTHER;
+}
+
+// FILE: test.kt
+fun main() {
+     checkSubtype<Array<A>>(A.values())
+}
@@ -0,0 +1,16 @@
+// !CHECK_TYPE
+// FILE: A.java
+public enum A {
+
+    ENTRY {
+        public String s() {
+            return "s";
+        }
+    };
+    public abstract String s();
+}
+
+// FILE: test.kt
+fun main() {
+    checkSubtype<String?>(A.ENTRY.s())
+}
@@ -0,0 +1,16 @@
+// FILE: A.java
+public enum A {
+    ENTRY,
+    ANOTHER;
+    
+    public String s() {
+        return "";
+    }
+}
+
+// FILE: test.kt
+
+fun main() {
+    val c = A.ENTRY
+    c.s()
+}
@@ -0,0 +1,15 @@
+// FILE: A.java
+public enum A {
+    ENTRY,
+    ANOTHER;
+
+    public String ENTRY = "";
+}
+
+// FILE: test.kt
+
+fun main() {
+    val c: A = A.ENTRY
+    val c2: String? = c.<!AMBIGUITY!>ENTRY<!>
+    val c3: String? = A.ANOTHER.<!AMBIGUITY!>ENTRY<!>
+}
@@ -0,0 +1,19 @@
+// FILE: A.java
+public enum A {
+    ENTRY("1"),
+    ANOTHER("2");
+
+    public String s;
+
+    private A(String s) {
+        this.s = s;
+    }
+}
+
+// FILE: test.kt
+
+fun main() {
+    val c = A.ENTRY
+    c.s
+    A.ANOTHER.s
+}
@@ -0,0 +1,6 @@
+private enum class MethodKind {
+    INSTANCE,
+    STATIC
+}
+
+private fun MethodKind.hasThis() = this == MethodKind.INSTANCE
@@ -0,0 +1,7 @@
+// !WITH_NEW_INFERENCE
+enum class E : Cloneable {
+    A;
+    override fun clone(): Any {
+        return super.clone()
+    }
+}
@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    enum class A {
+        FOO,
+        BAR
+    }
+    val foo = A.<!UNRESOLVED_REFERENCE!>FOO<!>
+    val b = object {
+        enum class B {}
+    }
+    class C {
+        enum class D {}
+    }
+    val f = {
+        enum class E {}
+    }
+
+    enum class<!SYNTAX!><!> {}
+}
@@ -0,0 +1,23 @@
+enum class E {
+    public final SUBCLASS {
+        fun foo() {}
+    },
+
+    public PUBLIC,
+    protected PROTECTED,
+    private PRIVATE,
+    internal INTERNAL,
+
+    abstract ABSTRACT,
+    open OPEN,
+    override OVERRIDE,
+    final FINAL,
+
+    inner INNER,
+    annotation ANNOTATION,
+    enum ENUM,
+    out OUT,
+    in IN,
+    vararg VARARG,
+    reified REIFIED
+}
@@ -0,0 +1,8 @@
+enum class E(val x: Int, val y: Int) {
+    A(1, 2),
+    B(1),
+    C; // no constructor call needed even here
+
+    constructor(): this(0, 0)
+    constructor(x: Int): this(x, 0)
+}
@@ -0,0 +1,17 @@
+enum class EnumWithOpenMembers {
+    E1 {
+        override fun foo() = 1
+        override val bar: String = "a"
+    },
+
+    E2 {
+        override fun f() = 3
+        override val b = 4
+    };
+
+    open fun foo() = 1
+    open val bar: String = ""
+
+    fun f() = 2
+    val b = 3
+}
@@ -0,0 +1,11 @@
+enum class E {
+    ENTRY;
+
+    override val name: String = "lol"
+    override val ordinal: Int = 0
+
+    override fun compareTo(other: E) = -1
+
+    override fun equals(other: Any?) = true
+    override fun hashCode() = -1
+}
@@ -0,0 +1,24 @@
+// FILE: E.kt
+package foo
+
+enum class E {
+    ENTRY,
+    ANOTHER;
+
+    class Nested {
+        companion object {
+            fun foo() = 42
+        }
+    }
+}
+
+// FILE: main.kt
+package bar
+
+import foo.E.*
+
+fun f1() = ENTRY
+fun f2() = ANOTHER
+fun f3() = Nested()
+fun f4() = Nested.foo()
+fun f5() = values()
@@ -0,0 +1,7 @@
+// KT-5696 Prohibit type parameters for enum classes
+
+package bug
+
+public enum class Foo<T> {
+    A()
+}
@@ -0,0 +1,18 @@
+enum class E {
+    ENTRY;
+
+    companion object {
+        fun foo(): E = ENTRY
+        fun bar(): Array<E> = <!UNRESOLVED_REFERENCE!>values<!>()
+        fun baz(): E = <!UNRESOLVED_REFERENCE!>valueOf<!>("ENTRY")
+        val valuez = <!UNRESOLVED_REFERENCE!>values<!>()
+    }
+
+    fun oof(): E = ENTRY
+    fun rab(): Array<E> = values()
+    fun zab(): E = valueOf("ENTRY")
+}
+
+fun foo() = E.ENTRY
+fun bar() = E.values()
+fun baz() = E.valueOf("ENTRY")
@@ -0,0 +1,9 @@
+// See KT-20959
+
+enum class Foo {;
+    companion object  {
+        val x = foo() // there should be no UNINITIALIZED_ENUM_COMPANION
+
+        private fun foo() = "OK"
+    }
+}