Store toString value in enum.

pkg/compiler/lib/src/serialization/resolved_ast_serialization.dart

 // Copyright (c) 2016, 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.serialization.resolved_ast;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
@@ skipping 28 matching lines @@
     node.visitChildren(this);
   }
 }
 
 /// The kind of AST node. Used for determining how to deserialize
 /// [ResolvedAst]s.
 enum AstKind {
   ENUM_CONSTRUCTOR,
   ENUM_CONSTANT,
   ENUM_INDEX_FIELD,
+  ENUM_NAME_FIELD,
   ENUM_VALUES_FIELD,
   ENUM_TO_STRING,
   FACTORY,
   FIELD,
   FUNCTION,
 }
 
 /// Serializer for [ResolvedAst]s.
 class ResolvedAstSerializer extends Visitor {
   final SerializerPlugin nativeDataSerializer;
@@ skipping 45 matching lines @@
   }
 
   /// Serialize [ResolvedAst] that is defined in terms of an AST together with
   /// [TreeElements].
   void serializeParsed() {
     objectEncoder.setUri(Key.URI, resolvedAst.sourceUri, resolvedAst.sourceUri);
     AstKind kind;
     if (element.enclosingClass is EnumClassElement) {
       if (element.name == 'index') {
         kind = AstKind.ENUM_INDEX_FIELD;
+      } else if (element.name == '_name') {
+        kind = AstKind.ENUM_NAME_FIELD;

[sra1, 2017/02/24 01:01:50]

How do I best test this?
dart2js tests pass.

[Johnni Winther, 2017/02/24 08:52:45]

No need to do more. The serialization tests already cover enums.

       } else if (element.name == 'values') {
         kind = AstKind.ENUM_VALUES_FIELD;
       } else if (element.name == 'toString') {
         kind = AstKind.ENUM_TO_STRING;
       } else if (element.isConstructor) {
         kind = AstKind.ENUM_CONSTRUCTOR;
       } else {
         assert(invariant(element, element.isConst,
             message: "Unexpected enum member: $element"));
         kind = AstKind.ENUM_CONSTANT;
@@ skipping 286 matching lines @@
     Node computeNode(AstKind kind) {
       switch (kind) {
         case AstKind.ENUM_INDEX_FIELD:
           AstBuilder builder = new AstBuilder(element.sourcePosition.begin);
           Identifier identifier = builder.identifier('index');
           VariableDefinitions node = new VariableDefinitions(
               null,
               builder.modifiers(isFinal: true),
               new NodeList.singleton(identifier));
           return node;
+        case AstKind.ENUM_NAME_FIELD:
+          AstBuilder builder = new AstBuilder(element.sourcePosition.begin);
+          Identifier identifier = builder.identifier('_name');
+          VariableDefinitions node = new VariableDefinitions(
+              null,
+              builder.modifiers(isFinal: true),
+              new NodeList.singleton(identifier));
+          return node;
         case AstKind.ENUM_VALUES_FIELD:
           EnumClassElement enumClass = element.enclosingClass;
           AstBuilder builder = new AstBuilder(element.sourcePosition.begin);
           List<Node> valueReferences = <Node>[];
           for (EnumConstantElement enumConstant in enumClass.enumValues) {
             AstBuilder valueBuilder =
                 new AstBuilder(enumConstant.sourcePosition.begin);
             Identifier name = valueBuilder.identifier(enumConstant.name);
 
             // Add reference for the `values` field.
@@ skipping 28 matching lines @@
                     .literalString('${enumClass.name}.${name.source}')));
           }
 
           // TODO(johnniwinther): Support return type. Note `String` might be
           // prefixed or not imported within the current library.
           FunctionExpression toStringNode = builder.functionExpression(
               Modifiers.EMPTY,
               'toString',
               null,
               builder.argumentList([]),
-              builder.returnStatement(builder.indexGet(
-                  builder.mapLiteral(mapEntries, isConst: true),
-                  builder.reference(builder.identifier('index')))));
+              builder.returnStatement(
+                  builder.reference(builder.identifier('_name'))));
           return toStringNode;
         case AstKind.ENUM_CONSTRUCTOR:
           AstBuilder builder = new AstBuilder(element.sourcePosition.begin);
           VariableDefinitions indexDefinition =
               builder.initializingFormal('index');
+          VariableDefinitions nameDefinition =
+              builder.initializingFormal('_name');
           FunctionExpression constructorNode = builder.functionExpression(
               builder.modifiers(isConst: true),
               element.enclosingClass.name,
               null,
-              builder.argumentList([indexDefinition]),
+              builder.argumentList([indexDefinition, nameDefinition]),
               builder.emptyStatement());
           return constructorNode;
         case AstKind.ENUM_CONSTANT:
           EnumConstantElementZ enumConstant = element;
           EnumClassElement enumClass = element.enclosingClass;
           int index = enumConstant.index;
           AstBuilder builder = new AstBuilder(element.sourcePosition.begin);
           Identifier name = builder.identifier(element.name);
 
+          String enumString = "${enumClass.name}.${element.name}";
           Expression initializer = builder.newExpression(
-              enumClass.name, builder.argumentList([builder.literalInt(index)]),
+              enumClass.name,
+              builder.argumentList([
+                builder.literalInt(index),
+                builder.literalString(enumString)
+              ]),
               isConst: true);
           SendSet definition = builder.createDefinition(name, initializer);
 
           VariableDefinitions node = new VariableDefinitions(
               null,
               builder.modifiers(isStatic: true, isConst: true),
               new NodeList.singleton(definition));
           return node;
         case AstKind.FACTORY:
           Token beginToken = readBeginToken();
@@ skipping 179 matching lines @@
         }
       }
     }
     element.resolvedAst =
         new ParsedResolvedAst(element, root, body, elements, uri);
   }
 }
 
 const Key PARAMETER_NODE = const Key('parameter.node');
 const Key PARAMETER_INITIALIZER = const Key('parameter.initializer');