[tests] Add code examples from exploration of KT-62239

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java

@@ -11620,6 +11620,18 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia
                 runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt");
             }
 
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyNestedScope.kt")
+            public void testEnumWOParenthesesConsistencyNestedScope() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt");
+            }
+
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyTopLevel.kt")
+            public void testEnumWOParenthesesConsistencyTopLevel() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt");
+            }
+
             @Test
             @TestMetadata("enumWithAnnotationKeyword.kt")
             public void testEnumWithAnnotationKeyword() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java

@@ -11620,6 +11620,18 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated
                 runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt");
             }
 
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyNestedScope.kt")
+            public void testEnumWOParenthesesConsistencyNestedScope() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt");
+            }
+
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyTopLevel.kt")
+            public void testEnumWOParenthesesConsistencyTopLevel() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt");
+            }
+
             @Test
             @TestMetadata("enumWithAnnotationKeyword.kt")
             public void testEnumWithAnnotationKeyword() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java

@@ -11614,6 +11614,18 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir
                 runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt");
             }
 
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyNestedScope.kt")
+            public void testEnumWOParenthesesConsistencyNestedScope() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt");
+            }
+
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyTopLevel.kt")
+            public void testEnumWOParenthesesConsistencyTopLevel() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt");
+            }
+
             @Test
             @TestMetadata("enumWithAnnotationKeyword.kt")
             public void testEnumWithAnnotationKeyword() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java

@@ -11620,6 +11620,18 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia
                 runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt");
             }
 
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyNestedScope.kt")
+            public void testEnumWOParenthesesConsistencyNestedScope() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt");
+            }
+
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyTopLevel.kt")
+            public void testEnumWOParenthesesConsistencyTopLevel() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt");
+            }
+
             @Test
             @TestMetadata("enumWithAnnotationKeyword.kt")
             public void testEnumWithAnnotationKeyword() throws Exception {

compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.fir.kt

@@ -0,0 +1,590 @@
+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

compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt

@@ -0,0 +1,590 @@
+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()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationADD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAEB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAEC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationAED(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    }
+
+    enum class EnumerationBDD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBEB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBEC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+        constructor() : this(UserKlass(), UserKlass())
+    }
+
+    enum class EnumerationBED constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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 {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDB {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDC {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+    }
+
+    enum class EnumerationCDD {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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 {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCEB {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCEC {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+        ENTRY2();
+
+        constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+        constructor(arg: UserKlass = UserKlass())
+        constructor()
+    }
+
+    enum class EnumerationCED {
+        <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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

compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.fir.kt

@@ -0,0 +1,406 @@
+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

compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt

@@ -0,0 +1,406 @@
+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()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationADD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAEB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAEC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationAED(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+}
+
+enum class EnumerationBDD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBEB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBEC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
+    constructor() : this(UserKlass(), UserKlass())
+}
+
+enum class EnumerationBED constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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 {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDB {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDC {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+}
+
+enum class EnumerationCDD {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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 {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCEB {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCEC {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
+    ENTRY2();
+    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
+    constructor(arg: UserKlass = UserKlass())
+    constructor()
+}
+
+enum class EnumerationCED {
+    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>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

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -11620,6 +11620,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                 runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt");
             }
 
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyNestedScope.kt")
+            public void testEnumWOParenthesesConsistencyNestedScope() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt");
+            }
+
+            @Test
+            @TestMetadata("EnumWOParenthesesConsistencyTopLevel.kt")
+            public void testEnumWOParenthesesConsistencyTopLevel() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt");
+            }
+
             @Test
             @TestMetadata("enumWithAnnotationKeyword.kt")
             public void testEnumWithAnnotationKeyword() throws Exception {