Version 2.17.0-27.0.dev

Merge commit 'df0f4761773fba9b21ff47ad3863145f73fa366e' into 'dev'

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -2806,6 +2806,30 @@ const MessageCode messageEnumInstantiation = const MessageCode(
     analyzerCodes: <String>["INSTANTIATE_ENUM"],
     problemMessage: r"""Enums can't be instantiated.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<Message Function(String name)>
+    templateEnumSupertypeOfNonAbstractClass =
+    const Template<Message Function(String name)>(
+        problemMessageTemplate:
+            r"""Non-abstract class '#name' has 'Enum' as a superinterface.""",
+        withArguments: _withArgumentsEnumSupertypeOfNonAbstractClass);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)> codeEnumSupertypeOfNonAbstractClass =
+    const Code<Message Function(String name)>(
+  "EnumSupertypeOfNonAbstractClass",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsEnumSupertypeOfNonAbstractClass(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeEnumSupertypeOfNonAbstractClass,
+      problemMessage:
+          """Non-abstract class '${name}' has 'Enum' as a superinterface.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeEqualityCannotBeEqualityOperand =
     messageEqualityCannotBeEqualityOperand;

pkg/front_end/lib/src/fasta/denylisted_classes.dart

@@ -8,7 +8,6 @@ const List<String> denylistedCoreClasses = [
   "int",
   "num",
   "double",
-  "Enum",
   "String",
   "Null"
 ];

pkg/front_end/lib/src/fasta/source/source_loader.dart

@@ -1648,6 +1648,8 @@ severity: $severity
           denylistedCoreClasses[i],
           required: true) as ClassBuilder);
     }
+    ClassBuilder enumClass =
+        coreLibrary.lookupLocalMember("Enum", required: true) as ClassBuilder;
     if (typedDataLibrary != null) {
       for (int i = 0; i < denylistedTypedDataClasses.length; i++) {
         // Allow the member to not exist. If it doesn't, nobody can extend it.
@@ -1664,8 +1666,8 @@ severity: $severity
         topologicalSort(classGraph);
     List<SourceClassBuilder> classes = result.sortedVertices;
     for (SourceClassBuilder cls in classes) {
-      checkClassSupertypes(
-          cls, classGraph.directSupertypeMap[cls]!, denyListedClasses);
+      checkClassSupertypes(cls, classGraph.directSupertypeMap[cls]!,
+          denyListedClasses, enumClass);
     }
 
     List<SourceClassBuilder> classesWithCycles = result.cyclicVertices;
@@ -1708,10 +1710,30 @@ severity: $severity
     }
   }
 
