[K2/Diff] Rebase onto a fresher master

compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/FirDifferences.kt

diff --git a/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/FirDifferences.kt b/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/FirDifferences.kt
index 0179568..46ff11d 100644
--- a/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/FirDifferences.kt
+++ b/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/FirDifferences.kt
@@ -109,6 +109,8 @@
         "OPT_IN_USAGE_ERROR",
         "EXPRESSION_EXPECTED_PACKAGE_FOUND",
         "ADAPTED_CALLABLE_REFERENCE_AGAINST_REFLECTION_TYPE",
+        "NO_RECEIVER_ALLOWED",
+        "DEPRECATED_ACCESS_TO_ENTRY_PROPERTY_FROM_ENUM",
 //    ),
 //    listOf(
         "CLASS_LITERAL_LHS_NOT_A_CLASS",
@@ -157,6 +159,7 @@
         "ASSIGNMENT_IN_EXPRESSION_CONTEXT",
         "EXPRESSION_EXPECTED",
         "EXPRESSION_REQUIRED",
+        "DECLARATION_IN_ILLEGAL_CONTEXT",
 //    ),
 //    listOf(
         "TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM_IN_AUGMENTED_ASSIGNMENT_ERROR",

compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/KnownIssues.kt

diff --git a/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/KnownIssues.kt b/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/KnownIssues.kt
index 099b1b2..2ad77da 100644
--- a/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/KnownIssues.kt
+++ b/compiler/k2-differences/tests/org/jetbrains/kotlin/test/frontend/fir/differences/KnownIssues.kt
@@ -499,6 +499,12 @@
     "NESTED_JS_EXPORT" to IssueInfo("25-4874957", 62736),
     "JSCODE_NO_JAVASCRIPT_PRODUCED" to IssueInfo("25-4912778", 63204),
     "JSCODE_ERROR" to IssueInfo("25-4912779", 63205),
+    "OUTER_CLASS_ARGUMENTS_REQUIRED" to IssueInfo("25-5053078", 64661),
+    "BUILDER_INFERENCE_STUB_RECEIVER" to IssueInfo("25-5053079", 64662),
+    "TYPE_PARAMETER_AS_REIFIED" to IssueInfo("25-5053080", 64663),
+    "CALLABLE_REFERENCE_LHS_NOT_A_CLASS" to IssueInfo("25-5053081", 64664),
+    "DELEGATE_SPECIAL_FUNCTION_AMBIGUITY" to IssueInfo("25-5053082", 64665),
+    "JS_MODULE_PROHIBITED_ON_NON_NATIVE" to IssueInfo("25-5053083", 64666),
     //<::>knownDisappearedDiagnostics
 )
 
@@ -625,6 +631,18 @@
     "JSCODE_ARGUMENT_NON_CONST_EXPRESSION" to IssueInfo("25-4912722", 63199),
     "JSCODE_CAN_NOT_VERIFY_JAVASCRIPT" to IssueInfo("25-4912723", 63200),
     "JSCODE_WARNING" to IssueInfo("25-4912724", 63201),
+    "ANONYMOUS_SUSPEND_FUNCTION" to IssueInfo("25-5053085", 64667),
+    "TYPE_PARAMETER_IS_NOT_AN_EXPRESSION" to IssueInfo("25-5053086", 64668),
+    "NEW_INFERENCE_ERROR" to IssueInfo("25-5053087", 64669),
+    "MANY_IMPL_MEMBER_NOT_IMPLEMENTED" to IssueInfo("25-5053088", 64670),
+    "MISSING_DEPENDENCY_CLASS" to IssueInfo("25-5053089", 64671),
+    "EXPECT_ACTUAL_INCOMPATIBILITY" to IssueInfo("25-5053090", 64672),
+    "ACTUAL_MISSING" to IssueInfo("25-5053091", 64673),
+    "EXPECT_ACTUAL_MISMATCH" to IssueInfo("25-5053092", 64674),
+    "DYNAMIC_RECEIVER_EXPECTED_BUT_WAS_NON_DYNAMIC" to IssueInfo("25-5053093", 64675),
+    "OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION" to IssueInfo("25-5053094", 64676),
+    "INCOMPATIBLE_OBJC_NAME_OVERRIDE" to IssueInfo("25-5053095", 64677),
+    "JS_MODULE_PROHIBITED_ON_NON_EXTERNAL" to IssueInfo("25-5053096", 64678),
     //<::>knownIntroducedDiagnostics
 )
 

compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyNestedScope.kt

