Store toString value in enum.

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 '../common.dart';
 import '../core_types.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 163 matching lines @@
 /// This class generates the model for an enum class.
 ///
 /// For instance
 ///
 ///     enum A { b, c, }
 ///
 /// is modelled as
 ///
 ///     class A {
 ///       final int index;
+///       final String _name;
 ///
 ///       const A(this.index);
 ///
 ///       String toString() {
-///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///         return _name;
 ///       }
 ///
-///       static const A b = const A(0);
-///       static const A c = const A(1);
+///       static const A b = const A(0, "A.b");
+///       static const A c = const A(1, "A.v");
 ///
 ///       static const List<A> values = const <A>[b, c];
 ///     }
 ///
 // TODO(johnniwinther): Avoid creating synthesized ASTs for enums when SSA is
 // removed.
 class EnumCreator {
   final DiagnosticReporter reporter;
   final CommonElements commonElements;
   final EnumClassElementX enumClass;
@@ skipping 14 matching lines @@
       VariableList variableList =
           new VariableList(builder.modifiers(isFinal: true));
       variableList.type = type;
       EnumFieldElementX variable = new EnumFieldElementX(
           identifier, enumClass, variableList, identifier);
       enumClass.addMember(variable, reporter);
       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.modifiers(isConst: true),
         enumClass.name,
         null, // typeVariables
-        builder.argumentList([indexDefinition]),
+        builder.argumentList([indexDefinition, nameDefinition]),
         builder.emptyStatement());
 
     EnumConstructorElementX constructor = new EnumConstructorElementX(
         enumClass, 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: [indexFormal],
-        requiredParameterCount: 1,
-        type: new ResolutionFunctionType(constructor,
-            const ResolutionDynamicType(), <ResolutionDartType>[intType]));
+        requiredParameters: [indexFormal, nameFormal],
+        requiredParameterCount: 2,
+        type: new ResolutionFunctionType(
+            constructor,
+            const ResolutionDynamicType(),
+            <ResolutionDartType>[intType, stringType]));
     constructor.functionSignature = constructorSignature;
     enumClass.addMember(constructor, reporter);
 
     List<EnumConstantElement> enumValues = <EnumConstantElement>[];
     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.charOffset);
       VariableList variableList = new VariableList(
           valueBuilder.modifiers(isStatic: true, isConst: true));
       variableList.type = enumType;
 
       // 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)]),
+      Expression initializer = valueBuilder.newExpression(
+          enumClass.name,
+          valueBuilder.argumentList([
+            valueBuilder.literalInt(index),
+            valueBuilder.literalString('${enumClass.name}.${name.source}')
+          ]),
           isConst: true);
       SendSet definition = valueBuilder.createDefinition(name, initializer);
 
       EnumConstantElementX field = new EnumConstantElementX(
           name, enumClass, variableList, definition, initializer, index);
       enumValues.add(field);
       enumClass.addMember(field, reporter);
       index++;
     }
 
     VariableList valuesVariableList =
         new VariableList(builder.modifiers(isStatic: true, isConst: true));
     ResolutionInterfaceType valuesType = commonElements.listType(enumType);
     valuesVariableList.type = valuesType;
 
     Identifier valuesIdentifier = builder.identifier('values');
-    // TODO(johnniwinther): Add type argument.
+    // TODO(28340): 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, reporter);
 
-    // 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, // typeVariables
         builder.argumentList([]),
-        builder.returnStatement(builder.indexGet(
-            builder.mapLiteral(mapEntries, isConst: true),
-            builder.reference(builder.identifier('index')))));
+        builder
+            .returnStatement(builder.reference(builder.identifier('_name'))));
 
     EnumMethodElementX toString = new EnumMethodElementX(
         'toString', enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new ResolutionFunctionType(toString, stringType));
     toString.functionSignature = toStringSignature;
     enumClass.addMember(toString, reporter);
 
     enumClass.enumValues = enumValues;
   }
 }