+  bool checkEnumSupertypeIsDenylisted(SourceClassBuilder cls) {
+    if (!cls.library.enableEnhancedEnumsInLibrary) {
+      cls.addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              cls.library.enableEnhancedEnumsVersionInLibrary.toText()),
+          cls.charOffset,
+          noLength);
+      return true;
+    } else {
+      if (!cls.isAbstract) {
+        cls.addProblem(
+            templateEnumSupertypeOfNonAbstractClass.withArguments(cls.name),
+            cls.charOffset,
+            noLength);
+      }
+      return false;
+    }
+  }
+
   void checkClassSupertypes(
       SourceClassBuilder cls,
       Map<TypeDeclarationBuilder?, TypeAliasBuilder?> directSupertypeMap,
-      Set<ClassBuilder> denyListedClasses) {
+      Set<ClassBuilder> denyListedClasses,
+      ClassBuilder enumClass) {
     // Check that the direct supertypes aren't deny-listed or enums.
     List<TypeDeclarationBuilder?> directSupertypes =
         directSupertypeMap.keys.toList();
@@ -1721,7 +1743,9 @@ severity: $severity
         cls.addProblem(templateExtendingEnum.withArguments(supertype.name),
             cls.charOffset, noLength);
       } else if (!cls.library.mayImplementRestrictedTypes &&
-          denyListedClasses.contains(supertype)) {
+          (denyListedClasses.contains(supertype) ||
+              identical(supertype, enumClass) &&
+                  checkEnumSupertypeIsDenylisted(cls))) {
         TypeAliasBuilder? aliasBuilder = directSupertypeMap[supertype];
         if (aliasBuilder != null) {
           cls.addProblem(

pkg/front_end/messages.status

@@ -218,6 +218,8 @@ EnumDeclaresConstFactory/example: Fail
 EnumDeclaresFactory/analyzerCode: Fail
 EnumDeclaresFactory/example: Fail
 EnumInstantiation/example: Fail
+EnumSupertypeOfNonAbstractClass/analyzerCode: Fail
+EnumSupertypeOfNonAbstractClass/example: Fail
 EqualityCannotBeEqualityOperand/part_wrapped_script1: Fail
 EqualityCannotBeEqualityOperand/part_wrapped_script2: Fail
 EqualityCannotBeEqualityOperand/script1: Fail

pkg/front_end/messages.yaml

@@ -5455,3 +5455,6 @@ PositionalSuperParametersAndArguments:
 SuperInitializerParameter:
   problemMessage: "This is the super-initializer parameter."
   severity: CONTEXT
+
+EnumSupertypeOfNonAbstractClass:
+  problemMessage: "Non-abstract class '#name' has 'Enum' as a superinterface."

pkg/front_end/test/spell_checking_list_messages.txt

@@ -75,6 +75,7 @@ stringokempty
 struct<#name
 structs
 super.namedconstructor
+superinterface
 supermixin
 team
 this.namedconstructor

pkg/front_end/test/spell_checking_list_tests.txt

@@ -321,7 +321,9 @@ dw
 dyn
 e's
 e2e
+ea
 ease
+eb
 ec
 echo
 edits

pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart

@@ -0,0 +1,40 @@
+// 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.
+
+abstract class A extends Enum { // Ok.
+  int get foo => index;
+}
+
+enum EA with A { element }
+
+abstract class B implements Enum { // Ok.
+  int get foo => index;
+}
+
+enum EB with B { element }
+
+mixin M on Enum { // Ok.
+  int get foo => index;
+}
+
+enum EM with M { element }
+
+mixin N implements Enum { // Ok.
+  int get foo => index;
+}
+
+enum EN with N { element }
+
+expectEquals(x, y) {
+  if (x != y) {
+    throw "Expected '$x' to be equal to '$y'.";
+  }
+}
+
+main() {
+  expectEquals(EA.element.foo, EA.element.index);
+  expectEquals(EB.element.foo, EB.element.index);
+  expectEquals(EM.element.foo, EM.element.index);
+  expectEquals(EN.element.foo, EN.element.index);
+}

pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.strong.expect

@@ -0,0 +1,128 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Enum {
+  synthetic constructor •() → self::A
+    : super core::Enum::•()
+    ;
+  get foo() → core::int
+    return this.{core::Enum::index}{core::int};
+}
+abstract class _EA&_Enum&A = core::_Enum with self::A /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EA&_Enum&A
+    : super core::_Enum::•(index, _name)
+    ;
+  mixin-super-stub get foo() → core::int
+    return super.{self::A::foo};
+}
+class EA extends self::_EA&_Enum&A /*isEnum*/  {
+  static const field core::List<self::EA> values = #C4;
+  static const field self::EA element = #C3;
+  const constructor •(core::int index, core::String name) → self::EA
+    : super self::_EA&_Enum&A::•(index, name)
+    ;
+  method toString() → core::String
+    ;
+}
+abstract class B extends core::Object implements core::Enum {
+  synthetic constructor •() → self::B
+    : super core::Object::•()
+    ;
+  get foo() → core::int
+    return this.{core::Enum::index}{core::int};
+}
+abstract class _EB&_Enum&B = core::_Enum with self::B /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EB&_Enum&B
+    : super core::_Enum::•(index, _name)
+    ;
+  mixin-super-stub get foo() → core::int
+    return super.{self::B::foo};
+}
+class EB extends self::_EB&_Enum&B /*isEnum*/  {
+  static const field core::List<self::EB> values = #C6;
+  static const field self::EB element = #C5;
+  const constructor •(core::int index, core::String name) → self::EB
+    : super self::_EB&_Enum&B::•(index, name)
+    ;
+  method toString() → core::String
+    ;
+}
+abstract class M extends core::Enum /*isMixinDeclaration*/  {
+  get foo() → core::int
+    return this.{core::Enum::index}{core::int};
+}
+abstract class _EM&_Enum&M = core::_Enum with self::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EM&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+  mixin-super-stub get foo() → core::int
+    return super.{self::M::foo};
+}
+class EM extends self::_EM&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EM> values = #C8;
+  static const field self::EM element = #C7;
+  const constructor •(core::int index, core::String name) → self::EM
+    : super self::_EM&_Enum&M::•(index, name)
+    ;
+  method toString() → core::String
+    ;
+}
+abstract class N extends core::Object implements core::Enum /*isMixinDeclaration*/  {
+  get foo() → core::int
+    return this.{core::Enum::index}{core::int};
+}
+abstract class _EN&_Enum&N = core::_Enum with self::N /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EN&_Enum&N
+    : super core::_Enum::•(index, _name)
+    ;
+  mixin-super-stub get foo() → core::int
+    return super.{self::N::foo};
+}
+class EN extends self::_EN&_Enum&N /*isEnum*/  {
+  static const field core::List<self::EN> values = #C10;
+  static const field self::EN element = #C9;
+  const constructor •(core::int index, core::String name) → self::EN
+    : super self::_EN&_Enum&N::•(index, name)
+    ;
+  method toString() → core::String
+    ;
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(#C3.{self::_EA&_Enum&A::foo}{core::int}, #C3.{core::_Enum::index}{core::int});
+  self::expectEquals(#C5.{self::_EB&_Enum&B::foo}{core::int}, #C5.{core::_Enum::index}{core::int});
+  self::expectEquals(#C7.{self::_EM&_Enum&M::foo}{core::int}, #C7.{core::_Enum::index}{core::int});
+  self::expectEquals(#C9.{self::_EN&_Enum&N::foo}{core::int}, #C9.{core::_Enum::index}{core::int});
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "element"
+  #C3 = self::EA {index:#C1, _name:#C2}
+  #C4 = <self::EA>[#C3]
+  #C5 = self::EB {index:#C1, _name:#C2}
+  #C6 = <self::EB>[#C5]
+  #C7 = self::EM {index:#C1, _name:#C2}
+  #C8 = <self::EM>[#C7]
+  #C9 = self::EN {index:#C1, _name:#C2}
+  #C10 = <self::EN>[#C9]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///enum_as_supertype.dart:
+- EA. (from org-dartlang-testcase:///enum_as_supertype.dart:9:6)
+- _EA&_Enum&A. (from org-dartlang-testcase:///enum_as_supertype.dart:9:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- EB. (from org-dartlang-testcase:///enum_as_supertype.dart:15:6)
+- _EB&_Enum&B. (from org-dartlang-testcase:///enum_as_supertype.dart:15:6)
+- EM. (from org-dartlang-testcase:///enum_as_supertype.dart:21:6)
+- _EM&_Enum&M. (from org-dartlang-testcase:///enum_as_supertype.dart:21:6)
+- EN. (from org-dartlang-testcase:///enum_as_supertype.dart:27:6)
+- _EN&_Enum&N. (from org-dartlang-testcase:///enum_as_supertype.dart:27:6)