diff --git a/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyNestedScope.kt b/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyNestedScope.kt
new file mode 100644
index 0000000..2ccd315
--- /dev/null
+++ b/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyNestedScope.kt
@@ -0,0 +1,595 @@
+// ORIGINAL: /compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.fir.kt
+// WITH_STDLIB
+class Context {
+
+    enum class EnumerationAAA() {
+        ENTRY
+    }
+
+    enum class EnumerationAAB() {
+        ENTRY;
+    }
+
+    enum class EnumerationAAC() {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationAAD() {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationAAE() {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationABA(arg: UserKlass = UserKlass()) {
+        ENTRY
+    }
+
+    enum class EnumerationABB(arg: UserKlass = UserKlass()) {
+        ENTRY;
+    }
+
+    enum class EnumerationABC(arg: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationABD(arg: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationABE(arg: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationACA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY
+    }
+
+    enum class EnumerationACB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+    }
+
+    enum class EnumerationACC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationACD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationACE(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationADA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationAEA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAEB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAEC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAED(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationBAA constructor() {
+        ENTRY
+    }
+
+    enum class EnumerationBAB constructor() {
+        ENTRY;
+    }
+
+    enum class EnumerationBAC constructor() {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationBAD constructor() {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationBAE constructor() {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationBBA constructor(arg: UserKlass = UserKlass()) {
+        ENTRY
+    }
+
+    enum class EnumerationBBB constructor(arg: UserKlass = UserKlass()) {
+        ENTRY;
+    }
+
+    enum class EnumerationBBC constructor(arg: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationBBD constructor(arg: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationBBE constructor(arg: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationBCA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY
+    }
+
+    enum class EnumerationBCB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+    }
+
+    enum class EnumerationBCC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationBCD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationBCE constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationBDA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationBEA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBEB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBEC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBED constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationCAA {
+        ENTRY;
+
+        constructor()
+    }
+
+    enum class EnumerationCAB {
+        ENTRY1,
+        ENTRY2;
+
+        constructor()
+    }
+
+    enum class EnumerationCAC {
+        ENTRY1,
+        ENTRY2();
+
+        constructor()
+    }
+
+    enum class EnumerationCAD {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor()
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationCBA {
+        ENTRY;
+
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCBB {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCBC {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCBD {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg: UserKlass = UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationCCA {
+        ENTRY;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCCB {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCCC {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCCD {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationCDA {
+        ENTRY;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDB {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDC {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDD {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationCEA {
+        ENTRY;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCEB {
+        ENTRY1,
+        ENTRY2;
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCEC {
+        ENTRY1,
+        ENTRY2();
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCED {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+
+        abstract fun abstractFunc()
+    }
+
+    enum class EnumerationDA {
+        ENTRY
+    }
+
+    enum class EnumerationDB {
+        ENTRY;
+    }
+
+    enum class EnumerationDC {
+        ENTRY1,
+        ENTRY2;
+    }
+
+    enum class EnumerationDD {
+        ENTRY1,
+        ENTRY2();
+    }
+
+    enum class EnumerationDE {
+        ENTRY1 {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        },
+        ENTRY2() {
+            override fun abstractFunc() {
+                TODO("Not yet implemented")
+            }
+        };
+
+        abstract fun abstractFunc()
+    }
+
+}
+
+
+class UserKlass
+
+
+fun box() = "OK"

compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyTopLevel.kt

diff --git a/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyTopLevel.kt b/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyTopLevel.kt
new file mode 100644
index 0000000..f3bdb573
--- /dev/null
+++ b/compiler/testData/codegen/box/k2DifferencesChecks/EnumWOParenthesesConsistencyTopLevel.kt
@@ -0,0 +1,411 @@
+// ORIGINAL: /compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.fir.kt
+// WITH_STDLIB
+enum class EnumerationAAA() {
+    ENTRY
+}
+
+enum class EnumerationAAB() {
+    ENTRY;
+}
+
+enum class EnumerationAAC() {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationAAD() {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationAAE() {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationABA(arg: UserKlass = UserKlass()) {
+    ENTRY
+}
+
+enum class EnumerationABB(arg: UserKlass = UserKlass()) {
+    ENTRY;
+}
+
+enum class EnumerationABC(arg: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationABD(arg: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationABE(arg: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationACA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY
+}
+
+enum class EnumerationACB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+}
+
+enum class EnumerationACC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationACD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationACE(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationADA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationAEA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAEB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAEC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAED(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationBAA constructor() {
+    ENTRY
+}
+
+enum class EnumerationBAB constructor() {
+    ENTRY;
+}
+
+enum class EnumerationBAC constructor() {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationBAD constructor() {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationBAE constructor() {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationBBA constructor(arg: UserKlass = UserKlass()) {
+    ENTRY
+}
+
+enum class EnumerationBBB constructor(arg: UserKlass = UserKlass()) {
+    ENTRY;
+}
+
+enum class EnumerationBBC constructor(arg: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationBBD constructor(arg: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationBBE constructor(arg: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationBCA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY
+}
+
+enum class EnumerationBCB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+}
+
+enum class EnumerationBCC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationBCD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationBCE constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationBDA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationBEA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBEB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBEC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBED constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationCAA {
+    ENTRY;
+    constructor()
+}
+
+enum class EnumerationCAB {
+    ENTRY1,
+    ENTRY2;
+    constructor()
+}
+
+enum class EnumerationCAC {
+    ENTRY1,
+    ENTRY2();
+    constructor()
+}
+
+enum class EnumerationCAD {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor()
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationCBA {
+    ENTRY;
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCBB {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCBC {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCBD {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg: UserKlass = UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationCCA {
+    ENTRY;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+}
+
+enum class EnumerationCCB {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+}
+
+enum class EnumerationCCC {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+}
+
+enum class EnumerationCCD {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationCDA {
+    ENTRY;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDB {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDC {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDD {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationCEA {
+    ENTRY;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCEB {
+    ENTRY1,
+    ENTRY2;
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCEC {
+    ENTRY1,
+    ENTRY2();
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCED {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+    abstract fun abstractFunc()
+}
+
+enum class EnumerationDA {
+    ENTRY
+}
+
+enum class EnumerationDB {
+    ENTRY;
+}
+
+enum class EnumerationDC {
+    ENTRY1,
+    ENTRY2;
+}
+
+enum class EnumerationDD {
+    ENTRY1,
+    ENTRY2();
+}
+
+enum class EnumerationDE {
+    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
+    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
+    abstract fun abstractFunc()
+}
+
+
+class UserKlass
+
+
+fun box() = "OK"