Update enum encoding to latest spec.

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

 // Copyright (c) 2014, 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 dart2js.resolution.enum_creator;
 
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart';
 import '../scanner/scannerlib.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 // TODO(johnniwinther): Merge functionality with the `TreePrinter`.
 class AstBuilder {
   final Token position;
 
   AstBuilder(this.position);
 
   int get charOffset => position.charOffset;
 
-  final Modifiers finalModifiers =
-      new Modifiers.withFlags(null, Modifiers.FLAG_FINAL);
-  final Modifiers constModifiers =
-      new Modifiers.withFlags(null, Modifiers.FLAG_CONST);
-  final Modifiers staticConstModifiers =
-      new Modifiers.withFlags(null,
-          Modifiers.FLAG_STATIC | Modifiers.FLAG_CONST);
+  Modifiers modifiers({bool isConst: false,
+                       bool isFinal: false,
+                       bool isStatic: false}) {
+    List identifiers = [];
+    int flags = 0;
+    if (isConst) {
+      identifiers.add(identifier('const'));
+      flags |= Modifiers.FLAG_CONST;
+    }
+    if (isFinal) {
+      identifiers.add(identifier('final'));
+      flags |= Modifiers.FLAG_FINAL;
+    }
+    if (isStatic) {
+      identifiers.add(identifier('static'));
+      flags |= Modifiers.FLAG_STATIC;
+    }
+    return new Modifiers.withFlags(
+        new NodeList(null, linkedList(identifiers), null, ''),
+        flags);
+  }
 
   Token keywordToken(String text) {
     return new KeywordToken(Keyword.keywords[text], position.charOffset);
   }
 
   Token stringToken(String text) {
     return new StringToken.fromString(IDENTIFIER_INFO, text, charOffset);
   }
 
   Token symbolToken(PrecedenceInfo info) {
@@ skipping 88 matching lines @@
             new Send(identifier('this'), identifier(fieldName))));
   }
 
   NewExpression newExpression(String typeName,
                               NodeList arguments,
                               {bool isConst: false}) {
     return new NewExpression(keywordToken(isConst ? 'const' : 'new'),
         new Send(null, identifier(typeName), arguments));
   }
 
+  Send reference(Identifier identifier) {
+    return new Send(null, identifier);
+  }
+
+  Send indexGet(Expression receiver, Expression index) {
+    return new Send(receiver,
+                    new Operator(symbolToken(INDEX_INFO)),
+                    new NodeList.singleton(index));
+  }
+
+  LiteralMapEntry mapLiteralEntry(Expression key, Expression value) {
+    return new LiteralMapEntry(key, symbolToken(COLON_INFO), value);
+  }
+
+  LiteralMap mapLiteral(List<LiteralMapEntry> entries, {bool isConst: false}) {
+    return new LiteralMap(
+        null, // Type arguments.
+        new NodeList(symbolToken(OPEN_CURLY_BRACKET_INFO),
+                     linkedList(entries),
+                     symbolToken(CLOSE_CURLY_BRACKET_INFO),
+                     ','),
+        isConst ? keywordToken('const') : null);
+  }
 }
 
 class EnumCreator {
   final Compiler compiler;
   final EnumClassElementX enumClass;
 
   EnumCreator(this.compiler, this.enumClass);
 
   void createMembers() {
     Enum node = enumClass.node;
     InterfaceType enumType = enumClass.thisType;
     AstBuilder builder = new AstBuilder(enumClass.position);
 
     InterfaceType intType = compiler.intClass.computeType(compiler);
     InterfaceType stringType = compiler.stringClass.computeType(compiler);
 
     EnumFieldElementX addInstanceMember(String name, InterfaceType type) {
       Identifier identifier = builder.identifier(name);
-      VariableList variableList = new VariableList(builder.finalModifiers);
+      VariableList variableList =
+          new VariableList(builder.modifiers(isFinal: true));
       variableList.type = type;
       EnumFieldElementX variable = new EnumFieldElementX(
           identifier, enumClass, variableList, identifier);
       enumClass.addMember(variable, compiler);
       return variable;
     }
 
     EnumFieldElementX indexVariable = addInstanceMember('index', intType);
-    EnumFieldElementX nameVariable = addInstanceMember('_name', stringType);
 
     VariableDefinitions indexDefinition = builder.initializingFormal('index');
-    VariableDefinitions nameDefinition = builder.initializingFormal('_name');
 
     FunctionExpression constructorNode = builder.functionExpression(
-        builder.constModifiers,
+        builder.modifiers(isConst: true),
         enumClass.name,
-        builder.argumentList([indexDefinition, nameDefinition]),
+        builder.argumentList([indexDefinition]),
         builder.emptyStatement());
 
     EnumConstructorElementX constructor = new EnumConstructorElementX(
         enumClass,
-        builder.constModifiers,
+        builder.modifiers(isConst: true),
         constructorNode);
 
     EnumFormalElementX indexFormal = new EnumFormalElementX(
         constructor,
         indexDefinition,
         builder.identifier('index'),
         indexVariable);
 
-    EnumFormalElementX nameFormal = new EnumFormalElementX(
-        constructor,
-        nameDefinition,
-        builder.identifier('_name'),
-        nameVariable);
-
     FunctionSignatureX constructorSignature = new FunctionSignatureX(
-        requiredParameters: builder.linkedList([indexFormal, nameFormal]),
-        requiredParameterCount: 2,
+        requiredParameters: builder.linkedList([indexFormal]),
+        requiredParameterCount: 1,
         type: new FunctionType(constructor, const VoidType(),
-            <DartType>[intType, stringType]));
+            <DartType>[intType]));
     constructor.functionSignatureCache = constructorSignature;
     enumClass.addMember(constructor, compiler);
 
