dartfmt pkg/compiler

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.
 
 part of dart2js.js_emitter.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 409 matching lines @@
   js.Expression generateEmbeddedGlobalAccess(String global) =>
       modelEmitter.generateEmbeddedGlobalAccess(global);
 
   js.Expression generateConstantReference(ConstantValue value) =>
       modelEmitter.generateConstantReference(value);
 
   js.Expression classReference(Class cls) {
     return js.js('#.#', [cls.holder.name, cls.name]);
   }
 
-  js.Statement emitMainFragment(
-      Program program,
+  js.Statement emitMainFragment(Program program,
       Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     MainFragment fragment = program.fragments.first;
 
-    Iterable<Holder> nonStaticStateHolders = program.holders
-        .where((Holder holder) => !holder.isStaticStateHolder);
+    Iterable<Holder> nonStaticStateHolders =
+        program.holders.where((Holder holder) => !holder.isStaticStateHolder);
 
-    return js.js.statement(mainBoilerplate,
-        {'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
-         'cyclicThrow': backend.emitter.staticFunctionAccess(
-                 backend.helpers.cyclicThrowHelper),
-         'operatorIsPrefix': js.string(namer.operatorIsPrefix),
-         'tearOffCode': new js.Block(buildTearOffCode(backend)),
-         'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
-         'embeddedInterceptorTags':
-             generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG),
-         'embeddedLeafTags': generateEmbeddedGlobalAccess(LEAF_TAGS),
-         'embeddedGlobalsObject': js.js("init"),
-         'holdersList': new js.ArrayInitializer(nonStaticStateHolders
-             .map((holder) => js.js("#", holder.name))
-             .toList(growable: false)),
-         'staticStateDeclaration': new js.VariableDeclaration(
-             namer.staticStateHolder, allowRename: false),
-         'staticState': js.js('#', namer.staticStateHolder),
-         'constantHolderReference': buildConstantHolderReference(program),
-         'holders': emitHolders(program.holders, fragment),
-         'callName': js.string(namer.callNameField),
-         'argumentCount': js.string(namer.requiredParameterField),
-         'defaultArgumentValues': js.string(namer.defaultValuesField),
-         'prototypes': emitPrototypes(fragment),
-         'inheritance': emitInheritance(fragment),
-         'aliases': emitInstanceMethodAliases(fragment),
-         'tearOffs': emitInstallTearOffs(fragment),
-         'constants': emitConstants(fragment),
-         'staticNonFinalFields': emitStaticNonFinalFields(fragment),
-         'lazyStatics': emitLazilyInitializedStatics(fragment),
-         'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
-         'nativeSupport': program.needsNativeSupport
-              ? emitNativeSupport(fragment)
-              : new js.EmptyStatement(),
-         'invokeMain': fragment.invokeMain,
-         });
+    return js.js.statement(mainBoilerplate, {
+      'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
+      'cyclicThrow': backend.emitter
+          .staticFunctionAccess(backend.helpers.cyclicThrowHelper),
+      'operatorIsPrefix': js.string(namer.operatorIsPrefix),
+      'tearOffCode': new js.Block(buildTearOffCode(backend)),
+      'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
+      'embeddedInterceptorTags':
+          generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG),
+      'embeddedLeafTags': generateEmbeddedGlobalAccess(LEAF_TAGS),
+      'embeddedGlobalsObject': js.js("init"),
+      'holdersList': new js.ArrayInitializer(nonStaticStateHolders
+          .map((holder) => js.js("#", holder.name))
+          .toList(growable: false)),
+      'staticStateDeclaration': new js.VariableDeclaration(
+          namer.staticStateHolder,
+          allowRename: false),
+      'staticState': js.js('#', namer.staticStateHolder),
+      'constantHolderReference': buildConstantHolderReference(program),
+      'holders': emitHolders(program.holders, fragment),
+      'callName': js.string(namer.callNameField),
+      'argumentCount': js.string(namer.requiredParameterField),
+      'defaultArgumentValues': js.string(namer.defaultValuesField),
+      'prototypes': emitPrototypes(fragment),
+      'inheritance': emitInheritance(fragment),
+      'aliases': emitInstanceMethodAliases(fragment),
+      'tearOffs': emitInstallTearOffs(fragment),
+      'constants': emitConstants(fragment),
+      'staticNonFinalFields': emitStaticNonFinalFields(fragment),
+      'lazyStatics': emitLazilyInitializedStatics(fragment),
+      'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
+      'nativeSupport': program.needsNativeSupport
+          ? emitNativeSupport(fragment)
+          : new js.EmptyStatement(),
+      'invokeMain': fragment.invokeMain,
+    });
   }
 
   js.Expression emitDeferredFragment(DeferredFragment fragment,
-                                     js.Expression deferredTypes,
-                                     List<Holder> holders) {
+      js.Expression deferredTypes, List<Holder> holders) {
     List<Holder> nonStaticStateHolders = holders
         .where((Holder holder) => !holder.isStaticStateHolder)
         .toList(growable: false);
 
     List<js.Statement> updateHolderAssignments = <js.Statement>[];
     for (int i = 0; i < nonStaticStateHolders.length; i++) {
       Holder holder = nonStaticStateHolders[i];
       updateHolderAssignments.add(js.js.statement(
           '#holder = updateHolder(holdersList[#index], #holder)',
-          {'index': js.number(i),
-           'holder': new js.VariableUse(holder.name)}));
+          {'index': js.number(i), 'holder': new js.VariableUse(holder.name)}));
     }
 
     // TODO(floitsch): don't just reference 'init'.
