diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t01.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t01.dart
index 8e46098..e5749f0 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t01.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t01.dart
@@ -9,42 +9,12 @@
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
 ///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
 ///
 /// @description Check that it’s a compile-time error if a non-abstract class
 /// implements Enum and it is not the implicit class of an enum declaration.
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t02.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t02.dart
index 3420b15..f238e02 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t02.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t02.dart
@@ -9,42 +9,12 @@
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
 ///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
 ///
 /// @description Check that abstract classes may implement enum
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t03.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t03.dart
index d29c4dc..841254d 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t03.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t03.dart
@@ -9,42 +9,12 @@
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
 ///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
 ///
 /// @description Check that implicit class of enum declaration implements Enum
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t04.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t04.dart
new file mode 100644
index 0000000..8f83cdc
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t04.dart
@@ -0,0 +1,49 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+///
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
+///
+/// @description Check that it’s a compile-time error if a non-abstract class
+/// implements Enum transitively and it is not the implicit class of an enum
+/// declaration.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class A implements Enum {
+  int foo();
+}
+
+class C1 implements A {
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  int get index => 42;
+  int foo() => 42;
+}
+
+class C2 extends A {
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  int get index => 42;
+  int foo() => 42;
+}
+
+main() {
+  print(C1);
+  print(C2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t05.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t05.dart
new file mode 100644
index 0000000..c6d9497
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t05.dart
@@ -0,0 +1,50 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+///
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
+///
+/// @description Check that mixins implementing Enum are allowed, if they are
+/// used by enum declarations
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class M1 with Enum {}
+
+abstract class M2 = Object with Enum;
+
+mixin M3 implements Enum {}
+
+enum E1 implements M1 {
+  e1,
+  e2;
+}
+
+enum E2 implements M2 {
+  e1,
+  e2;
+}
+
+enum E3 with M3 {
+  e1,
+  e2;
+}
+
+main() {
+  print(E1);
+  print(E2);
+  print(E3);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t06.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t06.dart
new file mode 100644
index 0000000..62985e4
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t06.dart
@@ -0,0 +1,56 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+///
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
+///
+/// @description Check that it is a compile-time error if mixins implementing
+/// Enum are used not by enum declarations
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class M1 with Enum {}
+
+abstract class M2 = Object with Enum;
+
+mixin M3 implements Enum {}
+
+class C1 implements M1 {
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  int get index => 1;
+}
+
+class C2 implements M2 {
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified;
+  int get index => 2;
+}
+
+class C3 with M3 {
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  int get index => 3;
+}
+
+main() {
+  print(C1);
+  print(C2);
+  print(C3);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t07.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t07.dart
new file mode 100644
index 0000000..a9dbe66
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A01_t07.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+///
+/// It's a compile-time error if a concrete class has Enum as a superinterface
+/// (directly or transitively) unless it is the corresponding class of an enum
+/// declaration. (Abstract interfaces and mixins implementing Enum are allowed,
+/// but only so that they can be used by enum declarations, they can never be
+/// used to create an instance which implements Enum, but which is not an enum
+/// value.)
+///
+/// @description Check that it is a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+
+class C1 implements Enum {
+//                  ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+class C2 extends Enum {
+//               ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified;
+}
+
+class C3 with Enum {
+//            ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C1);
+  print(C2);
+  print(C3);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t01.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t01.dart
index 3339f5d..33e300c 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t01.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t01.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class extends
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t02.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t02.dart
index 21b6ab4..80407c2 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t02.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t02.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class extends
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t03.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t03.dart
index 3cb2a68..31f56d3 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t03.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t03.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class implements
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t04.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t04.dart
index c509267..6f1beb5 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t04.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t04.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class implements
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t05.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t05.dart
index 8cc67e6..953e9bb 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t05.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t05.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class mixes-in
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t06.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t06.dart
index 64c4a8c..d009250 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t06.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A02_t06.dart
@@ -8,44 +8,12 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
+/// ...
 /// It is a compile-time error if a class implements, extends or mixes-in the
 /// class or interface introduced by an enum declaration. (An enum class can’t
 /// be used as a mixin since it is not a mixin declaration and the class has a
 /// superclass other than Object, but we include “mixes-in” for completeness.)
 ///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
 /// @description Check that it is a compile-time error if a class mixes-in
 /// a class declared by an enum declaration.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t01.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t01.dart
index 969fc9c..d53a2ba 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t01.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t01.dart
@@ -8,47 +8,19 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values
+/// member with the name `values`
 /// @author sgrekhov@unipro.ru
 
 // SharedOptions=--enable-experiment=enhanced-enums
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t02.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t02.dart
index 6b111bd..c278ddb 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t02.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t02.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t03.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t03.dart
index 8d1f471..875924c 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t03.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t03.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t04.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t04.dart
index 19ea864..e27a2ef 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t04.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t04.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t05.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t05.dart
index 83d91e8..b6fad65 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t05.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t05.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a mixin has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t06.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t06.dart
index df33302..071c3cf 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t06.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t06.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a mixin has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t07.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t07.dart
index c08754c..c981f34 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t07.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t07.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a mixin has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t08.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t08.dart
index 2d1efa6..a935c76 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t08.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t08.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a mixin has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t09.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t09.dart
index 0a1f9cf..f04feae 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t09.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t09.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t10.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t10.dart
index b81cb53..e9d0529 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t10.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t10.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t11.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t11.dart
index 99b0a4a..2a20a37 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t11.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t11.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t12.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t12.dart
index 48d874f..5fd4563 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t12.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t12.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t13.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t13.dart
index b57d721..5a50336 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t13.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t13.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t14.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t14.dart
index f9f671b..714e987 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t14.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t14.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t15.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t15.dart
index 80482a1..4351808 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t15.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t15.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t16.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t16.dart
index e40e935..9e0f979 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t16.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A03_t16.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
-/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// ...
+/// It's a compile-time error if a class or mixin declaration has `Enum` as a
 /// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// member with the name `values`, whether declared or inherited. If any
+/// concrete class implements this interface, it will be an enum declaration
+/// class, and then the `values` member would conflict with the static `values`
+/// constant getter that is automatically added to enum declaration classes.
+/// Such an instance `values` declaration is either useless or wrong, so we
+/// disallow it entirely.
 ///
 /// @description Check that it's a compile-time error if a class has Enum as a
 /// superinterface and the interface of the declarations contains an instance
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t01.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t01.dart
index 13802ea..8bbdd9a 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t01.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t01.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a class declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t02.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t02.dart
index b06b500..4654d1c 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t02.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t02.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a class declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t03.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t03.dart
index 337965b..b2c5643 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t03.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t03.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a class declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t04.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t04.dart
index 34cf5e6..25a29b3 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t04.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t04.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a class declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t05.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t05.dart
index 56b8b96..0d15992 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t05.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t05.dart
@@ -8,45 +8,17 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
-/// @description Check that it's a compile-time error if a enum declaration has
+/// @description Check that it's a compile-time error if an enum declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
 /// named `index`.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t06.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t06.dart
index 9abe3e5..ba8e45c 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t06.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t06.dart
@@ -8,45 +8,17 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
-/// @description Check that it's a compile-time error if a enum declaration has
+/// @description Check that it's a compile-time error if an enum declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
 /// named `index`.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t07.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t07.dart
index 958caf1..d8e26ca 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t07.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t07.dart
@@ -8,45 +8,17 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
-/// @description Check that it's a compile-time error if a enum declaration has
+/// @description Check that it's a compile-time error if an enum declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
 /// named `index`.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t08.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t08.dart
index 76491b0..fafbed3 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t08.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t08.dart
@@ -8,45 +8,17 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
-///
-/// @description Check that it's a compile-time error if a enum declaration has
+/// @description Check that it's a compile-time error if an enum declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
 /// named `index`.
 /// @author sgrekhov@unipro.ru
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t09.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t09.dart
index 7ad8ae2..a727933 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t09.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t09.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a mixin declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t10.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t10.dart
index eb144ad..7d5ccbc 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t10.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t10.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a mixin declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t11.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t11.dart
index 163554b..3dcb0b9 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t11.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t11.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a mixin declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t12.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t12.dart
index bc5f0b9..7e74fb4 100644
--- a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t12.dart
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t12.dart
@@ -8,43 +8,15 @@
 /// Because we want to allow interfaces and mixins that are intended to be
 /// applied to enum declarations, and therefore to assume Enum to be a
 /// superclass, we loosen that restriction to:
-///
-/// It's a compile-time error if a non-abstract class has Enum as a
-/// superinterface (directly or transitively) unless it is the corresponding
-/// class of an enum declaration.
-///
-/// It is a compile-time error if a class implements, extends or mixes-in the
-/// class or interface introduced by an enum declaration. (An enum class can’t
-/// be used as a mixin since it is not a mixin declaration and the class has a
-/// superclass other than Object, but we include “mixes-in” for completeness.)
-///
+/// ...
 /// It's a compile-time error if a class or mixin declaration has Enum as a
-/// superinterface and the interface of the declarations contains an instance
-/// member with the name values, whether declared or inherited. If any concrete
-/// class implements this interface, it will be an enum declaration class, and
-/// then the values member would conflict with the static values constant getter
-/// that is automatically added to enum declaration classes. Such an instance
-/// values declaration is either useless or wrong, so we disallow it entirely.
-///
-/// It's a compile-time error if a class, mixin or enum declaration has Enum as
-/// a superinterface, and it declares a non-abstract instance member named index.
-/// That member would override the index getter inherited from Enum, and we
-/// currently do not allow that.
-///
-/// Those restrictions allows abstract classes (interfaces) which implements
-/// Enum in order to have the int index; getter member available, and it allows
-/// mixin declarations to use Enum as an on type because mixin declarations
-/// cannot be instantiated directly.
-///
-/// The restrictions still ensure enum values are the only object instances
-/// which implements Enum, while making it valid to declare abstract class
-/// MyInterface implements Enum and mixin MyMixin on Enum for interfaces and
-/// mixins intended to be used in declaring enum classes. It's also impossible
-/// to override or prevent the instance index and static values members without
-/// causing a compile-time error. Say implementing an interface with
-/// `Never get index;` as a member, then because it's not possible to override
-/// `int get index;` from Enum, the resulting class does not implement its
-/// interface and is a compile-time error.
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
 ///
 /// @description Check that it's a compile-time error if a mixin declaration has
 /// Enum as a superinterface, and it declares a non-abstract instance member
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t13.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t13.dart
new file mode 100644
index 0000000..5edfca5
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t13.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a class declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class E1 extends Enum {
+  final int hashCode = 42;
+//          ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+abstract class E2 extends Enum {
+  final String hashCode = "42";
+//             ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t14.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t14.dart
new file mode 100644
index 0000000..4dc4461
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t14.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a class declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class E1 extends Enum {
+  int hashCode() => 42;
+//    ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+abstract class E2 extends Enum {
+  String hashCode() => "42";
+//       ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t15.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t15.dart
new file mode 100644
index 0000000..bbea12e
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t15.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a class declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class E1 extends Enum {
+  int get hashCode => 42;
+//        ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+abstract class E2 extends Enum {
+  int String hashCode => "42";
+//           ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t16.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t16.dart
new file mode 100644
index 0000000..b38dd70
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t16.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a class declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+abstract class E1 extends Enum {
+  void set hashCode(int val) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+abstract class E2 extends Enum {
+  void set hashCode(String val) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t17.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t17.dart
new file mode 100644
index 0000000..bfc5c29
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t17.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if an enum declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+enum E1 {
+  e1,
+  e2;
+
+  final int hashCode = 42;
+//          ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E2 {
+  e1(42),
+  e2(0);
+
+  const E2(int i);
+  final String hashCode = "";
+//             ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t18.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t18.dart
new file mode 100644
index 0000000..0836813
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t18.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if an enum declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+enum E1 {
+  e1,
+  e2;
+
+  int hashCode() => 42;
+//    ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E2 {
+  e1(42),
+  e2(0);
+
+  const E2(int i);
+  String hashCode() => "";
+//       ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t19.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t19.dart
new file mode 100644
index 0000000..3a260a4
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t19.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if an enum declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+enum E1 {
+  e1,
+  e2;
+
+  int get hashCode => 42;
+//        ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E2 {
+  e1(42),
+  e2(0);
+
+  const E2(int i);
+  String get hashCode => "";
+//           ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t20.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t20.dart
new file mode 100644
index 0000000..af08deb
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t20.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if an enum declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+enum E1 {
+  e1,
+  e2;
+
+  void set hashCode(int val) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E2 {
+  e1(42),
+  e2(0);
+
+  const E2(int i);
+  void set hashCode(String val) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t21.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t21.dart
new file mode 100644
index 0000000..262087f
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t21.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a mixin declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+mixin M1 on Enum {
+  final int hashCode = 42;
+//          ^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M2 on Enum {
+  final String hashCode = "";
+//             ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(M1);
+  print(M2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t22.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t22.dart
new file mode 100644
index 0000000..286d5c2
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t22.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a mixin declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+mixin M1 on Enum {
+  int hashCode() => 42;
+//    ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M2 on Enum {
+  String hashCode() => "";
+//       ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(M1);
+  print(M2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t23.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t23.dart
new file mode 100644
index 0000000..d5b27fc
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t23.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a mixin declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+mixin M1 on Enum {
+  int get hashCode => 42;
+//        ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M2 on Enum {
+  String get hashCode => "";
+//           ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(M1);
+  print(M2);
+}
diff --git a/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t24.dart b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t24.dart
new file mode 100644
index 0000000..6932088
--- /dev/null
+++ b/LanguageFeatures/Enhanced-Enum/implementing_enum_A04_t24.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion It’s currently a compile-time error for a class to implement,
+/// extend or mix-in the Enum class.
+///
+/// Because we want to allow interfaces and mixins that are intended to be
+/// applied to enum declarations, and therefore to assume Enum to be a
+/// superclass, we loosen that restriction to:
+/// ...
+/// It's a compile-time error if a class or mixin declaration has Enum as a
+/// superinterface, and that class or mixin declares or inherits a concrete
+/// instance member named `index`, `hashCode` or `==` (an `operator ==`
+/// declaration). That `index` member could override the `index` getter
+/// inherited from `Enum`, and we currently do not allow that. The `hashCode`
+/// and `operator ==` declarations would prevent the enum class from having
+/// "primitive equality", and we want to ensure that enums can be used in
+/// switches.
+///
+/// @description Check that it's a compile-time error if a mixin declaration has
+/// Enum as a superinterface, and it declares a non-abstract instance member
+/// named `hashCode`.
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=enhanced-enums
+
+mixin M1 on Enum {
+  void set hashCode(int v) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M2 on Enum {
+  void set hashCode(String val) {}
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(M1);
+  print(M2);
+}