[K2/Diff] Rebase onto a fresher master
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",
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
)
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"
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"