-    return js.js(deferredBoilerplate,
-    {'embeddedGlobalsObject': new js.Parameter('init'),
-     'staticState': new js.Parameter(namer.staticStateHolder),
-     'holders': emitHolders(holders, fragment),
-     'deferredHoldersList': new js.ArrayInitializer(nonStaticStateHolders
-         .map((holder) => js.js("#", holder.name))
-         .toList(growable: false)),
-     'updateHolders': new js.Block(updateHolderAssignments),
-     'prototypes': emitPrototypes(fragment),
-     'inheritance': emitInheritance(fragment),
-     'aliases': emitInstanceMethodAliases(fragment),
-     'tearOffs': emitInstallTearOffs(fragment),
-     'constants': emitConstants(fragment),
-     'staticNonFinalFields': emitStaticNonFinalFields(fragment),
-     'lazyStatics': emitLazilyInitializedStatics(fragment),
-     'types': deferredTypes,
-     // TODO(floitsch): only call emitNativeSupport if we need native.
-     'nativeSupport': emitNativeSupport(fragment),
+    return js.js(deferredBoilerplate, {
+      'embeddedGlobalsObject': new js.Parameter('init'),
+      'staticState': new js.Parameter(namer.staticStateHolder),
+      'holders': emitHolders(holders, fragment),
+      'deferredHoldersList': new js.ArrayInitializer(nonStaticStateHolders
+          .map((holder) => js.js("#", holder.name))
+          .toList(growable: false)),
+      'updateHolders': new js.Block(updateHolderAssignments),
+      'prototypes': emitPrototypes(fragment),
+      'inheritance': emitInheritance(fragment),
+      'aliases': emitInstanceMethodAliases(fragment),
+      'tearOffs': emitInstallTearOffs(fragment),
+      'constants': emitConstants(fragment),
+      'staticNonFinalFields': emitStaticNonFinalFields(fragment),
+      'lazyStatics': emitLazilyInitializedStatics(fragment),
+      'types': deferredTypes,
+      // TODO(floitsch): only call emitNativeSupport if we need native.
+      'nativeSupport': emitNativeSupport(fragment),
     });
   }
 
   /// Emits all holders, except for the static-state holder.
   ///
   /// The emitted holders contain classes (only the constructors) and all
   /// static functions.
   js.Statement emitHolders(List<Holder> holders, Fragment fragment) {
     // Skip the static-state holder in this function.
     holders = holders
@@ skipping 30 matching lines @@
     }
 
     // The generated code looks like this:
     //
     //    {
     //      var H = {...}, ..., G = {...};
     //      var holders = [ H, ..., G ];
     //    }
 
     List<js.Statement> statements = [
-      new js.ExpressionStatement(
-          new js.VariableDeclarationList(holders
-              .map(emitHolderInitialization)
-              .toList())),
-      js.js.statement('var holders = #', new js.ArrayInitializer(
-          holders
+      new js.ExpressionStatement(new js.VariableDeclarationList(
+          holders.map(emitHolderInitialization).toList())),
+      js.js.statement(
+          'var holders = #',
+          new js.ArrayInitializer(holders
               .map((holder) => new js.VariableUse(holder.name))
-              .toList(growable: false)))];
+              .toList(growable: false)))
+    ];
     return new js.Block(statements);
   }
 
   /// Returns a reference to the constant holder, or the JS-literal `null`.
   js.Expression buildConstantHolderReference(Program program) {
-    Holder constantHolder = program.holders
-        .firstWhere((Holder holder) => holder.isConstantsHolder,
-                    orElse: () => null);
+    Holder constantHolder = program.holders.firstWhere(
+        (Holder holder) => holder.isConstantsHolder,
+        orElse: () => null);
     if (constantHolder == null) return new js.LiteralNull();
     return new js.VariableUse(constantHolder.name);
   }
 
   /// Emits the given [method].
   ///
   /// A Dart method might result in several JavaScript functions, if it
   /// requires stubs. The returned map contains the original method and all
   /// the stubs it needs.
   Map<js.Name, js.Expression> emitStaticMethod(StaticMethod method) {
@@ skipping 33 matching lines @@
   }
 
   /// Emits the prototype-section of the fragment.
   ///
   /// This section updates the prototype-property of all constructors in the
   /// global holders.
   js.Statement emitPrototypes(Fragment fragment) {
     List<js.Statement> assignments = fragment.libraries
         .expand((Library library) => library.classes)
         .map((Class cls) => js.js.statement(
-            '#.prototype = #;',
-            [classReference(cls), emitPrototype(cls)]))
+            '#.prototype = #;', [classReference(cls), emitPrototype(cls)]))
         .toList(growable: false);
 
     return new js.Block(assignments);
   }
 
   /// Emits the prototype of the given class [cls].
   ///
   /// The prototype is generated as object literal. Inheritance is ignored.
   ///
   /// The prototype also includes the `is-property` that every class must have.
   // TODO(floitsch): we could avoid that property if we knew that it wasn't
   //    needed.
   js.Expression emitPrototype(Class cls) {
     Iterable<Method> methods = cls.methods;
     Iterable<Method> checkedSetters = cls.checkedSetters;
     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, checkedSetters, isChecks, callStubs, typeVariableReaderStubs,
-         noSuchMethodStubs, gettersSetters].expand((x) => x);
+    Iterable<Method> allMethods = [
+      methods,
+      checkedSetters,
+      isChecks,
+      callStubs,
+      typeVariableReaderStubs,
+      noSuchMethodStubs,
+      gettersSetters
+    ].expand((x) => x);
 
     List<js.Property> properties = <js.Property>[];
 
     if (cls.superclass == null) {
-      properties.add(new js.Property(js.string("constructor"),
-      classReference(cls)));
-      properties.add(new js.Property(namer.operatorIs(cls.element),
-      js.number(1)));
+      properties
+          .add(new js.Property(js.string("constructor"), classReference(cls)));
+      properties
+          .add(new js.Property(namer.operatorIs(cls.element), js.number(1)));
     }
 
     allMethods.forEach((Method method) {
       emitInstanceMethod(method)
           .forEach((js.Expression name, js.Expression code) {
         properties.add(new js.Property(name, code));
       });
     });
 
     return new js.ObjectInitializer(properties);
