Support enums in dart2js.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 1432 matching lines @@
 class FunctionSignatureX implements FunctionSignature {
   final Link<Element> requiredParameters;
   final Link<Element> optionalParameters;
   final int requiredParameterCount;
   final int optionalParameterCount;
   final bool optionalParametersAreNamed;
   final List<Element> orderedOptionalParameters;
   final FunctionType type;
   final bool hasOptionalParameters;
 
-  FunctionSignatureX(this.requiredParameters,
-                     Link<Element> optionalParameters,
-                     this.requiredParameterCount,
-                     this.optionalParameterCount,
-                     this.optionalParametersAreNamed,
-                     this.orderedOptionalParameters,
-                     this.type)
+  FunctionSignatureX({this.requiredParameters: const Link<Element>(),
+                      this.requiredParameterCount: 0,
+                      Link<Element> optionalParameters: const Link<Element>(),
+                      this.optionalParameterCount: 0,
+                      this.optionalParametersAreNamed: false,
+                      this.orderedOptionalParameters: const <Element>[],
+                      this.type})
       : optionalParameters = optionalParameters,
         hasOptionalParameters = !optionalParameters.isEmpty;
 
   void forEachRequiredParameter(void function(Element parameter)) {
     for (Link<Element> link = requiredParameters;
          !link.isEmpty;
          link = link.tail) {
       function(link.head);
     }
   }
@@ skipping 241 matching lines @@
       : this.prefix = prefix,
         super("loadLibrary",
               ElementKind.FUNCTION,
               Modifiers.EMPTY,
               prefix, true);
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignature;
     compiler.withCurrentElement(this, () {
       DartType inner = new FunctionType(this);
-      functionSignatureCache = new FunctionSignatureX(const Link(),
-          const Link(), 0, 0, false, [], inner);
+      functionSignatureCache = new FunctionSignatureX(type: inner);
     });
     return functionSignatureCache;
   }
 
   bool get isClassMember => false;
 
   bool isForeign(Backend backend) => true;
 
   bool get isSynthesized => true;
 
@@ skipping 80 matching lines @@
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   FunctionSignature computeSignature(compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
     if (isDefaultConstructor) {
       return functionSignatureCache = new FunctionSignatureX(
-          const Link<Element>(), const Link<Element>(), 0, 0, false,
-          const <Element>[],
-          new FunctionType(this, enclosingClass.thisType));
+          type: new FunctionType(this, enclosingClass.thisType));
     }
     if (definingConstructor.isErroneous) {
       return functionSignatureCache =
           compiler.objectClass.localLookup('').computeSignature(compiler);
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     return functionSignatureCache =
         definingConstructor.computeSignature(compiler);
   }
@@ skipping 130 matching lines @@
       : supertypeLoadState = initialState,
         resolutionState = initialState,
         super(name, ElementKind.CLASS, enclosing);
 
   int get hashCode => id;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   bool get isUnnamedMixinApplication => false;
 
+  @override
+  bool get isEnumClass => false;
+
   InterfaceType computeType(Compiler compiler) {
     if (thisTypeCache == null) {
       computeThisAndRawType(compiler, computeTypeParameters(compiler));
     }
     return thisTypeCache;
   }
 
   void computeThisAndRawType(Compiler compiler, List<DartType> typeVariables) {
     if (thisTypeCache == null) {
       if (origin == null) {
@@ skipping 362 matching lines @@
   Link<Element> get localMembers {
     if (localMembersCache == null) {
       localMembersCache = localMembersReversed.reverse();
     }
     return localMembersCache;
   }
 
   ClassElementX(String name, Element enclosing, int id, int initialState)
       : super(name, enclosing, id, initialState);
 
-  ClassNode parseNode(Compiler compiler);
-
   bool get isMixinApplication => false;
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembersCache = null;
     localMembersReversed = localMembersReversed.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
@@ skipping 39 matching lines @@
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
+class EnumClassElementX extends ClassElementX {
+  final Enum node;
+
+  EnumClassElementX(String name, Element enclosing, int id, this.node)
+      : super(name, enclosing, id, STATE_NOT_STARTED);
+
+  @override
+  bool get hasNode => true;
+
+  @override
+  Token get position => node.name.token;
+
+  @override
+  bool get isEnumClass => true;
+
+  @override
+  Node parseNode(Compiler compiler) => node;
+
+  @override
+  accept(ElementVisitor visitor) => visitor.visitClassElement(this);
+
+  List<DartType> computeTypeParameters(Compiler compiler) => const <DartType>[];
+}
+
+class EnumConstructorElementX extends ConstructorElementX {
+  final FunctionExpression node;
+
+  EnumConstructorElementX(EnumClassElementX enumClass,
+                          Modifiers modifiers,
+                          this.node)
+      : super('', // Name.
+              ElementKind.GENERATIVE_CONSTRUCTOR,
+              modifiers,
+              enumClass);
+
+  @override
+  bool get hasNode => true;
+
+  @override
+  FunctionExpression parseNode(Compiler compiler) => node;
+}
+
+class EnumMethodElementX extends FunctionElementX {
+  final FunctionExpression node;
+
+  EnumMethodElementX(String name,
+                     EnumClassElementX enumClass,
+                     Modifiers modifiers,
+                     this.node)
+      : super(name,
+              ElementKind.FUNCTION,
+              modifiers,
+              enumClass,
+              false);
+
+  @override
+  bool get hasNode => true;
+
+  @override
+  FunctionExpression parseNode(Compiler compiler) => node;
+}
+
+class EnumFormalElementX extends InitializingFormalElementX {
+  EnumFormalElementX(ConstructorElement constructor,
+                     VariableDefinitions variables,
+                     Identifier identifier,
+                     EnumFieldElementX fieldElement)
+      : super(constructor, variables, identifier, null, fieldElement) {
+    typeCache = fieldElement.type;
+  }
+}
+
+class EnumFieldElementX extends FieldElementX {
+
+  EnumFieldElementX(Identifier name,
+                    EnumClassElementX enumClass,
+                    VariableList variableList,
+                    Node definition,
+                    [Expression initializer])
+      : super(name, enumClass, variableList) {
+    definitionsCache = new VariableDefinitions(null,
+        variableList.modifiers, new NodeList.singleton(definition));
+    initializerCache = initializer;
+  }
+}
+
 class MixinApplicationElementX extends BaseClassElementX
     implements MixinApplicationElement {
   final Node node;
   final Modifiers modifiers;
 
   Link<FunctionElement> constructors = new Link<FunctionElement>();
 
   InterfaceType mixinType;
 
   MixinApplicationElementX(String name, Element enclosing, int id,
@@ skipping 283 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }