dartfmt pkg/compiler

pkg/compiler/lib/src/js_emitter/full_emitter/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.full_emitter;
 
 import 'dart:convert';
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
-import 'package:js_runtime/shared/embedded_names.dart' show
-    JsBuiltin,
-    JsGetName;
+import 'package:js_runtime/shared/embedded_names.dart'
+    show JsBuiltin, JsGetName;
 
 import '../headers.dart';
 import '../js_emitter.dart' hide Emitter;
 import '../js_emitter.dart' as js_emitter show Emitter;
 import '../model.dart';
 import '../program_builder/program_builder.dart';
 import '../constant_ordering.dart' show deepCompareConstants;
 
 import '../../common.dart';
-import '../../common/names.dart' show
-    Names;
-import '../../compiler.dart' show
-    Compiler;
+import '../../common/names.dart' show Names;
+import '../../compiler.dart' show Compiler;
 import '../../constants/values.dart';
-import '../../core_types.dart' show
-    CoreClasses;
-import '../../dart_types.dart' show
-    DartType;
+import '../../core_types.dart' show CoreClasses;
+import '../../dart_types.dart' show DartType;
 import '../../deferred_load.dart' show OutputUnit;
-import '../../elements/elements.dart' show
-    ClassElement,
-    ConstructorBodyElement,
-    Element,
-    Elements,
-    ElementKind,
-    FieldElement,
-    FunctionElement,
-    FunctionSignature,
-    LibraryElement,
-    MetadataAnnotation,
-    MethodElement,
-    MemberElement,
-    Name,
-    ParameterElement,
-    TypedefElement,
-    TypeVariableElement,
-    VariableElement;
+import '../../elements/elements.dart'
+    show
+        ClassElement,
+        ConstructorBodyElement,
+        Element,
+        Elements,
+        ElementKind,
+        FieldElement,
+        FunctionElement,
+        FunctionSignature,
+        LibraryElement,
+        MetadataAnnotation,
+        MethodElement,
+        MemberElement,
+        Name,
+        ParameterElement,
+        TypedefElement,
+        TypeVariableElement,
+        VariableElement;
 import '../../hash/sha1.dart' show Hasher;
 import '../../io/code_output.dart';
-import '../../io/line_column_provider.dart' show
-    LineColumnCollector,
-    LineColumnProvider;
-import '../../io/source_map_builder.dart' show
-    SourceMapBuilder;
+import '../../io/line_column_provider.dart'
+    show LineColumnCollector, LineColumnProvider;
+import '../../io/source_map_builder.dart' show SourceMapBuilder;
 import '../../js/js.dart' as jsAst;
 import '../../js/js.dart' show js;
-import '../../js_backend/backend_helpers.dart' show
-    BackendHelpers;
-import '../../js_backend/js_backend.dart' show
-    CheckedModeHelper,
-    CompoundName,
-    ConstantEmitter,
-    CustomElementsAnalysis,
-    GetterName,
-    JavaScriptBackend,
-    JavaScriptConstantCompiler,
-    Namer,
-    RuntimeTypes,
-    SetterName,
-    Substitution,
-    TypeCheck,
-    TypeChecks,
-    TypeVariableHandler;
-import '../../universe/call_structure.dart' show
-    CallStructure;
-import '../../universe/selector.dart' show
-    Selector;
-import '../../util/characters.dart' show
-    $$,
-    $A,
-    $HASH,
-    $PERIOD,
-    $Z,
-    $a,
-    $z;
-import '../../util/uri_extras.dart' show
-    relativize;
-import '../../util/util.dart' show
-    equalElements;
+import '../../js_backend/backend_helpers.dart' show BackendHelpers;
+import '../../js_backend/js_backend.dart'
+    show
+        CheckedModeHelper,
+        CompoundName,
+        ConstantEmitter,
+        CustomElementsAnalysis,
+        GetterName,
+        JavaScriptBackend,
+        JavaScriptConstantCompiler,
+        Namer,
+        RuntimeTypes,
+        SetterName,
+        Substitution,
+        TypeCheck,
+        TypeChecks,
+        TypeVariableHandler;
+import '../../universe/call_structure.dart' show CallStructure;
+import '../../universe/selector.dart' show Selector;
+import '../../util/characters.dart' show $$, $A, $HASH, $PERIOD, $Z, $a, $z;
+import '../../util/uri_extras.dart' show relativize;
+import '../../util/util.dart' show equalElements;
 
 part 'class_builder.dart';
 part 'class_emitter.dart';
 part 'code_emitter_helper.dart';
 part 'container_builder.dart';
 part 'declarations.dart';
 part 'deferred_output_unit_hash.dart';
 part 'interceptor_emitter.dart';
 part 'nsm_emitter.dart';
 part 'setup_program_builder.dart';
 
-
 class Emitter implements js_emitter.Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   // The following fields will be set to copies of the program-builder's
   // collector.
   Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists;
   Map<OutputUnit, Set<LibraryElement>> outputLibraryLists;
   List<TypedefElement> typedefsNeededForReflection;
 
