From 73aaa1ce288eee4bb21415f7721ad03155bea427 Mon Sep 17 00:00:00 2001
From: Stanislav Ruban <stanislav.ruban@jetbrains.com>
Date: Mon, 13 Nov 2023 19:55:29 +0200
Subject: [PATCH] [tests] Add code examples from exploration of KT-62239

---
 ...CompilerTestFE10TestdataTestGenerated.java |  12 +
 ...sticCompilerFE10TestDataTestGenerated.java |  12 +
 ...eeOldFrontendDiagnosticsTestGenerated.java |  12 +
 ...siOldFrontendDiagnosticsTestGenerated.java |  12 +
 ...WOParenthesesConsistencyNestedScope.fir.kt | 590 ++++++++++++++++++
 ...EnumWOParenthesesConsistencyNestedScope.kt | 590 ++++++++++++++++++
 ...numWOParenthesesConsistencyTopLevel.fir.kt | 406 ++++++++++++
 .../EnumWOParenthesesConsistencyTopLevel.kt   | 406 ++++++++++++
 .../test/runners/DiagnosticTestGenerated.java |  12 +
 9 files changed, 2052 insertions(+)
 create mode 100644 compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.fir.kt
 create mode 100644 compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt
 create mode 100644 compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.fir.kt
 create mode 100644 compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt

diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java
index c7d368f361d..7d0aefaea2e 100644
--- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java
+++ b/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 {
diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java
index 15d15a6ffff..2161f7623df 100644
--- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java
+++ b/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 {
diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java
index c7f4e67c395..01c66c502ae 100644
--- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java
+++ b/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 {
diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java
index 4bfc83de546..94c464c44de 100644
--- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java
+++ b/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 {
diff --git a/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.fir.kt b/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.fir.kt
new file mode 100644
index 00000000000..cdd0211fd72
--- /dev/null
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt b/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyNestedScope.kt
new file mode 100644
index 00000000000..f470a974bfd
--- /dev/null
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.fir.kt b/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.fir.kt
new file mode 100644
index 00000000000..fe48ffabc66
--- /dev/null
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt b/compiler/testData/diagnostics/tests/enum/EnumWOParenthesesConsistencyTopLevel.kt
new file mode 100644
index 00000000000..e3924ab7860
--- /dev/null
+++ b/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
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java
index 4695a5cd1cc..1aba02a404a 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java
+++ b/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 {