Create closed world for hello world using .dill file

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 '../common_elements.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 181 matching lines @@
 ///
 // TODO(johnniwinther): Avoid creating synthesized ASTs for enums when SSA is
 // removed.
 class EnumCreator {
   final DiagnosticReporter reporter;
   final CommonElements commonElements;
   final EnumClassElementX enumClass;
 
   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;
     AstBuilder builder = new AstBuilder(enumClass.position.charOffset);
 
     ResolutionInterfaceType intType = commonElements.intType;
     ResolutionInterfaceType stringType = commonElements.stringType;
 
     EnumFieldElementX addInstanceMember(
         String name, ResolutionInterfaceType type) {
       Identifier identifier = builder.identifier(name);
       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);
+    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(
         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);
+    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);
       VariableList variableList = new VariableList(
           valueBuilder.modifiers(isStatic: true, isConst: true));
       variableList.type = enumType;
 
       // 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(
           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(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);
 
+    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);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new ResolutionFunctionType(toString, stringType));
     toString.functionSignature = toStringSignature;
     enumClass.addMember(toString, reporter);
 
     enumClass.enumValues = enumValues;
   }
 }