@@ skipping 80 matching lines @@
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
-        outputUnit,
-        () => new List<jsAst.Node>());
+        outputUnit, () => new List<jsAst.Node>());
   }
 
   List<jsAst.Expression> cspPrecompiledConstructorNamesFor(
       OutputUnit outputUnit) {
     return _cspPrecompiledConstructorNames.putIfAbsent(
-        outputUnit,
-        () => new List<jsAst.Expression>());
+        outputUnit, () => new List<jsAst.Expression>());
   }
 
   /// Erases the precompiled information for csp mode for all output units.
   /// Used by the incremental compiler.
   void clearCspPrecompiledNodes() {
     _cspPrecompiledFunctions.clear();
     _cspPrecompiledConstructorNames.clear();
   }
 
   @override
   String get patchVersion => "full";
 
   @override
   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;
   }
 
   @override
   int compareConstants(ConstantValue a, ConstantValue b) {
     // Inlined constants don't affect the order and sometimes don't even have
@@ skipping 22 matching lines @@
     if (value.isFunction) {
       FunctionConstantValue functionConstant = value;
       return isolateStaticClosureAccess(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('#.#', [namer.globalObjectForConstant(value),
-                      namer.constantName(value)]);
+    return js('#.#',
+        [namer.globalObjectForConstant(value), namer.constantName(value)]);
   }
 
   jsAst.Expression constantInitializerExpression(ConstantValue value) {
     return constantEmitter.generate(value);
   }
 
   String get name => 'CodeEmitter';
 
-  String get finishIsolateConstructorName
-      => '${namer.isolateName}.\$finishIsolateConstructor';
-  String get isolatePropertiesName
-      => '${namer.isolateName}.${namer.isolatePropertiesName}';
-  String get lazyInitializerProperty
-      => r'$lazy';
-  String get lazyInitializerName
-      => '${namer.isolateName}.${lazyInitializerProperty}';
+  String get finishIsolateConstructorName =>
+      '${namer.isolateName}.\$finishIsolateConstructor';
+  String get isolatePropertiesName =>
+      '${namer.isolateName}.${namer.isolatePropertiesName}';
+  String get lazyInitializerProperty => r'$lazy';
+  String get lazyInitializerName =>
+      '${namer.isolateName}.${lazyInitializerProperty}';
   String get initName => 'init';
 
-  jsAst.Name get makeConstListProperty
-      => namer.internalGlobal('makeConstantList');
+  jsAst.Name get makeConstListProperty =>
+      namer.internalGlobal('makeConstantList');
 
   /// The name of the property that contains all field names.
   ///
   /// This property is added to constructors when isolate support is enabled.
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers$";
 
   /// Contains the global state that is needed to initialize and load a
   /// deferred library.
   String get globalsHolder => r"$globals$";
 
   @override
   bool get supportsReflection => true;
 
   @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
   jsAst.PropertyAccess globalPropertyAccess(Element element) {
     jsAst.Name name = namer.globalPropertyName(element);
     jsAst.PropertyAccess pa = new jsAst.PropertyAccess(
-        new jsAst.VariableUse(namer.globalObjectFor(element)),
-        name);
+        new jsAst.VariableUse(namer.globalObjectFor(element)), name);
     return pa;
   }
 
   @override
   jsAst.Expression isolateLazyInitializerAccess(FieldElement element) {
-     return jsAst.js('#.#', [namer.globalObjectFor(element),
-                             namer.lazyInitializerName(element)]);
-   }
+    return jsAst.js('#.#',
+        [namer.globalObjectFor(element), namer.lazyInitializerName(element)]);
+  }
 
   @override
   jsAst.Expression isolateStaticClosureAccess(FunctionElement element) {
-     return jsAst.js('#.#()',
-         [namer.globalObjectFor(element), namer.staticClosureName(element)]);
-   }
+    return jsAst.js('#.#()',
+        [namer.globalObjectFor(element), namer.staticClosureName(element)]);
+  }
 
   @override
   jsAst.PropertyAccess staticFieldAccess(FieldElement element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.PropertyAccess staticFunctionAccess(FunctionElement element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.PropertyAccess constructorAccess(ClassElement element) {
     return globalPropertyAccess(element);
   }
 
   @override
-  jsAst.PropertyAccess prototypeAccess(ClassElement element,
-                                       bool hasBeenInstantiated) {
+  jsAst.PropertyAccess prototypeAccess(
+      ClassElement element, bool hasBeenInstantiated) {
     return jsAst.js('#.prototype', constructorAccess(element));
   }
 
   @override
   jsAst.PropertyAccess interceptorClassAccess(ClassElement element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.PropertyAccess typeAccess(Element element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.Template templateForBuiltin(JsBuiltin builtin) {
     switch (builtin) {
       case JsBuiltin.dartObjectConstructor:
-        return jsAst.js.expressionTemplateYielding(
-            typeAccess(coreClasses.objectClass));
+        return jsAst.js
+            .expressionTemplateYielding(typeAccess(coreClasses.objectClass));
 
       case JsBuiltin.isCheckPropertyToJsConstructorName:
         int isPrefixLength = namer.operatorIsPrefix.length;
         return jsAst.js.expressionTemplateFor('#.substring($isPrefixLength)');
 
       case JsBuiltin.isFunctionType:
         return backend.rtiEncoder.templateForIsFunctionType;
 
       case JsBuiltin.rawRtiToJsConstructorName:
         return jsAst.js.expressionTemplateFor("#.$typeNameProperty");
 
       case JsBuiltin.rawRuntimeType:
         return jsAst.js.expressionTemplateFor("#.constructor");
 
       case JsBuiltin.createFunctionTypeRti:
         return backend.rtiEncoder.templateForCreateFunctionType;
 
       case JsBuiltin.isSubtype:
         // TODO(floitsch): move this closer to where is-check properties are
         // built.
         String isPrefix = namer.operatorIsPrefix;
-        return jsAst.js.expressionTemplateFor(
-            "('$isPrefix' + #) in #.prototype");
+        return jsAst.js
+            .expressionTemplateFor("('$isPrefix' + #) in #.prototype");
 
       case JsBuiltin.isGivenTypeRti:
         return jsAst.js.expressionTemplateFor('#.$typeNameProperty === #');
 
       case JsBuiltin.getMetadata:
         String metadataAccess =
             generateEmbeddedGlobalAccessString(embeddedNames.METADATA);
         return jsAst.js.expressionTemplateFor("$metadataAccess[#]");
 
       case JsBuiltin.getType:
         String typesAccess =
             generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
         return jsAst.js.expressionTemplateFor("$typesAccess[#]");
 
       case JsBuiltin.createDartClosureFromNameOfStaticFunction:
         // The global-functions map contains a map from name to tear-off
         // getters.
         String functionGettersMap =
             generateEmbeddedGlobalAccessString(embeddedNames.GLOBAL_FUNCTIONS);
         return jsAst.js.expressionTemplateFor("$functionGettersMap[#]()");
 
       default:
-        reporter.internalError(NO_LOCATION_SPANNABLE,
-            "Unhandled Builtin: $builtin");
+        reporter.internalError(
+            NO_LOCATION_SPANNABLE, "Unhandled Builtin: $builtin");
         return null;
     }
   }
 
-  List<jsAst.Statement> buildTrivialNsmHandlers(){
+  List<jsAst.Statement> buildTrivialNsmHandlers() {
     return nsmEmitter.buildTrivialNsmHandlers();
   }
 
   jsAst.Statement buildNativeInfoHandler(
       jsAst.Expression infoAccess,
       jsAst.Expression constructorAccess,
       jsAst.Expression subclassReadGenerator(jsAst.Expression subclass),
       jsAst.Expression interceptorsByTagAccess,
       jsAst.Expression leafTagsAccess) {
     return NativeGenerator.buildNativeInfoHandler(infoAccess, constructorAccess,
-                                                  subclassReadGenerator,
-                                                  interceptorsByTagAccess,
-                                                  leafTagsAccess);
+        subclassReadGenerator, interceptorsByTagAccess, leafTagsAccess);
   }
 
   jsAst.ObjectInitializer generateInterceptedNamesSet() {
     return interceptorEmitter.generateInterceptedNamesSet();
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
     if (!element.isClass) return false;
     return (element == coreClasses.intClass ||
-            element == coreClasses.doubleClass ||
-            element == coreClasses.numClass ||
-            element == coreClasses.stringClass ||
-            element == coreClasses.boolClass ||
-            element == coreClasses.nullClass ||
-            element == coreClasses.listClass);
+        element == coreClasses.doubleClass ||
+        element == coreClasses.numClass ||
+        element == coreClasses.stringClass ||
+        element == coreClasses.boolClass ||
+        element == coreClasses.nullClass ||
+        element == coreClasses.listClass);
   }
 
   /// Returns the "reflection name" of an [Element] or [Selector].
   /// The reflection name of a getter 'foo' is 'foo'.
   /// The reflection name of a setter 'foo' is 'foo='.
   /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
   /// number of required arguments, M is the number of optional arguments, and
   /// O is the named arguments.
   /// The reflection name of a constructor is similar to a regular method but
   /// starts with 'new '.
   /// The reflection name of class 'C' is 'C'.
   /// An anonymous mixin application has no reflection name.
   /// This is used by js_mirrors.dart.
   String getReflectionName(elementOrSelector, jsAst.Name mangledName) {
     String name = elementOrSelector.name;
     if (backend.shouldRetainName(name) ||
         elementOrSelector is Element &&
-        // Make sure to retain names of unnamed constructors, and
-        // for common native types.
-        ((name == '' &&
-          backend.isAccessibleByReflection(elementOrSelector)) ||
-         _isNativeTypeNeedingReflectionName(elementOrSelector))) {
-
+            // Make sure to retain names of unnamed constructors, and
+            // for common native types.
+            ((name == '' &&
+                    backend.isAccessibleByReflection(elementOrSelector)) ||
+                _isNativeTypeNeedingReflectionName(elementOrSelector))) {
       // TODO(ahe): Enable the next line when I can tell the difference between
       // an instance method and a global.  They may have the same mangled name.
       // if (recordedMangledNames.contains(mangledName)) return null;
       recordedMangledNames.add(mangledName);
       return getReflectionNameInternal(elementOrSelector, mangledName);
     }
     return null;
   }
 
-  String getReflectionNameInternal(elementOrSelector,
-                                   jsAst.Name mangledName) {
+  String getReflectionNameInternal(elementOrSelector, jsAst.Name mangledName) {
     String name = namer.privateName(elementOrSelector.memberName);
     if (elementOrSelector.isGetter) return name;
     if (elementOrSelector.isSetter) {
       if (mangledName is! SetterName) return '$name=';
       SetterName setterName = mangledName;
       jsAst.Name base = setterName.base;
       jsAst.Name getter = namer.deriveGetterName(base);
       mangledFieldNames.putIfAbsent(getter, () => name);
       assert(mangledFieldNames[getter] == name);
       recordedMangledNames.add(getter);
       // TODO(karlklose,ahe): we do not actually need to store information
       // about the name of this setter in the output, but it is needed for
       // marking the function as invokable by reflection.
       return '$name=';
     }
     if (elementOrSelector is Element && elementOrSelector.isClosure) {
       // Closures are synthesized and their name might conflict with existing
       // globals. Assign an illegal name, and make sure they don't clash
       // with each other.
       return " $name";
     }
-    if (elementOrSelector is Selector
-        || elementOrSelector.isFunction
-        || elementOrSelector.isConstructor) {
+    if (elementOrSelector is Selector ||
+        elementOrSelector.isFunction ||
+        elementOrSelector.isConstructor) {
       int positionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
         CallStructure callStructure = elementOrSelector.callStructure;
         positionalParameterCount = callStructure.positionalArgumentCount;
         namedArguments = namedParametersAsReflectionNames(callStructure);
       } else {
         FunctionElement function = elementOrSelector;
         if (function.isConstructor) {
@@ skipping 25 matching lines @@
     Element element = elementOrSelector;
     if (element.isGenerativeConstructorBody) {
       return null;
     } else if (element.isClass) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name;
     } else if (element.isTypedef) {
       return element.name;
     }
-    throw reporter.internalError(element,
-        'Do not know how to reflect on this $element.');
+    throw reporter.internalError(
+        element, 'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(CallStructure structure) {
     if (structure.isUnnamed) return '';
     String names = structure.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
-  jsAst.Statement buildCspPrecompiledFunctionFor(
-      OutputUnit outputUnit) {
+  jsAst.Statement buildCspPrecompiledFunctionFor(OutputUnit outputUnit) {
     if (compiler.options.useContentSecurityPolicy) {
       // TODO(ahe): Compute a hash code.
       // TODO(sigurdm): Avoid this precompiled function. Generated
       // constructor-functions and getter/setter functions can be stored in the
       // library-description table. Setting properties on these can be moved to
       // finishClasses.
-      return js.statement(r"""
+      return js.statement(
+          r"""
         #precompiled = function ($collectedClasses$) {
           #norename;
           var $desc;
           #functions;
           return #result;
         };""",
-        {'norename': new jsAst.Comment("// ::norenaming:: "),
-         'precompiled': generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
-         'functions': cspPrecompiledFunctionFor(outputUnit),
-         'result': new jsAst.ArrayInitializer(
-               cspPrecompiledConstructorNamesFor(outputUnit))});
+          {
+            'norename': new jsAst.Comment("// ::norenaming:: "),
+            'precompiled':
+                generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
+            'functions': cspPrecompiledFunctionFor(outputUnit),
+            'result': new jsAst.ArrayInitializer(
+                cspPrecompiledConstructorNamesFor(outputUnit))
+          });
     } else {
       return js.comment("Constructors are generated at runtime.");
     }
   }
 
-  void assembleClass(Class cls, ClassBuilder enclosingBuilder,
-                     Fragment fragment) {
+  void assembleClass(
+      Class cls, ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassElement classElement = cls.element;
     reporter.withCurrentElement(classElement, () {
       if (compiler.options.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
-              ClassBuilder builder =
-                  new ClassBuilder.forClass(classElement, namer);
-              classEmitter.emitClass(cls, builder, fragment);
-              return builder;
-            });
+          ClassBuilder builder = new ClassBuilder.forClass(classElement, namer);
+          classEmitter.emitClass(cls, builder, fragment);
+          return builder;
+        });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
         invariant(classElement, cachedBuilder.fieldMetadata == null);
         enclosingBuilder.properties.addAll(cachedBuilder.properties);
       } else {
         classEmitter.emitClass(cls, enclosingBuilder, fragment);
       }
     });
   }
 
-  void assembleStaticFunctions(Iterable<Method> staticFunctions,
-                               Fragment fragment) {
+  void assembleStaticFunctions(
+      Iterable<Method> staticFunctions, Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
       Element element = method.element;
       // We need to filter out null-elements for the interceptors.
       // TODO(floitsch): use the precomputed interceptors here.
       if (element == null) continue;
       ClassBuilder builder = new ClassBuilder.forStatics(element, namer);
       containerBuilder.addMemberMethod(method, builder);
-      getElementDescriptor(element, fragment).properties
+      getElementDescriptor(element, fragment)
+          .properties
           .addAll(builder.properties);
     }
   }
 
   jsAst.Statement buildStaticNonFinalFieldInitializations(
       OutputUnit outputUnit) {
-    jsAst.Statement buildInitialization(Element element,
-                                       jsAst.Expression initialValue) {
+    jsAst.Statement buildInitialization(
+        Element element, jsAst.Expression initialValue) {
       return js.statement('${namer.staticStateHolder}.# = #',
-                          [namer.globalPropertyName(element), initialValue]);
+          [namer.globalPropertyName(element), initialValue]);
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     Iterable<Element> fields = outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
     // [fields] is `null`.
     if (fields != null) {
       for (Element element in fields) {
         reporter.withCurrentElement(element, () {
           ConstantValue constant = handler.getInitialValueFor(element);
           parts.add(buildInitialization(element, constantReference(constant)));
         });
       }
     }
 
     if (inMainUnit && outputStaticNonFinalFieldLists.length > 1) {
       // In the main output-unit we output a stub initializer for deferred
       // variables, so that `isolateProperties` stays a fast object.
       outputStaticNonFinalFieldLists.forEach(
           (OutputUnit fieldsOutputUnit, Iterable<VariableElement> fields) {
-        if (fieldsOutputUnit == outputUnit) return;  // Skip the main unit.
+        if (fieldsOutputUnit == outputUnit) return; // Skip the main unit.
         for (Element element in fields) {
           reporter.withCurrentElement(element, () {
             parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildLazilyInitializedStaticFields(
-      Iterable<StaticField> lazyFields, {bool isMainFragment: true}) {
+      Iterable<StaticField> lazyFields,
+      {bool isMainFragment: true}) {
     if (lazyFields.isNotEmpty) {
       needsLazyInitializer = true;
       List<jsAst.Expression> laziesInfo =
           buildLaziesInfo(lazyFields, isMainFragment);
-      return js.statement('''
+      return js.statement(
+          '''
       (function(lazies) {
         for (var i = 0; i < lazies.length; ) {
           var fieldName = lazies[i++];
           var getterName = lazies[i++];
           var lazyValue = lazies[i++];
           if (#notMinified) {
             var staticName = lazies[i++];
           }
           if (#isDeferredFragment) {
             var fieldHolder = lazies[i++];
@@ skipping 10 matching lines @@
             }
           } else {
             if (#notMinified) {
               #lazy(fieldName, getterName, lazyValue, staticName, fieldHolder);
             } else {
               #lazy(fieldName, getterName, lazyValue, null, fieldHolder);
             }
           }
         }
       })(#laziesInfo)
-      ''', {'notMinified': !compiler.options.enableMinification,
+      ''',
+          {
+            'notMinified': !compiler.options.enableMinification,
             'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
             'lazy': js(lazyInitializerName),
             'isMainFragment': isMainFragment,
-            'isDeferredFragment': !isMainFragment});
+            'isDeferredFragment': !isMainFragment
+          });
     } else {
       return js.comment("No lazy statics.");
     }
   }
 
   List<jsAst.Expression> buildLaziesInfo(
       Iterable<StaticField> lazies, bool isMainFragment) {
     List<jsAst.Expression> laziesInfo = <jsAst.Expression>[];
     for (StaticField field in lazies) {
       laziesInfo.add(js.quoteName(field.name));
       laziesInfo.add(js.quoteName(namer.deriveLazyInitializerName(field.name)));
       laziesInfo.add(field.code);
       if (!compiler.options.enableMinification) {
         laziesInfo.add(js.quoteName(field.name));
       }
       if (!isMainFragment) {
         laziesInfo.add(js('#', field.holder.name));
       }
     }
     return laziesInfo;
   }
 
   // TODO(sra): Remove this unused function.
-  jsAst.Expression buildLazilyInitializedStaticField(
-      VariableElement element, {String isolateProperties}) {
+  jsAst.Expression buildLazilyInitializedStaticField(VariableElement element,
+      {String isolateProperties}) {
     jsAst.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
     // The code only computes the initial value. We build the lazy-check
     // here:
     //   lazyInitializer(fieldName, getterName, initial, name, prototype);
     // The name is used for error reporting. The 'initial' must be a
     // closure that constructs the initial value.
     if (isolateProperties != null) {
       // This is currently only used in incremental compilation to patch
       // in new lazy values.
-      return js('#(#,#,#,#,#)',
-          [js(lazyInitializerName),
-           js.quoteName(namer.globalPropertyName(element)),
-           js.quoteName(namer.lazyInitializerName(element)),
-           code,
-           js.string(element.name),
-           isolateProperties]);
+      return js('#(#,#,#,#,#)', [
+        js(lazyInitializerName),
+        js.quoteName(namer.globalPropertyName(element)),
+        js.quoteName(namer.lazyInitializerName(element)),
+        code,
+        js.string(element.name),
+        isolateProperties
+      ]);
     }
 
     if (compiler.options.enableMinification) {
-      return js('#(#,#,#)',
-          [js(lazyInitializerName),
-           js.quoteName(namer.globalPropertyName(element)),
-           js.quoteName(namer.lazyInitializerName(element)),
-           code]);
+      return js('#(#,#,#)', [
+        js(lazyInitializerName),
+        js.quoteName(namer.globalPropertyName(element)),
+        js.quoteName(namer.lazyInitializerName(element)),
+        code
+      ]);
     } else {
-      return js('#(#,#,#,#)',
-          [js(lazyInitializerName),
-           js.quoteName(namer.globalPropertyName(element)),
-           js.quoteName(namer.lazyInitializerName(element)),
-           code,
-           js.string(element.name)]);
+      return js('#(#,#,#,#)', [
+        js(lazyInitializerName),
+        js.quoteName(namer.globalPropertyName(element)),
+        js.quoteName(namer.lazyInitializerName(element)),
+        code,
+        js.string(element.name)
+      ]);
     }
   }
 
   jsAst.Statement buildMetadata(Program program, OutputUnit outputUnit) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     jsAst.Expression types = program.metadataTypesForOutputUnit(outputUnit);
 
     if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
       jsAst.Expression metadataAccess =
           generateEmbeddedGlobalAccess(embeddedNames.METADATA);
       jsAst.Expression typesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.TYPES);
 
-      parts..add(js.statement('# = #;', [metadataAccess, program.metadata]))
-           ..add(js.statement('# = #;', [typesAccess, types]));
+      parts
+        ..add(js.statement('# = #;', [metadataAccess, program.metadata]))
+        ..add(js.statement('# = #;', [typesAccess, types]));
     } else if (types != null) {
-      parts.add(js.statement('var ${namer.deferredTypesName} = #;',
-                             types));
+      parts.add(js.statement('var ${namer.deferredTypesName} = #;', types));
     }
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildCompileTimeConstants(List<Constant> constants,
-                                           {bool isMainFragment}) {
+      {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return js.comment("No constants in program.");
     List<jsAst.Statement> parts = <jsAst.Statement>[];
     if (compiler.options.hasIncrementalSupport && isMainFragment) {
       parts = cachedEmittedConstantsAst;
     }
     for (Constant constant in constants) {
       ConstantValue constantValue = constant.value;
       if (compiler.options.hasIncrementalSupport && isMainFragment) {
         if (cachedEmittedConstants.contains(constantValue)) continue;
         cachedEmittedConstants.add(constantValue);
       }
       parts.add(buildConstantInitializer(constantValue));
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildConstantInitializer(ConstantValue constant) {
     jsAst.Name name = namer.constantName(constant);
-    jsAst.Statement initializer = js.statement('#.# = #',
-                        [namer.globalObjectForConstant(constant), name,
-                         constantInitializerExpression(constant)]);
+    jsAst.Statement initializer = js.statement('#.# = #', [
+      namer.globalObjectForConstant(constant),
+      name,
+      constantInitializerExpression(constant)
+    ]);
     compiler.dumpInfoTask.registerConstantAst(constant, initializer);
     return initializer;
   }
 
   jsAst.Expression constantListGenerator(jsAst.Expression array) {
     // TODO(floitsch): there is no harm in caching the template.
     return js('${namer.isolateName}.#(#)', [makeConstListProperty, array]);
   }
 
   jsAst.Statement buildMakeConstantList(bool outputContainsConstantList) {
     if (outputContainsConstantList) {
-      return js.statement(r'''
+      return js.statement(
+          r'''
           // Functions are stored in the hidden class and not as properties in
           // the object. We never actually look at the value, but only want
           // to know if the property exists.
           #.# = function (list) {
             list.immutable$list = Array;
             list.fixed$length = Array;
             return list;
           }''',
           [namer.isolateName, makeConstListProperty]);
     } else {
       return js.comment("Output contains no constant list.");
     }
   }
 
   jsAst.Statement buildFunctionThatReturnsNull() {
     return js.statement('#.# = function() {}',
-                        [namer.isolateName,
-                         backend.rtiEncoder.getFunctionThatReturnsNullName]);
+        [namer.isolateName, backend.rtiEncoder.getFunctionThatReturnsNullName]);
   }
 
   jsAst.Expression generateFunctionThatReturnsNull() {
-    return js("#.#", [namer.isolateName,
-                      backend.rtiEncoder.getFunctionThatReturnsNullName]);
+    return js("#.#",
+        [namer.isolateName, backend.rtiEncoder.getFunctionThatReturnsNullName]);
   }
 
   buildMain(jsAst.Statement invokeMain) {
     if (compiler.isMockCompilation) return js.comment("Mock compilation");
 
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
-      parts.add(
-          NativeGenerator.generateIsolateAffinityTagInitialization(
-              backend,
-              generateEmbeddedGlobalAccess,
-              js("""
+      parts.add(NativeGenerator.generateIsolateAffinityTagInitialization(
+          backend,
+          generateEmbeddedGlobalAccess,
+          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];
-        }""", [])));
+        }""",
+              [])));
     }
 
-    parts..add(js.comment('BEGIN invoke [main].'))
-         ..add(invokeMain)
-         ..add(js.comment('END invoke [main].'));
+    parts
+      ..add(js.comment('BEGIN invoke [main].'))
+      ..add(invokeMain)
+      ..add(js.comment('END invoke [main].'));
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildInitFunction(bool outputContainsConstantList) {
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression getTypeFromNameAccess =
         generateEmbeddedGlobalAccess(embeddedNames.GET_TYPE_FROM_NAME);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression cyclicThrow =
         staticFunctionAccess(backend.helpers.cyclicThrowHelper);
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
-    return js.statement('''
+    return js.statement(
+        '''
       function init() {
         $isolatePropertiesName = Object.create(null);
         #allClasses = map();
         #getTypeFromName = function(name) {return #allClasses[name];};
         #interceptorsByTag = map();
         #leafTags = map();
         #finishedClasses = map();
 
         if (#needsLazyInitializer) {
           // [staticName] is only provided in non-minified mode. If missing, we
@@ skipping 89 matching lines @@
           }
           Isolate.#functionThatReturnsNullProperty =
               oldIsolate.#functionThatReturnsNullProperty;
           if (#hasIncrementalSupport) {
             Isolate.#lazyInitializerProperty =
                 oldIsolate.#lazyInitializerProperty;
           }
           return Isolate;
       }
 
-      }''', {'allClasses': allClassesAccess,
-            'getTypeFromName': getTypeFromNameAccess,
-            'interceptorsByTag': interceptorsByTagAccess,
-            'leafTags': leafTagsAccess,
-            'finishedClasses': finishedClassesAccess,
-            'needsLazyInitializer': needsLazyInitializer,
-            'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
-            'isolatePropertiesName': namer.isolatePropertiesName,
-            'outputContainsConstantList': outputContainsConstantList,
-            'makeConstListProperty': makeConstListProperty,
-            'functionThatReturnsNullProperty':
-                backend.rtiEncoder.getFunctionThatReturnsNullName,
-            'hasIncrementalSupport': compiler.options.hasIncrementalSupport,
-            'lazyInitializerProperty': lazyInitializerProperty,});
+      }''',
+        {
+          'allClasses': allClassesAccess,
+          'getTypeFromName': getTypeFromNameAccess,
+          'interceptorsByTag': interceptorsByTagAccess,
+          'leafTags': leafTagsAccess,
+          'finishedClasses': finishedClassesAccess,
+          'needsLazyInitializer': needsLazyInitializer,
+          'lazies': laziesAccess,
+          'cyclicThrow': cyclicThrow,
+          'isolatePropertiesName': namer.isolatePropertiesName,
+          'outputContainsConstantList': outputContainsConstantList,
+          'makeConstListProperty': makeConstListProperty,
+          'functionThatReturnsNullProperty':
+              backend.rtiEncoder.getFunctionThatReturnsNullName,
+          'hasIncrementalSupport': compiler.options.hasIncrementalSupport,
+          'lazyInitializerProperty': lazyInitializerProperty,
+        });
   }
 
   jsAst.Statement buildConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
         if (typeof print === "function") {
           var HasFastProperties =
             new Function("a", "return %HasFastProperties(a)");
           print("Size of global object: "
                    + String(Object.getOwnPropertyNames(properties).length)
                    + ", fast properties " + HasFastProperties(properties));
         }'''));
     }
 
-    return js.statement(r'''
+    return js.statement(
+        r'''
       function convertToFastObject(properties) {
         // Create an instance that uses 'properties' as prototype. This should
         // make 'properties' a fast object.
         function MyClass() {};
         MyClass.prototype = properties;
         new MyClass();
         #;
         return properties;
-      }''', [debugCode]);
+      }''',
+        [debugCode]);
   }
 
   jsAst.Statement buildConvertToSlowObjectFunction() {
     return js.statement(r'''
     function convertToSlowObject(properties) {
       // Add and remove a property to make the object transition into hashmap
       // mode.
       properties.__MAGIC_SLOW_PROPERTY = 1;
       delete properties.__MAGIC_SLOW_PROPERTY;
       return properties;
@@ skipping 15 matching lines @@
           var object = new cls();
           return object.__proto__ &&
                  object.__proto__.p === cls.prototype.p;
          })();
       ''');
     }
 
     return supportsDirectProtoAccess;
   }
 
-  jsAst.Expression generateLibraryDescriptor(LibraryElement library,
-                                             Fragment fragment) {
+  jsAst.Expression generateLibraryDescriptor(
+      LibraryElement library, Fragment fragment) {
     var uri = "";
     if (!compiler.options.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.options.outputUri != null) {
-        uri = relativize(
-        compiler.options.outputUri, library.canonicalUri, false);
+        uri =
+            relativize(compiler.options.outputUri, library.canonicalUri, false);
       }
     }
 
     String libraryName = (!compiler.options.enableMinification ||
         backend.mustRetainLibraryNames) ? library.libraryName : "";
 
     jsAst.Fun metadata = task.metadataCollector.buildMetadataFunction(library);
 
     ClassBuilder descriptor = elementDescriptors[fragment][library];
 
     jsAst.ObjectInitializer initializer;
     if (descriptor == null) {
       // Nothing of the library was emitted.
       // TODO(floitsch): this should not happen. We currently have an example
       // with language/prefix6_negative_test.dart where we have an instance
       // method without its corresponding class.
       initializer = new jsAst.ObjectInitializer([]);
     } else {
       initializer = descriptor.toObjectInitializer();
     }
 
     compiler.dumpInfoTask.registerElementAst(library, metadata);
     compiler.dumpInfoTask.registerElementAst(library, initializer);
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
-    parts..add(js.string(libraryName))
-         ..add(js.string(uri.toString()))
-         ..add(metadata == null ? new jsAst.ArrayHole() : metadata)
-         ..add(js('#', namer.globalObjectFor(library)))
-         ..add(initializer);
+    parts
+      ..add(js.string(libraryName))
+      ..add(js.string(uri.toString()))
+      ..add(metadata == null ? new jsAst.ArrayHole() : metadata)
+      ..add(js('#', namer.globalObjectFor(library)))
+      ..add(initializer);
     if (library == compiler.mainApp) {
       parts.add(js.number(1));
     }
 
     return new jsAst.ArrayInitializer(parts);
   }
 
-  void assemblePrecompiledConstructor(OutputUnit outputUnit,
-                                      jsAst.Name constructorName,
-                                      jsAst.Expression constructorAst,
-                                      List<jsAst.Name> fields) {
-    cspPrecompiledFunctionFor(outputUnit).add(
-        new jsAst.FunctionDeclaration(constructorName, constructorAst));
+  void assemblePrecompiledConstructor(
+      OutputUnit outputUnit,
+      jsAst.Name constructorName,
+      jsAst.Expression constructorAst,
+      List<jsAst.Name> fields) {
+    cspPrecompiledFunctionFor(outputUnit)
+        .add(new jsAst.FunctionDeclaration(constructorName, constructorAst));
 
     String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
     bool hasIsolateSupport = compiler.hasIsolateSupport;
     jsAst.Node fieldNamesArray;
     if (hasIsolateSupport) {
       fieldNamesArray =
           new jsAst.ArrayInitializer(fields.map(js.quoteName).toList());
     } else {
       fieldNamesArray = new jsAst.LiteralNull();
     }
 
-    cspPrecompiledFunctionFor(outputUnit).add(js.statement(r'''
+    cspPrecompiledFunctionFor(outputUnit).add(js.statement(
+        r'''
         {
           #constructorName.#typeNameProperty = #constructorNameString;
           // IE does not have a name property.
           if (!("name" in #constructorName))
               #constructorName.name = #constructorNameString;
           $desc = $collectedClasses$.#constructorName[1];
           #constructorName.prototype = $desc;
           ''' /* next string is not a raw string */ '''
           if (#hasIsolateSupport) {
             #constructorName.$fieldNamesProperty = #fieldNamesArray;
           }
         }''',
-        {"constructorName": constructorName,
-         "typeNameProperty": typeNameProperty,
-         "constructorNameString": js.quoteName(constructorName),
-         "hasIsolateSupport": hasIsolateSupport,
-         "fieldNamesArray": fieldNamesArray}));
+        {
+          "constructorName": constructorName,
+          "typeNameProperty": typeNameProperty,
+          "constructorNameString": js.quoteName(constructorName),
+          "hasIsolateSupport": hasIsolateSupport,
+          "fieldNamesArray": fieldNamesArray
+        }));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
   void assembleTypedefs(Program program) {
     Fragment mainFragment = program.mainFragment;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     // Emit all required typedef declarations into the main output unit.
     // TODO(karlklose): unify required classes and typedefs to declarations
     // and have builders for each kind.
     for (TypedefElement typedef in typedefsNeededForReflection) {
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
       // TODO(zarah): reify type variables once reflection on type arguments of
       // typedefs is supported.
       jsAst.Expression typeIndex =
           task.metadataCollector.reifyType(type, ignoreTypeVariables: true);
       ClassBuilder builder = new ClassBuilder.forStatics(typedef, namer);
-      builder.addPropertyByName(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
-                                typeIndex);
-      builder.addPropertyByName(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
-                                js.boolean(true));
+      builder.addPropertyByName(
+          embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME, typeIndex);
+      builder.addPropertyByName(
+          embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME, js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(coreClasses.objectClass != null);
       builder.superName = namer.className(coreClasses.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
       jsAst.Name mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getElementDescriptor(library, mainFragment)
-          ..addProperty(mangledName, declaration)
-          ..addPropertyByName("+$reflectionName", js.string(''));
+        ..addProperty(mangledName, declaration)
+        ..addPropertyByName("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       jsAst.Name constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<jsAst.Name> fieldNames = [];
-      assemblePrecompiledConstructor(mainOutputUnit,
-                                     constructorName,
-                                     constructorAst,
-                                     fieldNames);
+      assemblePrecompiledConstructor(
+          mainOutputUnit, constructorName, constructorAst, fieldNames);
     }
   }
 
   jsAst.Statement buildGlobalObjectSetup(bool isProgramSplit) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     parts.add(js.comment("""
       // The global objects start as so-called "slow objects". For V8, this
       // means that it won't try to make map transitions as we add properties
       // to these objects. Later on, we attempt to turn these objects into
       // fast objects by calling "convertToFastObject" (see
       // [emitConvertToFastObjectFunction]).
       """));
 
     for (String globalObject in Namer.reservedGlobalObjectNames) {
       if (isProgramSplit) {
         String template =
             "var #globalObject = #globalsHolder.#globalObject = map();";
-        parts.add(js.statement(template, {"globalObject": globalObject,
-                                          "globalsHolder": globalsHolder}));
+        parts.add(js.statement(template,
+            {"globalObject": globalObject, "globalsHolder": globalsHolder}));
       } else {
-        parts.add(js.statement("var #globalObject = map();",
-                               {"globalObject": globalObject}));
+        parts.add(js.statement(
+            "var #globalObject = map();", {"globalObject": globalObject}));
       }
-
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildConvertGlobalObjectToFastObjects() {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     for (String globalObject in Namer.reservedGlobalObjectNames) {
       parts.add(js.statement(
@@ skipping 31 matching lines @@
                    + String(Object.getOwnPropertyNames(C).length)
                    + ", fast properties " + HasFastProperties(C));
             var names = Object.getOwnPropertyNames($);
             for (var i = 0; i < names.length; i++) {
               print("$." + names[i]);
             }
           }
        '''));
 
       for (String object in Namer.userGlobalObjects) {
-        parts.add(js.statement('''
+        parts.add(js.statement(
+            '''
           if (typeof print === "function") {
             print("Size of " + #objectString + ": "
                   + String(Object.getOwnPropertyNames(#object).length)
                   + ", fast properties " + HasFastProperties(#object));
           }
-        ''', {"object": object, "objectString": js.string(object)}));
+        ''',
+            {"object": object, "objectString": js.string(object)}));
       }
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildMangledNames() {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (!mangledFieldNames.isEmpty) {
       List<jsAst.Name> keys = mangledFieldNames.keys.toList()..sort();
       var properties = [];
       for (jsAst.Name key in keys) {
         var value = js.string(mangledFieldNames[key]);
         properties.add(new jsAst.Property(key, value));
       }
 
       jsAst.Expression mangledNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledNamesAccess, map]));
     }
 
     if (!mangledGlobalFieldNames.isEmpty) {
-      List<jsAst.Name> keys = mangledGlobalFieldNames.keys.toList()
-          ..sort();
+      List<jsAst.Name> keys = mangledGlobalFieldNames.keys.toList()..sort();
       List<jsAst.Property> properties = <jsAst.Property>[];
       for (jsAst.Name key in keys) {
         jsAst.Literal value = js.string(mangledGlobalFieldNames[key]);
         properties.add(new jsAst.Property(js.quoteName(key), value));
       }
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       jsAst.ObjectInitializer map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
 
     return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
     if (!compiler.options.hasIncrementalSupport) {
       pendingStatics =
           Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
-      pendingStatics.forEach((element) =>
-          reporter.reportInfo(
-              element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
+      pendingStatics.forEach((element) => reporter.reportInfo(
+          element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
     }
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
-      reporter.internalError(pendingStatics.first,
-          'Pending statics (see above).');
+      reporter.internalError(
+          pendingStatics.first, 'Pending statics (see above).');
     }
   }
 
   void assembleLibrary(Library library, Fragment fragment) {
     LibraryElement libraryElement = library.element;
 
     assembleStaticFunctions(library.statics, fragment);
 
     ClassBuilder libraryBuilder =
         getElementDescriptor(libraryElement, fragment);
@@ skipping 11 matching lines @@
       }
     }
     assembleTypedefs(program);
   }
 
   jsAst.Statement buildDeferredHeader() {
     /// For deferred loading we communicate the initializers via this global
     /// variable. The deferred hunks will add their initialization to this.
     /// The semicolon is important in minified mode, without it the
     /// following parenthesis looks like a call to the object literal.
-    return js.statement('self.#deferredInitializers = '
-                        'self.#deferredInitializers || Object.create(null);',
-                        {'deferredInitializers': deferredInitializers});
+    return js.statement(
+        'self.#deferredInitializers = '
+        'self.#deferredInitializers || Object.create(null);',
+        {'deferredInitializers': deferredInitializers});
   }
 
   jsAst.Program buildOutputAstForMain(Program program,
       Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     MainFragment mainFragment = program.mainFragment;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
     bool isProgramSplit = program.isSplit;
 
     List<jsAst.Statement> statements = <jsAst.Statement>[];
 
-    statements..add(buildGeneratedBy())
-              ..add(js.comment(HOOKS_API_USAGE));
+    statements..add(buildGeneratedBy())..add(js.comment(HOOKS_API_USAGE));
 
     if (isProgramSplit) {
       statements.add(buildDeferredHeader());
     }
 
     // Collect the AST for the decriptors
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
     Iterable<LibraryElement> libraries = outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = <LibraryElement>[];
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
-      List<Element> remainingLibraries = descriptors.keys
-      .where((Element e) => e is LibraryElement)
-      .toList();
+      List<Element> remainingLibraries =
+          descriptors.keys.where((Element e) => e is LibraryElement).toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
       for (LibraryElement element in remainingLibraries) {
         assert(element is LibraryElement ||
             compiler.options.hasIncrementalSupport);
         if (element is LibraryElement) {
           parts.add(generateLibraryDescriptor(element, mainFragment));
           descriptors.remove(element);
         }
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
-    statements.add(js.statement("""
+    statements.add(js.statement(
+        """
     (function() {
        // No renaming in the top-level function to save the locals for the
        // nested context where they will be used more. We have to put the
        // comment into a hole as the parser strips out comments right away.
        #disableVariableRenaming;
        #supportsDirectProtoAccess;
 
        if (#hasIncrementalSupport) {
          #helper = #helper || Object.create(null);
          #helper.patch = function(a) { eval(a)};
@@ skipping 89 matching lines @@
        #convertToFastObject;
        #convertToSlowObject;
 
        #convertGlobalObjectsToFastObjects;
        #debugFastObjects;
 
        #init;
 
        #main;
     })();
-    """, {
-      "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
-      "hasIncrementalSupport": compiler.options.hasIncrementalSupport,
-      "helper": js('this.#', [namer.incrementalHelperName]),
-      "schemaChange": buildSchemaChangeFunction(),
-      "addMethod": buildIncrementalAddMethod(),
-      "isProgramSplit": isProgramSplit,
-      "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
-      "globalsHolder": globalsHolder,
-      "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
-      "isolateName": namer.isolateName,
-      "isolatePropertiesName": js(isolatePropertiesName),
-      "initName": initName,
-      "functionThatReturnsNull": buildFunctionThatReturnsNull(),
-      "mangledNames": buildMangledNames(),
-      "setupProgram": buildSetupProgram(program, compiler, backend, namer, this),
-      "setupProgramName": setupProgramName,
-      "descriptors": descriptorsAst,
-      "cspPrecompiledFunctions": buildCspPrecompiledFunctionFor(mainOutputUnit),
-      "getInterceptorMethods": interceptorEmitter.buildGetInterceptorMethods(),
-      "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
-      "makeConstantList":
-          buildMakeConstantList(program.outputContainsConstantList),
-      "compileTimeConstants":  buildCompileTimeConstants(mainFragment.constants,
-                                                         isMainFragment: true),
-      "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
-      "staticNonFinalInitializers": buildStaticNonFinalFieldInitializations(
-          mainOutputUnit),
-      "typeToInterceptorMap":
-          interceptorEmitter.buildTypeToInterceptorMap(program),
-      "lazyStaticFields": buildLazilyInitializedStaticFields(
-          mainFragment.staticLazilyInitializedFields),
-      "metadata": buildMetadata(program, mainOutputUnit),
-      "convertToFastObject": buildConvertToFastObjectFunction(),
-      "convertToSlowObject": buildConvertToSlowObjectFunction(),
-      "convertGlobalObjectsToFastObjects":
-          buildConvertGlobalObjectToFastObjects(),
-      "debugFastObjects": buildDebugFastObjectCode(),
-      "init": buildInitFunction(program.outputContainsConstantList),
-      "main": buildMain(mainFragment.invokeMain)
-    }));
+    """,
+        {
+          "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
+          "hasIncrementalSupport": compiler.options.hasIncrementalSupport,
+          "helper": js('this.#', [namer.incrementalHelperName]),
+          "schemaChange": buildSchemaChangeFunction(),
+          "addMethod": buildIncrementalAddMethod(),
+          "isProgramSplit": isProgramSplit,
+          "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
+          "globalsHolder": globalsHolder,
+          "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
+          "isolateName": namer.isolateName,
+          "isolatePropertiesName": js(isolatePropertiesName),
+          "initName": initName,
+          "functionThatReturnsNull": buildFunctionThatReturnsNull(),
+          "mangledNames": buildMangledNames(),
+          "setupProgram":
+              buildSetupProgram(program, compiler, backend, namer, this),
+          "setupProgramName": setupProgramName,
+          "descriptors": descriptorsAst,
+          "cspPrecompiledFunctions":
+              buildCspPrecompiledFunctionFor(mainOutputUnit),
+          "getInterceptorMethods":
+              interceptorEmitter.buildGetInterceptorMethods(),
+          "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
+          "makeConstantList":
+              buildMakeConstantList(program.outputContainsConstantList),
+          "compileTimeConstants": buildCompileTimeConstants(
+              mainFragment.constants,
+              isMainFragment: true),
+          "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
+          "staticNonFinalInitializers":
+              buildStaticNonFinalFieldInitializations(mainOutputUnit),
+          "typeToInterceptorMap":
+              interceptorEmitter.buildTypeToInterceptorMap(program),
+          "lazyStaticFields": buildLazilyInitializedStaticFields(
+              mainFragment.staticLazilyInitializedFields),
+          "metadata": buildMetadata(program, mainOutputUnit),
+          "convertToFastObject": buildConvertToFastObjectFunction(),
+          "convertToSlowObject": buildConvertToSlowObjectFunction(),
+          "convertGlobalObjectsToFastObjects":
+              buildConvertGlobalObjectToFastObjects(),
+          "debugFastObjects": buildDebugFastObjectCode(),
+          "init": buildInitFunction(program.outputContainsConstantList),
+          "main": buildMain(mainFragment.invokeMain)
+        }));
 
     return new jsAst.Program(statements);
   }
 
   void emitMainOutputUnit(OutputUnit mainOutputUnit, jsAst.Program program) {
     LineColumnCollector lineColumnCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
       lineColumnCollector = new LineColumnCollector();
       codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
     }
 
-    CodeOutput mainOutput =
-        new StreamCodeOutput(compiler.outputProvider('', 'js'),
-                             codeOutputListeners);
+    CodeOutput mainOutput = new StreamCodeOutput(
+        compiler.outputProvider('', 'js'), codeOutputListeners);
     outputBuffers[mainOutputUnit] = mainOutput;
 
-
-    mainOutput.addBuffer(jsAst.createCodeBuffer(
-        program, compiler, monitor: compiler.dumpInfoTask));
+    mainOutput.addBuffer(jsAst.createCodeBuffer(program, compiler,
+        monitor: compiler.dumpInfoTask));
 
     if (compiler.options.deferredMapUri != null) {
       outputDeferredMap();
     }
 
     if (generateSourceMap) {
       mainOutput.add(generateSourceMapTag(
           compiler.options.sourceMapUri, compiler.options.outputUri));
     }
 
@@ skipping 143 matching lines @@
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
     return outputs;
   }
 
-  void finalizeTokensInAst(jsAst.Program main,
-                           Iterable<jsAst.Program> deferredParts) {
+  void finalizeTokensInAst(
+      jsAst.Program main, Iterable<jsAst.Program> deferredParts) {
     jsAst.TokenCounter counter = new jsAst.TokenCounter();
     counter.countTokens(main);
     deferredParts.forEach(counter.countTokens);
     task.metadataCollector.finalizeTokens();
     if (backend.namer is jsAst.TokenFinalizer) {
       var finalizer = backend.namer;
       finalizer.finalizeTokens();
     }
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
     Program program =
         programBuilder.buildProgram(storeFunctionTypesInMetadata: true);
 
     outputStaticNonFinalFieldLists =
         programBuilder.collector.outputStaticNonFinalFieldLists;
     outputLibraryLists = programBuilder.collector.outputLibraryLists;
     typedefsNeededForReflection =
-       programBuilder.collector.typedefsNeededForReflection;
+        programBuilder.collector.typedefsNeededForReflection;
 
     assembleProgram(program);
 
     // Construct the ASTs for all deferred output units.
     Map<OutputUnit, jsAst.Program> deferredParts =
         buildOutputAstForDeferredCode(program);
 
     Map<OutputUnit, _DeferredOutputUnitHash> deferredHashTokens =
         new Map<OutputUnit, _DeferredOutputUnitHash>.fromIterables(
-          deferredParts.keys,
-          deferredParts.keys.map((OutputUnit unit) {
-            return new _DeferredOutputUnitHash(unit);
-          })
-        );
+            deferredParts.keys, deferredParts.keys.map((OutputUnit unit) {
+      return new _DeferredOutputUnitHash(unit);
+    }));
 
     jsAst.Program mainOutput =
         buildOutputAstForMain(program, deferredHashTokens);
 
     finalizeTokensInAst(mainOutput, deferredParts.values);
 
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes =
         emitDeferredOutputUnits(deferredParts);
 
     deferredHashTokens.forEach((OutputUnit key, _DeferredOutputUnitHash token) {
       token.setHash(deferredLoadHashes[key]);
     });
     emitMainOutputUnit(program.mainFragment.outputUnit, mainOutput);
 
-    if (backend.requiresPreamble &&
-        !backend.htmlLibraryIsLoaded) {
-      reporter.reportHintMessage(
-          NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
+    if (backend.requiresPreamble && !backend.htmlLibraryIsLoaded) {
+      reporter.reportHintMessage(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
     if (sourceMapUri != null && fileUri != null) {
       String sourceMapFileName = relativize(fileUri, sourceMapUri, false);
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
 ''';
     }
     return '';
   }
 
   ClassBuilder getElementDescriptor(Element element, Fragment fragment) {
     Element owner = element.library;
     if (!element.isLibrary &&
         !element.isTopLevel &&
         !backend.isNative(element)) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
-      ClassElement cls =
-          element.enclosingClassOrCompilationUnit.declaration;
+      ClassElement cls = element.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
           !backend.isNative(cls) &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
         owner = cls;
       }
     }
     if (owner == null) {
       reporter.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
         .putIfAbsent(owner, () {
-          return new ClassBuilder(owner, namer, owner.isClass);
-        });
+      return new ClassBuilder(owner, namer, owner.isClass);
+    });
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
       Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
-    parts.add(js.statement('''
+    parts.add(js.statement(
+        '''
         {
           // Function for checking if a hunk is loaded given its hash.
           #isHunkLoaded = function(hunkHash) {
             return !!$deferredInitializers[hunkHash];
           };
           #deferredInitialized = new Object(null);
           // Function for checking if a hunk is initialized given its hash.
           #isHunkInitialized = function(hunkHash) {
             return #deferredInitialized[hunkHash];
           };
           // Function for initializing a loaded hunk, given its hash.
           #initializeLoadedHunk = function(hunkHash) {
             $deferredInitializers[hunkHash](
             #globalsHolder, ${namer.staticStateHolder});
             #deferredInitialized[hunkHash] = true;
           };
         }
-        ''', {"globalsHolder": globalsHolder,
-              "isHunkLoaded": generateEmbeddedGlobalAccess(
-                  embeddedNames.IS_HUNK_LOADED),
-              "isHunkInitialized": generateEmbeddedGlobalAccess(
-                  embeddedNames.IS_HUNK_INITIALIZED),
-              "initializeLoadedHunk": generateEmbeddedGlobalAccess(
-                  embeddedNames.INITIALIZE_LOADED_HUNK),
-              "deferredInitialized": generateEmbeddedGlobalAccess(
-                  embeddedNames.DEFERRED_INITIALIZED)}));
+        ''',
+        {
+          "globalsHolder": globalsHolder,
+          "isHunkLoaded":
+              generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_LOADED),
+          "isHunkInitialized":
+              generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_INITIALIZED),
+          "initializeLoadedHunk": generateEmbeddedGlobalAccess(
+              embeddedNames.INITIALIZE_LOADED_HUNK),
+          "deferredInitialized":
+              generateEmbeddedGlobalAccess(embeddedNames.DEFERRED_INITIALIZED)
+        }));
 
     // Write a javascript mapping from Deferred import load ids (derrived
     // from the import prefix.) to a list of lists of uris of hunks to load,
     // and a corresponding mapping to a list of hashes used by
     // INITIALIZE_LOADED_HUNK and IS_HUNK_LOADED.
     Map<String, List<jsAst.LiteralString>> deferredLibraryUris =
         new Map<String, List<jsAst.LiteralString>>();
     Map<String, List<_DeferredOutputUnitHash>> deferredLibraryHashes =
         new Map<String, List<_DeferredOutputUnitHash>>();
-    compiler.deferredLoadTask.hunksToLoad.forEach(
-                  (String loadId, List<OutputUnit>outputUnits) {
+    compiler.deferredLoadTask.hunksToLoad
+        .forEach((String loadId, List<OutputUnit> outputUnits) {
       List<jsAst.LiteralString> uris = new List<jsAst.LiteralString>();
       List<_DeferredOutputUnitHash> hashes =
           new List<_DeferredOutputUnitHash>();
       deferredLibraryHashes[loadId] = new List<_DeferredOutputUnitHash>();
       for (OutputUnit outputUnit in outputUnits) {
-        uris.add(js.escapedString(
-            backend.deferredPartFileName(outputUnit.name)));
+        uris.add(
+            js.escapedString(backend.deferredPartFileName(outputUnit.name)));
         hashes.add(deferredLoadHashes[outputUnit]);
       }
 
       deferredLibraryUris[loadId] = uris;
       deferredLibraryHashes[loadId] = hashes;
     });
 
     void emitMapping(String name, Map<String, List<jsAst.Expression>> mapping) {
       List<jsAst.Property> properties = new List<jsAst.Property>();
       mapping.forEach((String key, List<jsAst.Expression> values) {
-        properties.add(new jsAst.Property(js.escapedString(key),
-            new jsAst.ArrayInitializer(values)));
+        properties.add(new jsAst.Property(
+            js.escapedString(key), new jsAst.ArrayInitializer(values)));
       });
       jsAst.Node initializer =
           new jsAst.ObjectInitializer(properties, isOneLiner: true);
 
       jsAst.Node globalName = generateEmbeddedGlobalAccess(name);
       parts.add(js.statement("# = #", [globalName, initializer]));
     }
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
-    emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
-                deferredLibraryHashes);
+    emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES, deferredLibraryHashes);
 
     return new jsAst.Block(parts);
   }
 