-    VariableList variableList = new VariableList(builder.staticConstModifiers);
+    VariableList variableList =
+        new VariableList(builder.modifiers(isStatic: true, isConst: true));
     variableList.type = enumType;
     int index = 0;
     List<Node> valueReferences = <Node>[];
+    List<LiteralMapEntry> mapEntries = <LiteralMapEntry>[];
     for (Link<Node> link = node.names.nodes;
          !link.isEmpty;
          link = link.tail) {
       Identifier name = link.head;
       AstBuilder valueBuilder = new AstBuilder(name.token);
-      valueReferences.add(new Send(null, name));
+
+      // Add reference for the `values` field.
+      valueReferences.add(valueBuilder.reference(name));
+
+      // Add map entry for `toString` implementation.
+      mapEntries.add(valueBuilder.mapLiteralEntry(
+            valueBuilder.literalInt(index),
+            valueBuilder.literalString('${enumClass.name}.${name.source}')));
 
       Expression initializer = valueBuilder.newExpression(
           enumClass.name,
-          valueBuilder.argumentList([
-            valueBuilder.literalInt(index),
-            valueBuilder.literalString('${name.source}')
-          ]),
+          valueBuilder.argumentList([valueBuilder.literalInt(index)]),
           isConst: true);
       SendSet definition = valueBuilder.createDefinition(name, initializer);
 
       EnumFieldElementX field = new EnumFieldElementX(
           name, enumClass, variableList, definition, initializer);
       enumClass.addMember(field, compiler);
       index++;
     }
 
     VariableList valuesVariableList =
-        new VariableList(builder.staticConstModifiers);
+        new VariableList(builder.modifiers(isStatic: true, isConst: true));
     InterfaceType listType = compiler.listClass.computeType(compiler);
     valuesVariableList.type = listType.createInstantiation([enumType]);
 
     Identifier valuesIdentifier = builder.identifier('values');
     // TODO(johnniwinther): Add type argument.
     Expression initializer = builder.listLiteral(
         valueReferences, isConst: true);
 
     Node definition = builder.createDefinition(valuesIdentifier, initializer);
 
     EnumFieldElementX valuesVariable = new EnumFieldElementX(
         valuesIdentifier, enumClass, valuesVariableList,
         definition, initializer);
 
     enumClass.addMember(valuesVariable, compiler);
 
     // TODO(johnniwinther): Support return type. Note `String` might be prefixed
     // or not imported within the current library.
     FunctionExpression toStringNode = builder.functionExpression(
         Modifiers.EMPTY,
         'toString',
         builder.argumentList([]),
         builder.returnStatement(
-            new StringInterpolation(
-                builder.literalString('${enumClass.name}.', suffix: ''),
-                new NodeList.singleton(new StringInterpolationPart(
-                    new Send(null, builder.identifier('_name')),
-                    builder.literalString('', prefix: '')))
-            ))
+              builder.indexGet(
+                  builder.mapLiteral(mapEntries, isConst: true),
+                  builder.reference(builder.identifier('index')))
+            )
         );
 
     EnumMethodElementX toString = new EnumMethodElementX('toString',
         enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new FunctionType(toString, stringType));
     toString.functionSignatureCache = toStringSignature;
     enumClass.addMember(toString, compiler);
   }
 }