@@ skipping 68 matching lines @@
       for (ParameterStubMethod stubMethod in method.parameterStubs) {
         properties[stubMethod.name] = stubMethod.code;
       }
 
       if (method.isClosureCallMethod && method.canBeApplied) {
         properties[js.string(namer.callCatchAllName)] =
             js.quoteName(method.name);
         properties[js.string(namer.requiredParameterField)] =
             js.number(method.requiredParameterCount);
         properties[js.string(namer.defaultValuesField)] =
-             _encodeOptionalParameterDefaultValues(method);
+            _encodeOptionalParameterDefaultValues(method);
       }
     }
 
     return properties;
   }
 
   /// Emits the inheritance block of the fragment.
   ///
   /// In this section prototype chains are updated and mixin functions are
   /// copied.
   js.Statement emitInheritance(Fragment fragment) {
     List<js.Expression> inheritCalls = <js.Expression>[];
     List<js.Expression> mixinCalls = <js.Expression>[];
 
     Set<Class> emittedClasses = new Set<Class>();
 
     void emitInheritanceForClass(cls) {
       if (cls == null || emittedClasses.contains(cls)) return;
 
       Class superclass = cls.superclass;
       emitInheritanceForClass(superclass);
 
       js.Expression superclassReference = (superclass == null)
           ? new js.LiteralNull()
           : classReference(superclass);
 
-      inheritCalls.add(js.js('inherit(#, #)',
-          [classReference(cls), superclassReference]));
+      inheritCalls.add(
+          js.js('inherit(#, #)', [classReference(cls), superclassReference]));
 
       emittedClasses.add(cls);
     }
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
         emitInheritanceForClass(cls);
 
         if (cls.isMixinApplication) {
           MixinApplication mixin = cls;
@@ skipping 13 matching lines @@
   ///
   /// This step consists of simply copying JavaScript functions to their
   /// aliased names so they point to the same function.
   js.Statement emitInstanceMethodAliases(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
         for (InstanceMethod method in cls.methods) {
           if (method.aliasName != null) {
-            assignments.add(js.js.statement(
-                '#.prototype.# = #.prototype.#',
-                [classReference(cls), js.quoteName(method.aliasName),
-                 classReference(cls), js.quoteName(method.name)]));
-
+            assignments.add(js.js.statement('#.prototype.# = #.prototype.#', [
+              classReference(cls),
+              js.quoteName(method.aliasName),
+              classReference(cls),
+              js.quoteName(method.name)
+            ]));
           }
         }
       }
     }
     return new js.Block(assignments);
   }
 
   /// Encodes the optional default values so that the runtime Function.apply
   /// can use them.
   js.Expression _encodeOptionalParameterDefaultValues(DartMethod method) {
     // TODO(herhut): Replace [js.LiteralNull] with [js.ArrayHole].
     if (method.optionalParameterDefaultValues is List) {
       List<ConstantValue> defaultValues = method.optionalParameterDefaultValues;
       Iterable<js.Expression> elements =
           defaultValues.map(generateConstantReference);
       return js.js('function() { return #; }',
           new js.ArrayInitializer(elements.toList()));
     } else {
       Map<String, ConstantValue> defaultValues =
           method.optionalParameterDefaultValues;
       List<js.Property> properties = <js.Property>[];
       List<String> names = defaultValues.keys.toList(growable: false);
       // Sort the names the same way we sort them for the named-argument calling
       // convention.
       names.sort();
 
       for (String name in names) {
         ConstantValue value = defaultValues[name];
-        properties.add(new js.Property(js.string(name),
-        generateConstantReference(value)));
+        properties.add(
+            new js.Property(js.string(name), generateConstantReference(value)));
       }
-      return js.js('function() { return #; }',
-          new js.ObjectInitializer(properties));
+      return js.js(
+          'function() { return #; }', new js.ObjectInitializer(properties));
     }
   }
 
   /// Emits the statement that installs a tear off for a method.
   ///
   /// Tear-offs might be passed to `Function.apply` which means that all
   /// calling-conventions (with or without optional positional/named arguments)
   /// are possible. As such, the tear-off needs enough information to fill in
   /// missing parameters.
   js.Statement emitInstallTearOff(js.Expression container, DartMethod method) {
@@ skipping 32 matching lines @@
       isIntercepted = backend.isInterceptedMethod(method.element);
     }
     int requiredParameterCount = 0;
     js.Expression optionalParameterDefaultValues = new js.LiteralNull();
     if (method.canBeApplied) {
       requiredParameterCount = method.requiredParameterCount;
       optionalParameterDefaultValues =
           _encodeOptionalParameterDefaultValues(method);
     }
 
-    return js.js.statement('''
+    return js.js.statement(
+        '''
         installTearOff(#container, #getterName, #isStatic, #isIntercepted,
                        #requiredParameterCount, #optionalParameterDefaultValues,
                        #callNames, #funsOrNames, #funType)''',
         {
           "container": container,
           "getterName": js.quoteName(method.tearOffName),
           "isStatic": new js.LiteralBool(method.isStatic),
           "isIntercepted": new js.LiteralBool(isIntercepted),
           "requiredParameterCount": js.number(requiredParameterCount),
           "optionalParameterDefaultValues": optionalParameterDefaultValues,
@@ skipping 31 matching lines @@
   }
 
   /// Emits the constants section.
   js.Statement emitConstants(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
     for (Constant constant in fragment.constants) {
       // TODO(floitsch): instead of just updating the constant holder, we should
       // find the constants that don't have any dependency on other constants
       // and create an object-literal with them (and assign it to the
       // constant-holder variable).
-      assignments.add(js.js.statement('#.# = #',
-          [constant.holder.name,
-           constant.name,
-           constantEmitter.generate(constant.value)]));
+      assignments.add(js.js.statement('#.# = #', [
+        constant.holder.name,
+        constant.name,
+        constantEmitter.generate(constant.value)
+      ]));
     }
     return new js.Block(assignments);
   }
 
-
   /// Emits the static non-final fields section.
   ///
   /// This section initializes all static non-final fields that don't require
   /// an initializer.
   js.Block emitStaticNonFinalFields(Fragment fragment) {
     List<StaticField> fields = fragment.staticNonFinalFields;
     // TODO(floitsch): instead of assigning the fields one-by-one we should
     // create a literal and assign it to the static-state holder.
     // TODO(floitsch): if we don't make a literal we should at least initialize
     // statics that have the same initial value in the same expression:
     //    `$.x = $.y = $.z = null;`.
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       assert(field.holder.isStaticStateHolder);
-      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());
   }
 
   /// Emits lazy fields.
   ///
   /// This section initializes all static (final and non-final) fields that
   /// require an initializer.
   js.Block emitLazilyInitializedStatics(Fragment fragment) {
     List<StaticField> fields = fragment.staticLazilyInitializedFields;
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       assert(field.holder.isStaticStateHolder);
-      return js.js.statement("lazy(#, #, #, #);",
-          [field.holder.name,
-           js.quoteName(field.name),
-           js.quoteName(namer.deriveLazyInitializerName(field.name)),
-           field.code]);
+      return js.js.statement("lazy(#, #, #, #);", [
+        field.holder.name,
+        js.quoteName(field.name),
+        js.quoteName(namer.deriveLazyInitializerName(field.name)),
+        field.code
+      ]);
     });
 
     return new js.Block(statements.toList());
   }
 
   /// Emits the embedded globals that are needed for deferred loading.
   ///
   /// This function is only invoked for the main fragment.
   ///
   /// The [loadMap] contains a map from load-ids (for each deferred library)
   /// to the list of generated fragments that must be installed when the
   /// deferred library is loaded.
   Iterable<js.Property> emitEmbeddedGlobalsForDeferredLoading(
       Map<String, List<Fragment>> loadMap,
       Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     if (loadMap.isEmpty) return [];
 
     List<js.Property> globals = <js.Property>[];
 
     js.ArrayInitializer fragmentUris(List<Fragment> fragments) {
       return js.stringArray(fragments.map((DeferredFragment fragment) =>
           "${fragment.outputFileName}.${ModelEmitter.deferredExtension}"));
     }
     js.ArrayInitializer fragmentHashes(List<Fragment> fragments) {
-      return new js.ArrayInitializer(
-          fragments
-              .map((fragment) => deferredLoadHashes[fragment])
-              .toList(growable: false));
+      return new js.ArrayInitializer(fragments
+          .map((fragment) => deferredLoadHashes[fragment])
+          .toList(growable: false));
     }
 
     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_INITIALIZED),
-        js.js("Object.create(null)")));
+    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_INITIALIZED), js.js("Object.create(null)")));
 
     String deferredGlobal = ModelEmitter.deferredInitializersGlobal;
     js.Expression isHunkLoadedFunction =
         js.js("function(hash) { return !!$deferredGlobal[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 !!#deferredInitialized[hash]; }",
-            {'deferredInitialized':
-                generateEmbeddedGlobalAccess(DEFERRED_INITIALIZED)});
-    globals.add(new js.Property(js.string(IS_HUNK_INITIALIZED),
-        isHunkInitializedFunction));
+    js.Expression isHunkInitializedFunction = js.js(
+        "function(hash) { return !!#deferredInitialized[hash]; }", {
+      'deferredInitialized': generateEmbeddedGlobalAccess(DEFERRED_INITIALIZED)
+    });
+    globals.add(new js.Property(
+        js.string(IS_HUNK_INITIALIZED), isHunkInitializedFunction));
 
     /// See [emitEmbeddedGlobalsForDeferredLoading] for the format of the
     /// deferred hunk.
-    js.Expression initializeLoadedHunkFunction =
-    js.js("""
+    js.Expression initializeLoadedHunkFunction = js.js(
+        """
             function(hash) {
               initializeDeferredHunk($deferredGlobal[hash]);
               #deferredInitialized[hash] = true;
-            }""", {'deferredInitialized':
-                    generateEmbeddedGlobalAccess(DEFERRED_INITIALIZED)});
+            }""",
+        {
+          'deferredInitialized':
+              generateEmbeddedGlobalAccess(DEFERRED_INITIALIZED)
+        });
 
-    globals.add(new js.Property(js.string(INITIALIZE_LOADED_HUNK),
-                                initializeLoadedHunkFunction));
+    globals.add(new js.Property(
+        js.string(INITIALIZE_LOADED_HUNK), initializeLoadedHunkFunction));
 
     return globals;
   }
 
   /// Emits the [MANGLED_GLOBAL_NAMES] embedded global.
   ///
   /// This global maps minified names for selected classes (some important
   /// core classes, and some native classes) to their unminified names.
   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
+    ];
     // TODO(floitsch): this should probably be on a per-fragment basis.
     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));
   }
 
   /// Emits the [GET_TYPE_FROM_NAME] embedded global.
   ///
   /// This embedded global provides a way to go from a class name (which is
   /// also the constructor's name) to the constructor itself.
   js.Property emitGetTypeFromName() {
     js.Expression function = js.js("getGlobalFromName");
     return new js.Property(js.string(GET_TYPE_FROM_NAME), function);
   }
@@ skipping 11 matching lines @@
 
     metadataGlobals.add(createGlobal(program.metadata, METADATA));
     js.Expression types =
         program.metadataTypesForOutputUnit(program.mainFragment.outputUnit);
     metadataGlobals.add(createGlobal(types, TYPES));
 
     return metadataGlobals;
   }
 
   /// Emits all embedded globals.
-  js.Statement emitEmbeddedGlobals(
-      Program program,
+  js.Statement emitEmbeddedGlobals(Program program,
       Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     List<js.Property> globals = <js.Property>[];
 
     if (program.loadMap.isNotEmpty) {
       globals.addAll(emitEmbeddedGlobalsForDeferredLoading(
           program.loadMap, deferredLoadHashes));
     }
 
     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 staticStateName = namer.staticStateHolder;
       // TODO(floitsch): this doesn't create a new isolate, but just reuses
       // the current static state. Since we don't run multiple isolates in the
       // same JavaScript context (except for testing) this shouldn't have any
       // impact on real-world programs, though.
-      globals.add(
-          new js.Property(js.string(CREATE_NEW_ISOLATE),
-                          js.js('function () { return $staticStateName; }')));
+      globals.add(new js.Property(js.string(CREATE_NEW_ISOLATE),
+          js.js('function () { return $staticStateName; }')));
 
       js.Expression nameToClosureFunction = js.js('''
         // First fetch the static function. From there we can execute its
         // getter function which builds a Dart closure.
         function(name) {
            var staticFunction = getGlobalFromName(name);
            var getterFunction = staticFunction.$tearOffPropertyName;
            return getterFunction();
          }''');
-      globals.add(new js.Property(js.string(STATIC_FUNCTION_NAME_TO_CLOSURE),
-                                  nameToClosureFunction));
+      globals.add(new js.Property(
+          js.string(STATIC_FUNCTION_NAME_TO_CLOSURE), nameToClosureFunction));
 
-      globals.add(
-          new js.Property(js.string(CLASS_ID_EXTRACTOR),
-                          js.js('function(o) { return o.constructor.name; }')));
+      globals.add(new js.Property(js.string(CLASS_ID_EXTRACTOR),
+          js.js('function(o) { return o.constructor.name; }')));
 
       js.Expression extractFieldsFunction = js.js('''
       function(o) {
         var constructor = o.constructor;
         var fieldNames = constructor.$cachedClassFieldNames;
         if (!fieldNames) {
           // Extract the fields from an empty unmodified object.
           var empty = new constructor();
           // This gives us the keys that the constructor sets.
           fieldNames = constructor.$cachedClassFieldNames = Object.keys(empty);
         }
         var result = new Array(fieldNames.length);
         for (var i = 0; i < fieldNames.length; i++) {
           result[i] = o[fieldNames[i]];
         }
         return result;
       }''');
-      globals.add(new js.Property(js.string(CLASS_FIELDS_EXTRACTOR),
-                                  extractFieldsFunction));
+      globals.add(new js.Property(
+          js.string(CLASS_FIELDS_EXTRACTOR), extractFieldsFunction));
 
       js.Expression createInstanceFromClassIdFunction = js.js('''
         function(name) {
           var constructor = getGlobalFromName(name);
           return new constructor();
         }
       ''');
       globals.add(new js.Property(js.string(INSTANCE_FROM_CLASS_ID),
-                                  createInstanceFromClassIdFunction));
+          createInstanceFromClassIdFunction));
 
       js.Expression initializeEmptyInstanceFunction = js.js('''
       function(name, o, fields) {
         var constructor = o.constructor;
         // By construction the object `o` is an empty object with the same
         // keys as the one we used in the extract-fields function.
         var fieldNames = Object.keys(o);
         if (fieldNames.length != fields.length) {
           throw new Error("Mismatch during deserialization.");
         }
         for (var i = 0; i < fields.length; i++) {
           o[fieldNames[i]] = fields[i];
         }
         return o;
       }''');
       globals.add(new js.Property(js.string(INITIALIZE_EMPTY_INSTANCE),
-                                  initializeEmptyInstanceFunction));
+          initializeEmptyInstanceFunction));
     }
 
     globals.add(emitMangledGlobalNames());
 
     // The [MANGLED_NAMES] table must contain the mapping for const symbols.
     // Without const symbols, the table is only relevant for reflection and
     // therefore unused in this emitter.
     List<js.Property> mangledNamesProperties = <js.Property>[];
     program.symbolsMap.forEach((js.Name mangledName, String unmangledName) {
-      mangledNamesProperties.add(
-          new js.Property(mangledName, js.string(unmangledName)));
+      mangledNamesProperties
+          .add(new js.Property(mangledName, js.string(unmangledName)));
     });
-    globals.add(new js.Property(
-        js.string(MANGLED_NAMES),
+    globals.add(new js.Property(js.string(MANGLED_NAMES),
         new js.ObjectInitializer(mangledNamesProperties)));
 
     globals.add(emitGetTypeFromName());
 
     globals.addAll(emitMetadata(program));
 
     if (program.needsNativeSupport) {
-      globals.add(new js.Property(js.string(INTERCEPTORS_BY_TAG),
-          new js.LiteralNull()));
-      globals.add(new js.Property(js.string(LEAF_TAGS),
-          new js.LiteralNull()));
+      globals.add(new js.Property(
+          js.string(INTERCEPTORS_BY_TAG), new js.LiteralNull()));
+      globals.add(new js.Property(js.string(LEAF_TAGS), new js.LiteralNull()));
     }
 
     js.ObjectInitializer globalsObject = new js.ObjectInitializer(globals);
 
     return js.js.statement('var init = #;', globalsObject);
   }
 
   /// Emits data needed for native classes.
   ///
   /// We don't try to reduce the size of the native data, but rather build
   /// JavaScript object literals that contain all the information directly.
   /// This means that the output size is bigger, but that the startup is faster.
   ///
   /// This function is the static equivalent of
   /// [NativeGenerator.buildNativeInfoHandler].
   js.Statement emitNativeSupport(Fragment fragment) {
     List<js.Statement> statements = <js.Statement>[];
 
     // The isolate-affinity tag must only be initialized once per program.
     if (fragment.isMainFragment &&
         NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
       statements.add(NativeGenerator.generateIsolateAffinityTagInitialization(
-              backend,
-              generateEmbeddedGlobalAccess,
-              js.js("""
+          backend,
+          generateEmbeddedGlobalAccess,
+          js.js(
+              """
         // On V8, the 'intern' function converts a string to a symbol, which
         // makes property access much faster.
         function (s) {
           var o = {};
           o[s] = 1;
           return Object.keys(convertToFastObject(o))[0];
-        }""", [])));
+        }""",
+              [])));
     }
 
     Map<String, js.Expression> interceptorsByTag = <String, js.Expression>{};
     Map<String, js.Expression> leafTags = <String, js.Expression>{};
     js.Statement subclassAssignment = new js.EmptyStatement();
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
         if (cls.nativeLeafTags != null) {
           for (String tag in cls.nativeLeafTags) {
             interceptorsByTag[tag] = classReference(cls);
             leafTags[tag] = new js.LiteralBool(true);
           }
         }
         if (cls.nativeNonLeafTags != null) {
           for (String tag in cls.nativeNonLeafTags) {
             interceptorsByTag[tag] = classReference(cls);
             leafTags[tag] = new js.LiteralBool(false);
           }
           if (cls.nativeExtensions != null) {
             List<Class> subclasses = cls.nativeExtensions;
             js.Expression value = js.string(cls.nativeNonLeafTags[0]);
             for (Class subclass in subclasses) {
-              value = js.js('#.# = #',
-                  [classReference(subclass),
-                   NATIVE_SUPERCLASS_TAG_NAME,
-                   js.string(cls.nativeNonLeafTags[0])]);
+              value = js.js('#.# = #', [
+                classReference(subclass),
+                NATIVE_SUPERCLASS_TAG_NAME,
+                js.string(cls.nativeNonLeafTags[0])
+              ]);
             }
             subclassAssignment = new js.ExpressionStatement(value);
           }
         }
       }
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
-    statements.add(js.js.statement("setOrUpdateLeafTags(#);",
-        js.objectLiteral(leafTags)));
+    statements.add(
+        js.js.statement("setOrUpdateLeafTags(#);", js.objectLiteral(leafTags)));
     statements.add(subclassAssignment);
 
     return new js.Block(statements);
   }
 }