-  Map <OutputUnit, jsAst.Program> buildOutputAstForDeferredCode(
+  Map<OutputUnit, jsAst.Program> buildOutputAstForDeferredCode(
       Program program) {
     if (!program.isSplit) return const <OutputUnit, jsAst.Program>{};
 
     Map<OutputUnit, jsAst.Program> result =
         new Map<OutputUnit, jsAst.Program>();
 
     Map<OutputUnit, jsAst.Expression> deferredAsts =
         buildDescriptorsForOutputUnits(program);
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
       jsAst.Expression libraryDescriptor = deferredAsts[outputUnit];
       List<jsAst.Statement> body = <jsAst.Statement>[];
 
       // No renaming in the top-level function to save the locals for the
       // nested context where they will be used more.
       body.add(js.comment("/* ::norenaming:: "));
 
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         body.add(js.statement('var #object = #globalsHolder.#object;',
-                              {'globalsHolder': globalsHolder,
-                               'object': globalObject}));
+            {'globalsHolder': globalsHolder, 'object': globalObject}));
       }
-      body..add(js.statement('var init = #globalsHolder.init;',
-                             {'globalsHolder': globalsHolder}))
-          ..add(js.statement('var $setupProgramName = '
-                             '#globalsHolder.$setupProgramName;',
-                             {'globalsHolder': globalsHolder}))
-          ..add(js.statement('var ${namer.isolateName} = '
-                             '#globalsHolder.${namer.isolateName};',
-                             {'globalsHolder': globalsHolder}));
+      body
+        ..add(js.statement('var init = #globalsHolder.init;',
+            {'globalsHolder': globalsHolder}))
+        ..add(js.statement(
+            'var $setupProgramName = '
+            '#globalsHolder.$setupProgramName;',
+            {'globalsHolder': globalsHolder}))
+        ..add(js.statement(
+            'var ${namer.isolateName} = '
+            '#globalsHolder.${namer.isolateName};',
+            {'globalsHolder': globalsHolder}));
       String typesAccess =
           generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
       if (libraryDescriptor != null) {
         // The argument to reflectionDataParser is assigned to a temporary
         // 'dart' so that 'dart.' will appear as the prefix to dart methods
         // in stack traces and profile entries.
         body.add(js.statement('var dart = #', libraryDescriptor));
 
         if (compiler.options.useContentSecurityPolicy) {
           body.add(buildCspPrecompiledFunctionFor(outputUnit));
         }
         body.add(
             js.statement('$setupProgramName(dart, ${typesAccess}.length);'));
       }
 
