Support enums in dart2js.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 4317 matching lines @@
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       element.setDefaultConstructor(constructor, compiler);
     }
     return element.computeType(compiler);
   }
 
+  @override
+  DartType visitEnum(Enum node) {
+    if (!compiler.enableEnums) {
+      compiler.reportError(node, MessageKind.EXPERIMENTAL_ENUMS);
+    }
+
+    invariant(node, element != null);
+    invariant(element, element.resolutionState == STATE_STARTED,
+        message: () => 'cyclic resolution of class $element');
+
+    InterfaceType type = element.computeType(compiler);
+    scope = new TypeDeclarationScope(scope, element);
+
+    // Setup the supertype for the element (if there is a cycle in the

[floitsch, 2014/11/10 16:08:32]

That comment should not be necessary.
Enums only have Object as superclass.

[Johnni Winther, 2014/11/11 08:23:37]

Reduced to setting the supertype to Object.

+    // class hierarchy, it has already been set to Object).
+    ClassElement superElement = registry.defaultSuperclass(element);
+    // Avoid making the superclass (usually Object) extend itself.

[floitsch, 2014/11/10 16:08:32]

ditto.

+    if (element != superElement) {

[floitsch, 2014/11/10 16:08:32]

These tests should just be replaced with an invariant that the superclass is
Object.

+      if (superElement == null) {
+        compiler.internalError(node,
+            "Cannot resolve default superclass for $element.");
+      } else {
+        superElement.ensureResolved(compiler);
+      }
+      element.supertype = superElement.computeType(compiler);
+    }
+
+    element.interfaces = const Link<DartType>();
+
+    calculateAllSupertypes(element);
+
+    InterfaceType enumType = element.computeType(compiler);
+
+    EnumCreator creator = new EnumCreator(compiler, element);
+    creator.createMembers();
+    return enumType;
+  }
+
   /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       compiler.reportError(mixinNode,
           MessageKind.CANNOT_MIXIN, {'type': mixinType});
     } else if (mixinType.isTypeVariable) {
       compiler.reportError(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
     } else if (mixinType.isMalformed) {
@@ skipping 346 matching lines @@
     if (node.superclass == null) {
       if (!identical(classElement, compiler.objectClass)) {
         loadSupertype(compiler.objectClass, node);
       }
     } else {
       node.superclass.accept(this);
     }
     visitNodeList(node.interfaces);
   }
 
+  void visitEnum(Enum node) {
+    loadSupertype(compiler.objectClass, node);
+  }
+
   void visitMixinApplication(MixinApplication node) {
     node.superclass.accept(this);
     visitNodeList(node.mixins);
   }
 
   void visitNamedMixinApplication(NamedMixinApplication node) {
     node.superclass.accept(this);
     visitNodeList(node.mixins);
     visitNodeList(node.interfaces);
   }
@@ skipping 331 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }