dartfmt pkg/compiler

pkg/compiler/lib/src/js_emitter/lazy_emitter/model_emitter.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.js_emitter.lazy_emitter.model_emitter;
 
-import '../../compiler.dart' show
-    Compiler;
-import '../../constants/values.dart' show
-    ConstantValue,
-    FunctionConstantValue;
-import '../../core_types.dart' show
-    CoreClasses;
-import '../../elements/elements.dart' show
-    ClassElement,
-    FunctionElement;
+import '../../compiler.dart' show Compiler;
+import '../../constants/values.dart' show ConstantValue, FunctionConstantValue;
+import '../../core_types.dart' show CoreClasses;
+import '../../elements/elements.dart' show ClassElement, FunctionElement;
 import '../../js/js.dart' as js;
-import '../../js_backend/js_backend.dart' show
-    JavaScriptBackend,
-    Namer,
-    ConstantEmitter;
+import '../../js_backend/js_backend.dart'
+    show JavaScriptBackend, Namer, ConstantEmitter;
 
 import '../js_emitter.dart' show NativeEmitter;
 import '../constant_ordering.dart' show deepCompareConstants;
 
-import 'package:js_runtime/shared/embedded_names.dart' show
-    CREATE_NEW_ISOLATE,
-    DEFERRED_LIBRARY_URIS,
-    DEFERRED_LIBRARY_HASHES,
-    GET_TYPE_FROM_NAME,
-    INITIALIZE_LOADED_HUNK,
-    INTERCEPTORS_BY_TAG,
-    IS_HUNK_INITIALIZED,
-    IS_HUNK_LOADED,
-    LEAF_TAGS,
-    MANGLED_GLOBAL_NAMES,
-    METADATA,
-    TYPE_TO_INTERCEPTOR_MAP,
-    TYPES;
+import 'package:js_runtime/shared/embedded_names.dart'
+    show
+        CREATE_NEW_ISOLATE,
+        DEFERRED_LIBRARY_URIS,
+        DEFERRED_LIBRARY_HASHES,
+        GET_TYPE_FROM_NAME,
+        INITIALIZE_LOADED_HUNK,
+        INTERCEPTORS_BY_TAG,
+        IS_HUNK_INITIALIZED,
+        IS_HUNK_LOADED,
+        LEAF_TAGS,
+        MANGLED_GLOBAL_NAMES,
+        METADATA,
+        TYPE_TO_INTERCEPTOR_MAP,
+        TYPES;
 
 import '../js_emitter.dart' show NativeGenerator, buildTearOffCode;
 import '../model.dart';
 
 class ModelEmitter {
   final Compiler compiler;
   final Namer namer;
   ConstantEmitter constantEmitter;
   final NativeEmitter nativeEmitter;
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// For deferred loading we communicate the initializers via this global var.
   static const String deferredInitializersGlobal =
       r"$__dart_deferred_initializers__";
 
   static const String deferredExtension = "part.js";
 
   static const String typeNameProperty = r"builtin$cls";
 
   ModelEmitter(Compiler compiler, Namer namer, this.nativeEmitter)
       : this.compiler = compiler,
         this.namer = namer {
-
     this.constantEmitter = new ConstantEmitter(
-        compiler, namer, this.generateConstantReference,
-        constantListGenerator);
+        compiler, namer, this.generateConstantReference, constantListGenerator);
   }
 
   js.Expression constantListGenerator(js.Expression array) {
     // TODO(floitsch): remove hard-coded name.
     return js.js('makeConstList(#)', [array]);
   }
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     return js.js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return 'init.$global';
   }
 
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
-    if (constant.isFunction) return true;    // Already emitted.
-    if (constant.isPrimitive) return true;   // Inlined.
-    if (constant.isDummy) return true;       // Inlined.
+    if (constant.isFunction) return true; // Already emitted.
+    if (constant.isPrimitive) return true; // Inlined.
+    if (constant.isDummy) return true; // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
 
   // TODO(floitsch): copied from full emitter. Adjust or share.
   int compareConstants(ConstantValue a, ConstantValue b) {
     // Inlined constants don't affect the order and sometimes don't even have
@@ skipping 26 matching lines @@
     if (value.isFunction) {
       FunctionConstantValue functionConstant = value;
       return generateStaticClosureAccess(functionConstant.element);
     }
 
     // We are only interested in the "isInlined" part, but it does not hurt to
     // test for the other predicates.
     if (isConstantInlinedOrAlreadyEmitted(value)) {
       return constantEmitter.generate(value);
     }
-    return js.js('#.#()', [namer.globalObjectForConstant(value),
-                           namer.constantName(value)]);
+    return js.js('#.#()',
+        [namer.globalObjectForConstant(value), namer.constantName(value)]);
   }
 
   int emitProgram(Program program) {
     List<Fragment> fragments = program.fragments;
     MainFragment mainFragment = fragments.first;
     Iterable<Fragment> deferredFragments = program.deferredFragments;
 
     int totalSize = 0;
 
     // We have to emit the deferred fragments first, since we need their
     // deferred hash (which depends on the output) when emitting the main
     // fragment.
-    List<js.Expression> fragmentsCode = deferredFragments.map(
-            (DeferredFragment deferredUnit) {
+    List<js.Expression> fragmentsCode =
+        deferredFragments.map((DeferredFragment deferredUnit) {
       js.Expression types =
           program.metadataTypesForOutputUnit(deferredUnit.outputUnit);
       return emitDeferredFragment(types, deferredUnit, program.holders);
     }).toList();
 
     js.Statement mainAst = emitMainFragment(program);
 
     js.TokenCounter counter = new js.TokenCounter();
     fragmentsCode.forEach(counter.countTokens);
     counter.countTokens(mainAst);
 
     program.finalizers.forEach((js.TokenFinalizer f) => f.finalizeTokens());
 
     // TODO(johnnniwinther): Support source maps in this emitter.
     for (int i = 0; i < fragmentsCode.length; ++i) {
       String code = js.createCodeBuffer(fragmentsCode[i], compiler).getText();
       totalSize += code.length;
-      compiler.outputProvider(fragments[i+1].outputFileName, deferredExtension)
+      compiler.outputProvider(
+          fragments[i + 1].outputFileName, deferredExtension)
         ..add(code)
         ..close();
     }
 
     String mainCode = js.createCodeBuffer(mainAst, compiler).getText();
     compiler.outputProvider(mainFragment.outputFileName, 'js')
-        ..add(buildGeneratedBy(compiler))
-        ..add(mainCode)
-        ..close();
+      ..add(buildGeneratedBy(compiler))
+      ..add(mainCode)
+      ..close();
     totalSize += mainCode.length;
 
     return totalSize;
   }
 
   /// Returns a [js.Literal] that represents the string result of unparsing
   /// [value].
   ///
   /// The returned node will, when its string value is requested, pretty-print
   /// the given [value] and, if [protectForEval] is true, wrap the resulting
   /// string in parenthesis. The result is also escaped.
   ///
   /// See [_UnparsedNode] for details.
   js.Literal unparse(Compiler compiler, js.Node value,
-                     {bool protectForEval: true}) {
+      {bool protectForEval: true}) {
     return new js.UnparsedNode(value, compiler, protectForEval);
   }
 
   String buildGeneratedBy(compiler) {
     var suffix = '';
     if (compiler.options.hasBuildId) {
       suffix = ' version: ${compiler.options.buildId}';
     }
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
 
   js.Statement emitMainFragment(Program program) {
     MainFragment fragment = program.fragments.first;
     List<js.Expression> elements = fragment.libraries.map(emitLibrary).toList();
     elements.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
     elements.add(emitConstants(fragment.constants));
 
     js.Expression code = new js.ArrayInitializer(elements);
 
-    Map<String, dynamic> holes =
-      {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
-       'holders': emitHolders(program.holders),
-       'tearOff': buildTearOffCode(backend),
-       'parseFunctionDescriptor':
-           js.js.statement(parseFunctionDescriptorBoilerplate,
-               {'argumentCount': js.string(namer.requiredParameterField),
-                'defaultArgumentValues': js.string(namer.defaultValuesField),
-                'callName': js.string(namer.callNameField)}),
-
-       'cyclicThrow':
-           backend.emitter.staticFunctionAccess(
-               backend.helpers.cyclicThrowHelper),
-       'outputContainsConstantList': program.outputContainsConstantList,
-       'embeddedGlobals': emitEmbeddedGlobals(program),
-       'readMetadataTypeFunction': readMetadataTypeFunction,
-       'staticNonFinals':
-            emitStaticNonFinalFields(fragment.staticNonFinalFields),
-       'operatorIsPrefix': js.string(namer.operatorIsPrefix),
-       'callName': js.string(namer.callNameField),
-       'argumentCount': js.string(namer.requiredParameterField),
-       'defaultArgumentValues': js.string(namer.defaultValuesField),
-       'eagerClasses': emitEagerClassInitializations(fragment.libraries),
-       'invokeMain': fragment.invokeMain,
-       'code': code};
+    Map<String, dynamic> holes = {
+      'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
+      'holders': emitHolders(program.holders),
+      'tearOff': buildTearOffCode(backend),
+      'parseFunctionDescriptor':
+          js.js.statement(parseFunctionDescriptorBoilerplate, {
+        'argumentCount': js.string(namer.requiredParameterField),
+        'defaultArgumentValues': js.string(namer.defaultValuesField),
+        'callName': js.string(namer.callNameField)
+      }),
+      'cyclicThrow': backend.emitter
+          .staticFunctionAccess(backend.helpers.cyclicThrowHelper),
+      'outputContainsConstantList': program.outputContainsConstantList,
+      'embeddedGlobals': emitEmbeddedGlobals(program),
+      'readMetadataTypeFunction': readMetadataTypeFunction,
+      'staticNonFinals':
+          emitStaticNonFinalFields(fragment.staticNonFinalFields),
+      'operatorIsPrefix': js.string(namer.operatorIsPrefix),
+      'callName': js.string(namer.callNameField),
+      'argumentCount': js.string(namer.requiredParameterField),
+      'defaultArgumentValues': js.string(namer.defaultValuesField),
+      'eagerClasses': emitEagerClassInitializations(fragment.libraries),
+      'invokeMain': fragment.invokeMain,
+      'code': code
+    };
 
     holes.addAll(nativeHoles(program));
 
     return js.js.statement(boilerplate, holes);
   }
 
   Map<String, dynamic> nativeHoles(Program program) {
     Map<String, dynamic> nativeHoles = <String, dynamic>{};
 
     js.Statement nativeIsolateAffinityTagInitialization;
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
       nativeIsolateAffinityTagInitialization =
           NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
               // TODO(floitsch): internStringFunction.
               js.js("(function(x) { return x; })", []));
     } else {
       nativeIsolateAffinityTagInitialization = js.js.statement(";");
     }
     nativeHoles['nativeIsolateAffinityTagInitialization'] =
         nativeIsolateAffinityTagInitialization;
 
-
     js.Expression nativeInfoAccess = js.js('nativeInfo', []);
     js.Expression constructorAccess = js.js('constructor', []);
     Function subclassReadGenerator = (js.Expression subclass) {
       return js.js('holdersMap[#][#].ensureResolved()', [subclass, subclass]);
     };
     js.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG);
-    js.Expression leafTagsAccess =
-        generateEmbeddedGlobalAccess(LEAF_TAGS);
+    js.Expression leafTagsAccess = generateEmbeddedGlobalAccess(LEAF_TAGS);
     js.Statement nativeInfoHandler = NativeGenerator.buildNativeInfoHandler(
         nativeInfoAccess,
         constructorAccess,
         subclassReadGenerator,
         interceptorsByTagAccess,
         leafTagsAccess);
 
     nativeHoles['needsNativeSupport'] = program.needsNativeSupport;
     nativeHoles['needsNoNativeSupport'] = !program.needsNativeSupport;
     nativeHoles['nativeInfoHandler'] = nativeInfoHandler;
 
     return nativeHoles;
   }
 
   js.Block emitHolders(List<Holder> holders) {
     // The top-level variables for holders must *not* be renamed by the
     // JavaScript pretty printer because a lot of code already uses the
     // non-renamed names. The generated code looks like this:
     //
     //    var H = {}, ..., G = {};
     //    var holders = [ H, ..., G ];
     //
     // and it is inserted at the top of the top-level function expression
     // that covers the entire program.
 
     List<js.Statement> statements = [
-        new js.ExpressionStatement(
-            new js.VariableDeclarationList(holders.map((e) =>
-                new js.VariableInitialization(
-                    new js.VariableDeclaration(e.name, allowRename: false),
-                    new js.ObjectInitializer(const []))).toList())),
-        js.js.statement('var holders = #', new js.ArrayInitializer(
-            holders.map((e) => new js.VariableUse(e.name))
-                   .toList(growable: false))),
-        js.js.statement('var holdersMap = Object.create(null)')
+      new js.ExpressionStatement(new js.VariableDeclarationList(holders
+          .map((e) => new js.VariableInitialization(
+              new js.VariableDeclaration(e.name, allowRename: false),
+              new js.ObjectInitializer(const [])))
+          .toList())),
+      js.js.statement(
+          'var holders = #',
+          new js.ArrayInitializer(holders
+              .map((e) => new js.VariableUse(e.name))
+              .toList(growable: false))),
+      js.js.statement('var holdersMap = Object.create(null)')
     ];
     return new js.Block(statements);
   }
 
   js.Block emitEmbeddedGlobals(Program program) {
     List<js.Property> globals = <js.Property>[];
 
     if (program.loadMap.isNotEmpty) {
       globals.addAll(emitEmbeddedGlobalsForDeferredLoading(program.loadMap));
     }
 
     if (program.typeToInterceptorMap != null) {
-      globals.add(new js.Property(js.string(TYPE_TO_INTERCEPTOR_MAP),
-                                  program.typeToInterceptorMap));
+      globals.add(new js.Property(
+          js.string(TYPE_TO_INTERCEPTOR_MAP), program.typeToInterceptorMap));
     }
 
     if (program.hasIsolateSupport) {
       String isolateName = namer.staticStateHolder;
-      globals.add(
-          new js.Property(js.string(CREATE_NEW_ISOLATE),
-                          js.js('function () { return $isolateName; }')));
+      globals.add(new js.Property(js.string(CREATE_NEW_ISOLATE),
+          js.js('function () { return $isolateName; }')));
       // TODO(floitsch): add remaining isolate functions.
     }
 
     globals.add(emitMangledGlobalNames());
 
     globals.add(emitGetTypeFromName());
 
     globals.addAll(emitMetadata(program));
 
     if (program.needsNativeSupport) {
-      globals.add(new js.Property(js.string(INTERCEPTORS_BY_TAG),
-                                  js.js('Object.create(null)', [])));
-      globals.add(new js.Property(js.string(LEAF_TAGS),
-                                  js.js('Object.create(null)', [])));
+      globals.add(new js.Property(
+          js.string(INTERCEPTORS_BY_TAG), js.js('Object.create(null)', [])));
+      globals.add(new js.Property(
+          js.string(LEAF_TAGS), js.js('Object.create(null)', [])));
     }
 
     js.ObjectInitializer globalsObject = new js.ObjectInitializer(globals);
 
-    List<js.Statement> statements =
-        [new js.ExpressionStatement(
-            new js.VariableDeclarationList(
-                [new js.VariableInitialization(
-                    new js.VariableDeclaration("init", allowRename: false),
-                    globalsObject)]))];
+    List<js.Statement> statements = [
+      new js.ExpressionStatement(new js.VariableDeclarationList([
+        new js.VariableInitialization(
+            new js.VariableDeclaration("init", allowRename: false),
+            globalsObject)
+      ]))
+    ];
     return new js.Block(statements);
   }
 
   js.Property emitMangledGlobalNames() {
     List<js.Property> names = <js.Property>[];
 
     CoreClasses coreClasses = compiler.coreClasses;
     // We want to keep the original names for the most common core classes when
     // calling toString on them.
-    List<ClassElement> nativeClassesNeedingUnmangledName =
-        [coreClasses.intClass, coreClasses.doubleClass, coreClasses.numClass,
-         coreClasses.stringClass, coreClasses.boolClass, coreClasses.nullClass,
-         coreClasses.listClass];
+    List<ClassElement> nativeClassesNeedingUnmangledName = [
+      coreClasses.intClass,
+      coreClasses.doubleClass,
+      coreClasses.numClass,
+      coreClasses.stringClass,
+      coreClasses.boolClass,
+      coreClasses.nullClass,
+      coreClasses.listClass
+    ];
     nativeClassesNeedingUnmangledName.forEach((element) {
-        names.add(new js.Property(js.quoteName(namer.className(element)),
-                                  js.string(element.name)));
+      names.add(new js.Property(
+          js.quoteName(namer.className(element)), js.string(element.name)));
     });
 
-    return new js.Property(js.string(MANGLED_GLOBAL_NAMES),
-                           new js.ObjectInitializer(names));
+    return new js.Property(
+        js.string(MANGLED_GLOBAL_NAMES), new js.ObjectInitializer(names));
   }
 
   js.Statement emitDeferredInitializerGlobal(Map loadMap) {
     if (loadMap.isEmpty) return new js.Block.empty();
 
     return js.js.statement("""
   if (typeof($deferredInitializersGlobal) === 'undefined')
     var $deferredInitializersGlobal = Object.create(null);""");
   }
 
   Iterable<js.Property> emitEmbeddedGlobalsForDeferredLoading(
       Map<String, List<Fragment>> loadMap) {
-
     List<js.Property> globals = <js.Property>[];
 
     js.ArrayInitializer fragmentUris(List<Fragment> fragments) {
       return js.stringArray(fragments.map((DeferredFragment fragment) =>
           "${fragment.outputFileName}.$deferredExtension"));
     }
     js.ArrayInitializer fragmentHashes(List<Fragment> fragments) {
       // TODO(floitsch): the hash must depend on the generated code.
       return js.numArray(
           fragments.map((DeferredFragment fragment) => fragment.hashCode));
     }
 
     List<js.Property> uris = new List<js.Property>(loadMap.length);
     List<js.Property> hashes = new List<js.Property>(loadMap.length);
     int count = 0;
     loadMap.forEach((String loadId, List<Fragment> fragmentList) {
       uris[count] =
           new js.Property(js.string(loadId), fragmentUris(fragmentList));
       hashes[count] =
           new js.Property(js.string(loadId), fragmentHashes(fragmentList));
       count++;
     });
 
-    globals.add(new js.Property(js.string(DEFERRED_LIBRARY_URIS),
-                                new js.ObjectInitializer(uris)));
-    globals.add(new js.Property(js.string(DEFERRED_LIBRARY_HASHES),
-                                new js.ObjectInitializer(hashes)));
+    globals.add(new js.Property(
+        js.string(DEFERRED_LIBRARY_URIS), new js.ObjectInitializer(uris)));
+    globals.add(new js.Property(
+        js.string(DEFERRED_LIBRARY_HASHES), new js.ObjectInitializer(hashes)));
 
     js.Expression isHunkLoadedFunction =
         js.js("function(hash) { return !!$deferredInitializersGlobal[hash]; }");
-    globals.add(new js.Property(js.string(IS_HUNK_LOADED),
-                                isHunkLoadedFunction));
+    globals
+        .add(new js.Property(js.string(IS_HUNK_LOADED), isHunkLoadedFunction));
 
     js.Expression isHunkInitializedFunction =
         js.js("function(hash) { return false; }");
-    globals.add(new js.Property(js.string(IS_HUNK_INITIALIZED),
-                                isHunkInitializedFunction));
+    globals.add(new js.Property(
+        js.string(IS_HUNK_INITIALIZED), isHunkInitializedFunction));
 
     js.Expression typesAccess = generateEmbeddedGlobalAccess(TYPES);
 
     /// See [emitEmbeddedGlobalsForDeferredLoading] for the format of the
     /// deferred hunk.
-    js.Expression initializeLoadedHunkFunction =
-        js.js("""
+    js.Expression initializeLoadedHunkFunction = js.js(
+        """
           function(hash) {
             var hunk = $deferredInitializersGlobal[hash];
             $setupProgramName(hunk[0], #typesAccess.length);
             eval(hunk[1]);
             var deferredTypes = eval(hunk[2]);
             #typesAccess.push.apply(#typesAccess, deferredTypes);
-          }""", {'typesAccess': typesAccess});
+          }""",
+        {'typesAccess': typesAccess});
 
-    globals.add(new js.Property(js.string(INITIALIZE_LOADED_HUNK),
-                                initializeLoadedHunkFunction));
+    globals.add(new js.Property(
+        js.string(INITIALIZE_LOADED_HUNK), initializeLoadedHunkFunction));
 
     return globals;
   }
 
   js.Property emitGetTypeFromName() {
-    js.Expression function =
-        js.js( """function(name) {
+    js.Expression function = js.js("""function(name) {
                     return holdersMap[name][name].ensureResolved();
                   }""");
     return new js.Property(js.string(GET_TYPE_FROM_NAME), function);
   }
 
   static final String readMetadataTypeName = "readMetadataType";
 
   js.Statement get readMetadataTypeFunction {
     // Types are non-evaluated and must be compiled at first use.
     // Compiled strings are guaranteed not to be strings, and it's thus safe
     // to use a type-test to determine if a type has already been compiled.
-    return js.js.statement('''function $readMetadataTypeName(index) {
+    return js.js.statement(
+        '''function $readMetadataTypeName(index) {
       var type = #typesAccess[index];
       if (typeof type == 'string') {
         type = expressionCompile(type);
         #typesAccess[index] = type;
       }
       return type;
-    }''', {"typesAccess": generateEmbeddedGlobalAccess(TYPES)});
+    }''',
+        {"typesAccess": generateEmbeddedGlobalAccess(TYPES)});
   }
 
   js.Template get templateForReadType {
     // TODO(floitsch): make sure that no local variable shadows the access to
     // the readMetadataType function.
     return js.js.expressionTemplateFor('$readMetadataTypeName(#)');
   }
 
   static final String readMetadataName = "readLazyMetadata";
   static final String lazyMetadataName = "lazy_$METADATA";
 
   js.Statement get readMetadataFunction {
     // Types are non-evaluated and must be compiled at first use.
     // Compiled strings are guaranteed not to be strings, and it's thus safe
     // to use a type-test to determine if a type has already been compiled.
-    return js.js.statement('''function $readMetadataName(index) {
+    return js.js.statement(
+        '''function $readMetadataName(index) {
       var lazyMetadata = #lazyMetadataAccess[index];
       if (typeof lazyMetadata == 'string') {
         #metadataAccess[index] = expressionCompile(lazyMetadata);
         #lazyMetadataAccess[index] = null;
       }
       return #metadataAccess[index];
-    }''', {
-      "lazyMetadataAccess": generateEmbeddedGlobalAccess(lazyMetadataName),
-      "metadataAccess": generateEmbeddedGlobalAccess(METADATA)
-    });
+    }''',
+        {
+          "lazyMetadataAccess": generateEmbeddedGlobalAccess(lazyMetadataName),
+          "metadataAccess": generateEmbeddedGlobalAccess(METADATA)
+        });
   }
 
   js.Template get templateForReadMetadata {
     // TODO(floitsch): make sure that no local variable shadows the access to
     // the readMetadata function.
     return js.js.expressionTemplateFor('$readMetadataName(#)');
   }
 
   List<js.Property> emitMetadata(Program program) {
     List<js.Property> metadataGlobals = <js.Property>[];
 
     js.Property createGlobal(js.Expression metadata, String global) {
       return new js.Property(js.string(global), metadata);
     }
 
     metadataGlobals.add(createGlobal(program.metadata, METADATA));
     js.Expression types =
         program.metadataTypesForOutputUnit(program.mainFragment.outputUnit);
     metadataGlobals.add(createGlobal(types, TYPES));
 
     return metadataGlobals;
   }
 
   js.Expression emitDeferredFragment(js.Expression deferredTypes,
-                                     DeferredFragment fragment,
-                                     List<Holder> holders) {
+      DeferredFragment fragment, List<Holder> holders) {
     // TODO(floitsch): initialize eager classes.
     // TODO(floitsch): the hash must depend on the output.
     int hash = fragment.hashCode;
 
     List<js.Expression> deferredCode =
         fragment.libraries.map(emitLibrary).toList();
 
     deferredCode.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
     deferredCode.add(emitConstants(fragment.constants));
 
     js.ArrayInitializer deferredArray = new js.ArrayInitializer(deferredCode);
 
     // This is the code that must be evaluated after all deferred classes have
     // been setup.
     js.Statement immediateCode = new js.Block([
-        emitStaticNonFinalFields(fragment.staticNonFinalFields),
-        emitEagerClassInitializations(fragment.libraries)]);
-
+      emitStaticNonFinalFields(fragment.staticNonFinalFields),
+      emitEagerClassInitializations(fragment.libraries)
+    ]);
 
     js.Literal immediateString = unparse(compiler, immediateCode);
 
-    js.ArrayInitializer hunk =
-        new js.ArrayInitializer([deferredArray, immediateString,
-                                 deferredTypes]);
+    js.ArrayInitializer hunk = new js.ArrayInitializer(
+        [deferredArray, immediateString, deferredTypes]);
 
     return js.js("$deferredInitializersGlobal[$hash] = #", hunk);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the constants format.
   static final String constantsDescription =
       "The constants are encoded as a follows:"
       "   [constantsHolderIndex, name, code, name2, code2, ...]."
       "The array is completely empty if there is no constant at all.";
 
   js.ArrayInitializer emitConstants(List<Constant> constants) {
     List<js.Expression> data = <js.Expression>[];
     if (constants.isNotEmpty) {
       int holderIndex = constants.first.holder.index;
       data.add(js.number(holderIndex));
       data.addAll(constants.expand((Constant constant) {
         assert(constant.holder.index == holderIndex);
         js.Expression code = constantEmitter.generate(constant.value);
         return [js.quoteName(constant.name), unparse(compiler, code)];
       }));
     }
     return new js.ArrayInitializer(data);
   }
 
   js.Block emitStaticNonFinalFields(List<StaticField> fields) {
     Iterable<js.Statement> statements = fields.map((StaticField field) {
-      return js.js.statement("#.# = #;",
-                             [field.holder.name, field.name, field.code]);
+      return js.js
+          .statement("#.# = #;", [field.holder.name, field.name, field.code]);
     });
     return new js.Block(statements.toList());
   }
 
   js.Expression emitLazilyInitializedStatics(List<StaticField> fields) {
-    Iterable fieldDescriptors = fields.expand((field) =>
-        [ js.quoteName(field.name),
+    Iterable fieldDescriptors = fields.expand((field) => [
+          js.quoteName(field.name),
           js.quoteName(namer.deriveLazyInitializerName(field.name)),
           js.number(field.holder.index),
-          emitLazyInitializer(field) ]);
+          emitLazyInitializer(field)
+        ]);
     return new js.ArrayInitializer(fieldDescriptors.toList(growable: false));
   }
 
   js.Block emitEagerClassInitializations(List<Library> libraries) {
     js.Statement createInstantiation(Class cls) {
       return js.js.statement('new #.#()', [cls.holder.name, cls.name]);
     }
 
-    List<js.Statement> instantiations =
-        libraries.expand((Library library) => library.classes)
-                 .where((Class cls) => cls.isEager)
-                 .map(createInstantiation)
-                 .toList(growable: false);
+    List<js.Statement> instantiations = libraries
+        .expand((Library library) => library.classes)
+        .where((Class cls) => cls.isEager)
+        .map(createInstantiation)
+        .toList(growable: false);
     return new js.Block(instantiations);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the mixin format.
-  static final String nativeInfoDescription =
-      "A class is encoded as follows:"
+  static final String nativeInfoDescription = "A class is encoded as follows:"
       "   [name, class-code, holder-index], or "
       "   [name, class-code, native-info, holder-index].";
 
   js.Expression emitLibrary(Library library) {
     Iterable staticDescriptors = library.statics.expand(emitStaticMethod);
 
     Iterable classDescriptors = library.classes.expand((Class cls) {
       js.Literal name = js.quoteName(cls.name);
       js.LiteralNumber holderIndex = js.number(cls.holder.index);
       js.Expression emittedClass = emitClass(cls);
@@ skipping 17 matching lines @@
     List<js.Name> fieldNames = const <js.Name>[];
 
     // If the class is not directly instantiated we only need it for inheritance
     // or RTI. In either case we don't need its fields.
     if (cls.isDirectlyInstantiated && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
     js.Name name = cls.name;
 
     Iterable<js.Name> assignments = fieldNames.map((js.Name field) {
-        return js.js("this.#field = #field", {"field": field});
-      });
+      return js.js("this.#field = #field", {"field": field});
+    });
 
     return js.js('function #(#) { # }', [name, fieldNames, assignments]);
   }
 
   Method _generateGetter(Field field) {
     String getterTemplateFor(int flags) {
       switch (flags) {
-        case 1: return "function() { return this[#]; }";
-        case 2: return "function(receiver) { return receiver[#]; }";
-        case 3: return "function(receiver) { return this[#]; }";
+        case 1:
+          return "function() { return this[#]; }";
+        case 2:
+          return "function(receiver) { return receiver[#]; }";
+        case 3:
+          return "function(receiver) { return this[#]; }";
       }
       return null;
     }
 
     js.Expression fieldName = js.quoteName(field.name);
     js.Expression code = js.js(getterTemplateFor(field.getterFlags), fieldName);
     js.Name getterName = namer.deriveGetterName(field.accessorName);
     return new StubMethod(getterName, code);
   }
 
   Method _generateSetter(Field field) {
     String setterTemplateFor(int flags) {
       switch (flags) {
-        case 1: return "function(val) { return this[#] = val; }";
-        case 2: return "function(receiver, val) { return receiver[#] = val; }";
-        case 3: return "function(receiver, val) { return this[#] = val; }";
+        case 1:
+          return "function(val) { return this[#] = val; }";
+        case 2:
+          return "function(receiver, val) { return receiver[#] = val; }";
+        case 3:
+          return "function(receiver, val) { return this[#] = val; }";
       }
       return null;
     }
     js.Expression fieldName = js.quoteName(field.name);
     js.Expression code = js.js(setterTemplateFor(field.setterFlags), fieldName);
     js.Name setterName = namer.deriveSetterName(field.accessorName);
     return new StubMethod(setterName, code);
   }
 
   Iterable<Method> _generateGettersSetters(Class cls) {
     Iterable<Method> getters = cls.fields
         .where((Field field) => field.needsGetter)
         .map(_generateGetter);
 
     Iterable<Method> setters = cls.fields
         .where((Field field) => field.needsUncheckedSetter)
         .map(_generateSetter);
 
     return [getters, setters].expand((x) => x);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the mixin format.
   static final String mixinFormatDescription =
       "Mixins have a reference to their mixin class at the place of the usual"
       "constructor. If they are instantiated the constructor follows the"
       "reference.";
 
   js.Expression emitClass(Class cls) {
-    List elements = [js.quoteName(cls.superclassName, allowNull: true),
-                     js.number(cls.superclassHolderIndex)];
+    List elements = [
+      js.quoteName(cls.superclassName, allowNull: true),
+      js.number(cls.superclassHolderIndex)
+    ];
 
     if (cls.isMixinApplication) {
       MixinApplication mixin = cls;
       elements.add(js.quoteName(mixin.mixinClass.name));
       elements.add(js.number(mixin.mixinClass.holder.index));
       if (cls.isDirectlyInstantiated) {
         elements.add(_generateConstructor(cls));
       }
     } else {
       elements.add(_generateConstructor(cls));
     }
     Iterable<Method> methods = cls.methods;
     Iterable<Method> isChecks = cls.isChecks;
     Iterable<Method> callStubs = cls.callStubs;
     Iterable<Method> typeVariableReaderStubs = cls.typeVariableReaderStubs;
     Iterable<Method> noSuchMethodStubs = cls.noSuchMethodStubs;
     Iterable<Method> gettersSetters = _generateGettersSetters(cls);
-    Iterable<Method> allMethods =
-        [methods, isChecks, callStubs, typeVariableReaderStubs,
-         noSuchMethodStubs, gettersSetters].expand((x) => x);
+    Iterable<Method> allMethods = [
+      methods,
+      isChecks,
+      callStubs,
+      typeVariableReaderStubs,
+      noSuchMethodStubs,
+      gettersSetters
+    ].expand((x) => x);
     elements.addAll(allMethods.expand(emitInstanceMethod));
 
     return unparse(compiler, new js.ArrayInitializer(elements));
   }
 
   js.Expression emitLazyInitializer(StaticField field) {
     assert(field.isLazy);
     return unparse(compiler, field.code);
   }
 
@@ skipping 82 matching lines @@
     if (method.optionalParameterDefaultValues is List) {
       List<ConstantValue> defaultValues = method.optionalParameterDefaultValues;
       Iterable<js.Expression> elements =
           defaultValues.map(generateConstantReference);
       return new js.ArrayInitializer(elements.toList());
     } else {
       Map<String, ConstantValue> defaultValues =
           method.optionalParameterDefaultValues;
       List<js.Property> properties = <js.Property>[];
       defaultValues.forEach((String name, ConstantValue value) {
-        properties.add(new js.Property(js.string(name),
-            generateConstantReference(value)));
+        properties.add(
+            new js.Property(js.string(name), generateConstantReference(value)));
       });
       return new js.ObjectInitializer(properties);
     }
   }
 
   Iterable<js.Expression> emitInstanceMethod(Method method) {
-
     List<js.Expression> makeNameCodePair(Method method) {
       return [js.quoteName(method.name), method.code];
     }
 
     List<js.Expression> makeNameCallNameCodeTriplet(ParameterStubMethod stub) {
       js.Expression callName = stub.callName == null
           ? new js.LiteralNull()
           : js.quoteName(stub.callName);
       return [js.quoteName(stub.name), callName, stub.code];
     }
@@ skipping 63 matching lines @@
         //     stub1_name, stub1_callName, stub1_code, ...]
         var data = [unparse(compiler, method.code)];
         data.add(js.quoteName(method.callName));
         data.add(js.quoteName(method.tearOffName));
         data.add(method.functionType);
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
         if (method.canBeApplied) {
           data.add(js.number(method.requiredParameterCount));
           data.add(_encodeOptionalParameterDefaultValues(method));
         }
-        return [js.quoteName(method.name), holderIndex,
-                new js.ArrayInitializer(data)];
+        return [
+          js.quoteName(method.name),
+          holderIndex,
+          new js.ArrayInitializer(data)
+        ];
       } else {
         method.parameterStubs.forEach(_addMethod);
       }
     }
     return output;
   }
 
   static final String setupProgramName = "setupProgram";
 
   static final String boilerplate = """
@@ skipping 330 matching lines @@
   // Initialize eager classes.
   #eagerClasses;
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 })(Date.now(), #code)
 }""";
-
 }