-      body..add(buildMetadata(program, outputUnit))
-          ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
-                             '${namer.deferredTypesName});'));
+      body
+        ..add(buildMetadata(program, outputUnit))
+        ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
+            '${namer.deferredTypesName});'));
 
-      body.add(buildCompileTimeConstants(fragment.constants,
-                                         isMainFragment: false));
+      body.add(
+          buildCompileTimeConstants(fragment.constants, isMainFragment: false));
       body.add(buildStaticNonFinalFieldInitializations(outputUnit));
       body.add(buildLazilyInitializedStaticFields(
-          fragment.staticLazilyInitializedFields, isMainFragment: false));
+          fragment.staticLazilyInitializedFields,
+          isMainFragment: false));
 
       List<jsAst.Statement> statements = <jsAst.Statement>[];
 
       statements
-          ..add(buildGeneratedBy())
-          ..add(buildDeferredHeader())
-          ..add(js.statement('${deferredInitializers}.current = '
-                             """function (#, ${namer.staticStateHolder}) {
+        ..add(buildGeneratedBy())
+        ..add(buildDeferredHeader())
+        ..add(js.statement(
+            '${deferredInitializers}.current = '
+            """function (#, ${namer.staticStateHolder}) {
                                   #
                                 }
-                             """, [globalsHolder, body]));
+                             """,
+            [globalsHolder, body]));
 
       result[outputUnit] = new jsAst.Program(statements);
     }
 
     return result;
   }
 
   /// Returns a map from OutputUnit to a hash of its content. The hash uniquely
   /// identifies the code of the output-unit. It does not include
   /// boilerplate JS code, like the sourcemap directives or the hash
   /// itself.
   Map<OutputUnit, String> emitDeferredOutputUnits(
       Map<OutputUnit, jsAst.Program> outputAsts) {
-
     Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
 
     for (OutputUnit outputUnit in outputAsts.keys) {
       List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
       Hasher hasher = new Hasher();
       outputListeners.add(hasher);
 
       LineColumnCollector lineColumnCollector;
       if (generateSourceMap) {
         lineColumnCollector = new LineColumnCollector();
         outputListeners.add(lineColumnCollector);
       }
 
       String partPrefix =
           backend.deferredPartFileName(outputUnit.name, addExtension: false);
       CodeOutput output = new StreamCodeOutput(
-          compiler.outputProvider(partPrefix, 'part.js'),
-          outputListeners);
+          compiler.outputProvider(partPrefix, 'part.js'), outputListeners);
 
       outputBuffers[outputUnit] = output;
 
-      output.addBuffer(jsAst.createCodeBuffer(
-          outputAsts[outputUnit], compiler, monitor: compiler.dumpInfoTask));
+      output.addBuffer(jsAst.createCodeBuffer(outputAsts[outputUnit], compiler,
+          monitor: compiler.dumpInfoTask));
 
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hasher.getHash();
 
       output.add('$N${deferredInitializers}["$hash"]$_=$_'
-                       '${deferredInitializers}.current$N');
+          '${deferredInitializers}.current$N');
 
       if (generateSourceMap) {
         Uri mapUri, partUri;
         Uri sourceMapUri = compiler.options.sourceMapUri;
         Uri outputUri = compiler.options.outputUri;
 
         String partName = "$partPrefix.part";
 
         if (sourceMapUri != null) {
           String mapFileName = partName + ".js.map";
           List<String> mapSegments = sourceMapUri.pathSegments.toList();
           mapSegments[mapSegments.length - 1] = mapFileName;
-          mapUri = compiler.options.sourceMapUri
-              .replace(pathSegments: mapSegments);
+          mapUri =
+              compiler.options.sourceMapUri.replace(pathSegments: mapSegments);
         }
 
         if (outputUri != null) {
           String partFileName = partName + ".js";
           List<String> partSegments = outputUri.pathSegments.toList();
           partSegments[partSegments.length - 1] = partFileName;
-          partUri = compiler.options.outputUri.replace(
-              pathSegments: partSegments);
+          partUri =
+              compiler.options.outputUri.replace(pathSegments: partSegments);
         }
 
         output.add(generateSourceMapTag(mapUri, partUri));
         output.close();
-        outputSourceMap(output, lineColumnCollector, partName,
-                        mapUri, partUri);
+        outputSourceMap(output, lineColumnCollector, partName, mapUri, partUri);
       } else {
         output.close();
       }
 
       hunkHashes[outputUnit] = hash;
     }
     return hunkHashes;
   }
 
   jsAst.Comment buildGeneratedBy() {
     List<String> options = [];
     if (compiler.mirrorsLibrary != null) options.add('mirrors');
     if (compiler.options.useContentSecurityPolicy) options.add("CSP");
     return new jsAst.Comment(generatedBy(compiler, flavor: options.join(", ")));
   }
 
