Create closed world for hello world using .dill file

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

Index: pkg/compiler/lib/src/resolution/enum_creator.dart
diff --git a/pkg/compiler/lib/src/resolution/enum_creator.dart b/pkg/compiler/lib/src/resolution/enum_creator.dart
index ced1450467c9e0d43d147d89bb474e9938f0c7d3..8ee32da5fae57743c9bdbc65e532ff9d2b3bb2e1 100644
--- a/pkg/compiler/lib/src/resolution/enum_creator.dart
+++ b/pkg/compiler/lib/src/resolution/enum_creator.dart
@@ -199,6 +199,10 @@ class EnumCreator {
 
   EnumCreator(this.reporter, this.commonElements, this.enumClass);
 
+  /// Flag to re-enable the spec-based encoding of the `toString` method. This
+  /// is used for equivalence testing with kernel based input.
+  static bool USE_CONSTANT_MAP_IN_TO_STRING = false;

[Siggi Cherem (dart-lang), 2017/05/15 17:05:50]

a few nits:
- just use the common camelCaseNotation
(https://www.dartlang.org/guides/language/effective-dart/style#prefer-using-lo...)

- I'd be nice to say "testing" in the field name, some ideas:
   - useConstantMapImplementationForTesting
   - implementToStringViaConstantMapForTesting
   - matchKernelRepresentationForTesting

- update the dartdoc to indicate what corresponds to the spec-based encoding or
what matches kernel. For example:

/// Whether to use a constant-map to encode the result of toString on an enum
value.
///
/// Dart2js by default uses a compact representation of enum values that include
their name. The spec and the kernel-based implementation use a const-map to
encode the result of toString. This flag is used to disable the default
representation, and instead match the kernel representation to make it easier to
test the equivalence of resolution-based and kernel-based world builders.

[Johnni Winther, 2017/05/16 08:29:54]

Done.

+
   void createMembers() {
     Enum node = enumClass.node;
     ResolutionInterfaceType enumType = enumClass.thisType;
@@ -220,16 +224,22 @@ class EnumCreator {
     }
 
     EnumFieldElementX indexVariable = addInstanceMember('index', intType);
-    EnumFieldElementX nameVariable = addInstanceMember('_name', stringType);
+    EnumFieldElementX nameVariable;
 
     VariableDefinitions indexDefinition = builder.initializingFormal('index');
-    VariableDefinitions nameDefinition = builder.initializingFormal('_name');
+    VariableDefinitions nameDefinition;
 
+    List<Node> constructorInitializers = <Node>[indexDefinition];
+    if (!USE_CONSTANT_MAP_IN_TO_STRING) {
+      nameVariable = addInstanceMember('_name', stringType);
+      nameDefinition = builder.initializingFormal('_name');
+      constructorInitializers.add(nameDefinition);
+    }
     FunctionExpression constructorNode = builder.functionExpression(
         builder.modifiers(isConst: true),
         enumClass.name,
         null, // typeVariables
-        builder.argumentList([indexDefinition, nameDefinition]),
+        builder.argumentList(constructorInitializers),
         builder.emptyStatement());
 
     EnumConstructorElementX constructor = new EnumConstructorElementX(
@@ -238,22 +248,31 @@ class EnumCreator {
     EnumFormalElementX indexFormal = new EnumFormalElementX(constructor,
         indexDefinition, builder.identifier('index'), indexVariable);
 
-    EnumFormalElementX nameFormal = new EnumFormalElementX(
-        constructor, nameDefinition, builder.identifier('_name'), nameVariable);
+    EnumFormalElementX nameFormal;
 
+    List<Element> parameters = <Element>[indexFormal];
+    List<ResolutionDartType> parameterTypes = <ResolutionDartType>[intType];
+    if (!USE_CONSTANT_MAP_IN_TO_STRING) {
+      nameFormal = new EnumFormalElementX(constructor, nameDefinition,
+          builder.identifier('_name'), nameVariable);
+      parameters.add(nameFormal);
+      parameterTypes.add(stringType);
+    }
     FunctionSignatureX constructorSignature = new FunctionSignatureX(
-        requiredParameters: [indexFormal, nameFormal],
-        requiredParameterCount: 2,
+        requiredParameters: parameters,
+        requiredParameterCount: parameters.length,
         type: new ResolutionFunctionType(
-            constructor,
-            const ResolutionDynamicType(),
-            <ResolutionDartType>[intType, stringType]));
+            constructor, const ResolutionDynamicType(), parameterTypes));
     constructor.functionSignature = constructorSignature;
     enumClass.addMember(constructor, reporter);
 
     List<EnumConstantElement> enumValues = <EnumConstantElement>[];
     int index = 0;
     List<Node> valueReferences = <Node>[];
+    List<LiteralMapEntry> mapEntries;
+    if (USE_CONSTANT_MAP_IN_TO_STRING) {
+      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);
@@ -264,13 +283,22 @@ class EnumCreator {
       // Add reference for the `values` field.
       valueReferences.add(valueBuilder.reference(name));
 
-      Expression initializer = valueBuilder.newExpression(
-          enumClass.name,
-          valueBuilder.argumentList([
-            valueBuilder.literalInt(index),
-            valueBuilder.literalString('${enumClass.name}.${name.source}')
-          ]),
-          isConst: true);
+      Node indexValue = valueBuilder.literalInt(index);
+      Node nameValue =
+          valueBuilder.literalString('${enumClass.name}.${name.source}');
+      Expression initializer;
+      if (USE_CONSTANT_MAP_IN_TO_STRING) {
+        // Add map entry for `toString` implementation.
+        mapEntries.add(valueBuilder.mapLiteralEntry(indexValue, nameValue));
+
+        initializer = valueBuilder.newExpression(enumClass.name,
+            valueBuilder.argumentList([valueBuilder.literalInt(index)]),

[Siggi Cherem (dart-lang), 2017/05/15 17:05:50]

reuse indexValue

[Johnni Winther, 2017/05/16 08:29:54]

Done.

+            isConst: true);
+      } else {
+        initializer = valueBuilder.newExpression(
+            enumClass.name, valueBuilder.argumentList([indexValue, nameValue]),
+            isConst: true);
+      }
       SendSet definition = valueBuilder.createDefinition(name, initializer);
 
       EnumConstantElementX field = new EnumConstantElementX(
@@ -297,13 +325,20 @@ class EnumCreator {
 
     enumClass.addMember(valuesVariable, reporter);
 
+    Node toStringValue;
+    if (USE_CONSTANT_MAP_IN_TO_STRING) {
+      toStringValue = builder.indexGet(
+          builder.mapLiteral(mapEntries, isConst: true),
+          builder.reference(builder.identifier('index')));
+    } else {
+      toStringValue = builder.reference(builder.identifier('_name'));
+    }
     FunctionExpression toStringNode = builder.functionExpression(
         Modifiers.EMPTY,
         'toString',
         null, // typeVariables
         builder.argumentList([]),
-        builder
-            .returnStatement(builder.reference(builder.identifier('_name'))));
+        builder.returnStatement(toStringValue));
 
     EnumMethodElementX toString = new EnumMethodElementX(
         'toString', enumClass, Modifiers.EMPTY, toStringNode);