-  void outputSourceMap(CodeOutput output,
-                       LineColumnProvider lineColumnProvider,
-                       String name,
-                       [Uri sourceMapUri,
-                        Uri fileUri]) {
+  void outputSourceMap(
+      CodeOutput output, LineColumnProvider lineColumnProvider, String name,
+      [Uri sourceMapUri, Uri fileUri]) {
     if (!generateSourceMap) return;
     // Create a source file for the compilation output. This allows using
     // [:getLine:] to transform offsets to line numbers in [SourceMapBuilder].
     SourceMapBuilder sourceMapBuilder =
-            new SourceMapBuilder(sourceMapUri, fileUri, lineColumnProvider);
+        new SourceMapBuilder(sourceMapUri, fileUri, lineColumnProvider);
     output.forEachSourceLocation(sourceMapBuilder.addMapping);
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
-        ..add(sourceMap)
-        ..close();
+      ..add(sourceMap)
+      ..close();
   }
 
   void outputDeferredMap() {
     Map<String, dynamic> mapping = new Map<String, dynamic>();
     // Json does not support comments, so we embed the explanation in the
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
-            compiler.options.deferredMapUri.path, 'deferred_map')
-        ..add(const JsonEncoder.withIndent("  ").convert(mapping))
-        ..close();
+        compiler.options.deferredMapUri.path, 'deferred_map')
+      ..add(const JsonEncoder.withIndent("  ").convert(mapping))
+      ..close();
   }
 
   void invalidateCaches() {
     if (!compiler.options.hasIncrementalSupport) return;
     if (cachedElements.isEmpty) return;
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
-
       }
     }
   }
 }