dart2js: Construct the entire output as a single AST before printing.

pkg/compiler/lib/src/js_emitter/old_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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final Set<ConstantValue> cachedEmittedConstants;
-  final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
+  final List<jsAst.Statement> cachedEmittedConstantsAst = <jsAst.Statement>[];
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
 
   /// True if [ContainerBuilder.addMemberMethodFromInfo] used "structured info",
   /// that is, some function was needed for reflection, had stubs, or had a
   /// super alias.
   bool needsStructuredMemberInfo = false;
 
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter get nativeEmitter => task.nativeEmitter;
   TypeTestRegistry get typeTestRegistry => task.typeTestRegistry;
 
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeOutput> outputBuffers = new Map<OutputUnit, CodeOutput>();
 
-  /** Shorter access to [isolatePropertiesName]. Both here in the code, as
-      well as in the generated code. */
-  String isolateProperties;
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
@@ skipping 63 matching lines @@
         () => 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();
   }
 
-  void addComment(String comment, CodeOutput output) {
-    output.addBuffer(jsAst.prettyPrint(js.comment(comment), compiler));
-  }
-
   @override
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     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;
@@ skipping 55 matching lines @@
   String get initName => 'init';
 
   String 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";
+  final String deferredInitializers = r"$dart_deferred_initializers$";
 
   /// Contains the global state that is needed to initialize and load a
   /// deferred library.
   String get globalsHolder => namer.internalGlobal("globalsHolder");
 
   @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
@@ skipping 120 matching lines @@
     return nativeEmitter.buildNativeInfoHandler(infoAccess, constructorAccess,
                                                 subclassReadGenerator,
                                                 interceptorsByTagAccess,
                                                 leafTagsAccess);
   }
 
   jsAst.ObjectInitializer generateInterceptedNamesSet() {
     return interceptorEmitter.generateInterceptedNamesSet();
   }
 
-  void emitFinishIsolateConstructorInvocation(CodeOutput output) {
-    String isolate = namer.isolateName;
-    output.add("$isolate = $finishIsolateConstructorName($isolate)$N");
-  }
-
   /// 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 == compiler.intClass ||
             element == compiler.doubleClass ||
             element == compiler.numClass ||
             element == compiler.stringClass ||
             element == compiler.boolClass ||
             element == compiler.nullClass ||
             element == compiler.listClass);
@@ skipping 103 matching lines @@
   }
 
   String namedParametersAsReflectionNames(CallStructure structure) {
     if (structure.isUnnamed) return '';
     String names = structure.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
   jsAst.Statement buildCspPrecompiledFunctionFor(
       OutputUnit outputUnit) {
-    // 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('''
-      # = function (\$collectedClasses) {
-        var \$desc;
-        #;
-        return #;
-      };''',
-        [generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
-         cspPrecompiledFunctionFor(outputUnit),
-         new jsAst.ArrayInitializer(
-             cspPrecompiledConstructorNamesFor(outputUnit))]);
+    if (compiler.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('''
+        # = function (\$collectedClasses) {
+          var \$desc;
+          #;
+          return #;
+        };''',
+          [generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
+           cspPrecompiledFunctionFor(outputUnit),
+           new jsAst.ArrayInitializer(
+               cspPrecompiledConstructorNamesFor(outputUnit))]);
+    } else {
+      return js.comment("Constructors are generated at runtime.");
+    }
   }
 
   void assembleClass(Class cls, ClassBuilder enclosingBuilder,
                      Fragment fragment) {
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder = new ClassBuilder(classElement, namer);
@@ skipping 20 matching lines @@
       // 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(element, namer);
       containerBuilder.addMemberMethod(method, builder);
       getElementDescriptor(element, fragment).properties
           .addAll(builder.properties);
     }
   }
 
-  void emitStaticNonFinalFieldInitializations(CodeOutput output,
-                                              OutputUnit outputUnit) {
-    void emitInitialization(Element element, jsAst.Expression initialValue) {
-      jsAst.Expression init =
-        js('$isolateProperties.# = #',
-            [namer.globalPropertyName(element), initialValue]);
-      output.addBuffer(jsAst.prettyPrint(init, compiler,
-                                         monitor: compiler.dumpInfoTask));
-      output.add('$N');
+  jsAst.Statement buildStaticNonFinalFieldInitializations(
+      OutputUnit outputUnit) {
+    jsAst.Statement buildInitialization(Element element,
+                                       jsAst.Expression initialValue) {
+      return js.statement('${namer.currentIsolate}.# = #',
+                          [namer.globalPropertyName(element), initialValue]);
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     Iterable<Element> fields = task.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) {
         compiler.withCurrentElement(element, () {
           ConstantValue constant = handler.getInitialValueFor(element).value;
-          emitInitialization(element, constantReference(constant));
+          parts.add(buildInitialization(element, constantReference(constant)));
         });
       }
     }
 
     if (inMainUnit && task.outputStaticNonFinalFieldLists.length > 1) {
       // In the main output-unit we output a stub initializer for deferred
       // variables, so that `isolateProperties` stays a fast object.
       task.outputStaticNonFinalFieldLists.forEach(
           (OutputUnit fieldsOutputUnit, Iterable<VariableElement> fields) {
         if (fieldsOutputUnit == outputUnit) return;  // Skip the main unit.
         for (Element element in fields) {
           compiler.withCurrentElement(element, () {
-            emitInitialization(element, jsAst.number(0));
+            parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
+
+    return new jsAst.Block(parts);
   }
 
-  void emitLazilyInitializedStaticFields(CodeOutput output) {
+  jsAst.Statement buildLazilyInitializedStaticFields() {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
-    if (!lazyFields.isEmpty) {
+    if (lazyFields.isNotEmpty) {
       needsLazyInitializer = true;
       List<jsAst.Expression> laziesInfo = buildLaziesInfo(lazyFields);
-      jsAst.Statement code = js.statement('''
+      return js.statement('''
       (function(lazies) {
         if (#notInMinifiedMode) {
           var descriptorLength = 4;
         } else {
           var descriptorLength = 3;
         }
 
         for (var i = 0; i < lazies.length; i += descriptorLength) {
           var fieldName = lazies [i];
           var getterName = lazies[i + 1];
           var lazyValue = lazies[i + 2];
           if (#notInMinifiedMode) {
             var staticName = lazies[i + 3];
           }
 
           // We build the lazy-check here:
           //   lazyInitializer(fieldName, getterName, lazyValue, staticName);
           // 'staticName' is used for error reporting in non-minified mode.
           // 'lazyValue' must be a closure that constructs the initial value.
           if (#notInMinifiedMode) {
             #lazy(fieldName, getterName, lazyValue, staticName);
           } else {
             #lazy(fieldName, getterName, lazyValue);
           }
         }
       })(#laziesInfo)
       ''', {'notInMinifiedMode': !compiler.enableMinification,
             'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
             'lazy': js(lazyInitializerName)});
-
-      output.addBuffer(
-          jsAst.prettyPrint(code, compiler, monitor: compiler.dumpInfoTask));
-      output.add("$N");
+    } else {
+      return js.comment("No lazy statics.");
     }
   }
 
   List<jsAst.Expression> buildLaziesInfo(List<VariableElement> lazies) {
     List<jsAst.Expression> laziesInfo = <jsAst.Expression>[];
     for (VariableElement element in Elements.sortedByPosition(lazies)) {
       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.
@@ skipping 45 matching lines @@
     } else {
       return js('#(#,#,#,#)',
           [js(lazyInitializerName),
            js.string(namer.globalPropertyName(element)),
            js.string(namer.lazyInitializerName(element)),
            code,
            js.string(element.name)]);
     }
   }
 
-  void emitMetadata(Program program, CodeOutput output, OutputUnit outputUnit) {
+  jsAst.Statement buildMetadata(Program program, OutputUnit outputUnit) {
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     jsAst.Expression constructList(List<jsAst.Expression> list) {
       return new jsAst.ArrayInitializer(list == null ? [] : list);
     }
 
     List<jsAst.Expression> types = program.metadataTypes[outputUnit];
 
     if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
       jsAst.Expression metadataAccess =
           generateEmbeddedGlobalAccess(embeddedNames.METADATA);
       jsAst.Expression typesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.TYPES);
 
-      output.addBuffer(
-          jsAst.prettyPrint(new jsAst.Block([
-              js.statement('# = #;', [metadataAccess,
-                                      constructList(program.metadata)]),
-              js.statement('# = #;', [typesAccess, constructList(types)])]),
-              compiler, monitor: compiler.dumpInfoTask));
-      output.add(n);
+      parts..add(js.statement('# = #;', [metadataAccess,
+                                         constructList(program.metadata)]))
+           ..add(js.statement('# = #;', [typesAccess, constructList(types)]));
     } else if (types != null) {
-      output.addBuffer(
-          jsAst.prettyPrint(
-              js.statement('var ${namer.deferredTypesName} = #;',
-                           constructList(types)),
-              compiler, monitor: compiler.dumpInfoTask));
-      if (compiler.enableMinification) {
-        output.add('\n');
-      }
+      parts.add(js.statement('var ${namer.deferredTypesName} = #;',
+                             constructList(types)));
     }
+    return new jsAst.Block(parts);
   }
 
-  void emitCompileTimeConstants(CodeOutput output,
-                                List<Constant> constants,
-                                {bool isMainFragment}) {
+  jsAst.Statement buildCompileTimeConstants(List<Constant> constants,
+                                           {bool isMainFragment}) {
     assert(isMainFragment != null);
 
-    if (constants.isEmpty) return;
-    CodeOutput constantOutput = output;
+    if (constants.isEmpty) return js.comment("No constants in program.");
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
     if (compiler.hasIncrementalSupport && isMainFragment) {
-      constantOutput = cachedEmittedConstantsBuffer;
+      parts = cachedEmittedConstantsAst;
     }
     for (Constant constant in constants) {
       ConstantValue constantValue = constant.value;
       if (compiler.hasIncrementalSupport && isMainFragment) {
         if (cachedEmittedConstants.contains(constantValue)) continue;
         cachedEmittedConstants.add(constantValue);
       }
-      jsAst.Expression init = buildConstantInitializer(constantValue);
-      constantOutput.addBuffer(
-          jsAst.prettyPrint(init, compiler, monitor: compiler.dumpInfoTask));
-      constantOutput.add('$N');
+      parts.add(buildConstantInitializer(constantValue));
     }
-    if (compiler.hasIncrementalSupport && isMainFragment) {
-      output.addBuffer(constantOutput);
-    }
+
+    return new jsAst.Block(parts);
   }
 
-  jsAst.Expression buildConstantInitializer(ConstantValue constant) {
+  jsAst.Statement buildConstantInitializer(ConstantValue constant) {
     String name = namer.constantName(constant);
-    return js('#.# = #',
-              [namer.globalObjectForConstant(constant), name,
-               constantInitializerExpression(constant)]);
+    return js.statement('#.# = #',
+                        [namer.globalObjectForConstant(constant), name,
+                         constantInitializerExpression(constant)]);
   }
 
   jsAst.Template get makeConstantListTemplate {
     // TODO(floitsch): there is no harm in caching the template.
     return jsAst.js.uncachedExpressionTemplate(
         '${namer.isolateName}.$makeConstListProperty(#)');
   }
 
-  void emitMakeConstantList(CodeOutput output) {
-    output.addBuffer(
-        jsAst.prettyPrint(
-            // 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.
-            js.statement(r'''#.# = function(list) {
-                                     list.immutable$list = Array;
-                                     list.fixed$length = Array;
-                                     return list;
-                                   }''',
-                         [namer.isolateName, makeConstListProperty]),
-            compiler, monitor: compiler.dumpInfoTask));
-    output.add(N);
+  jsAst.Statement buildMakeConstantList() {
+    if (task.outputContainsConstantList) {
+      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.");
+    }
   }
 
-  void emitFunctionThatReturnsNull(CodeOutput output) {
-    output.addBuffer(
-        jsAst.prettyPrint(
-            js.statement('#.# = function() {}',
-                         [backend.namer.currentIsolate,
-                          backend.rti.getFunctionThatReturnsNullName]),
-            compiler, monitor: compiler.dumpInfoTask));
-    output.add(N);
+  jsAst.Statement buildFunctionThatReturnsNull() {
+    return js.statement('#.# = function() {}',
+                        [backend.namer.currentIsolate,
+                         backend.rti.getFunctionThatReturnsNullName]);
   }
 
   jsAst.Expression generateFunctionThatReturnsNull() {
     return js("#.#", [backend.namer.currentIsolate,
                       backend.rti.getFunctionThatReturnsNullName]);
   }
 
-  emitMain(CodeOutput output, jsAst.Statement invokeMain) {
-    if (compiler.isMockCompilation) return;
+  buildMain(jsAst.Statement invokeMain) {
+    if (compiler.isMockCompilation) return js.comment("Mock compilation");
+
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
-      jsAst.Statement nativeBoilerPlate =
+      parts.add(
           NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
-              js("convertToFastObject", []));
-      output.addBuffer(jsAst.prettyPrint(
-          nativeBoilerPlate, compiler, monitor: compiler.dumpInfoTask));
+              js("convertToFastObject", [])));
     }
 
-    output.add(';');
-    addComment('BEGIN invoke [main].', output);
-    output.addBuffer(jsAst.prettyPrint(invokeMain,
-                     compiler, monitor: compiler.dumpInfoTask));
-    output.add(N);
-    addComment('END invoke [main].', output);
+    parts..add(js.comment('BEGIN invoke [main].'))
+         ..add(invokeMain)
+         ..add(js.comment('END invoke [main].'));
+
+    return new jsAst.Block(parts);
   }
 
-  void emitInitFunction(CodeOutput output) {
+  jsAst.Statement buildInitFunction() {
     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.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
-    jsAst.FunctionDeclaration decl = js.statement('''
+    return js.statement('''
       function init() {
-        $isolateProperties = Object.create(null);
+        $isolatePropertiesName = Object.create(null);
         #allClasses = Object.create(null);
         #getTypeFromName = function(name) {return #allClasses[name];};
         #interceptorsByTag = Object.create(null);
         #leafTags = Object.create(null);
         #finishedClasses = Object.create(null);
 
         if (#needsLazyInitializer) {
           // [staticName] is only provided in non-minified mode. If missing, we 
           // fall back to [fieldName]. Likewise, [prototype] is optional and 
           // defaults to the isolateProperties object.
           $lazyInitializerName = function (fieldName, getterName, lazyValue,
                                            staticName, prototype) {
             if (!#lazies) #lazies = Object.create(null);
             #lazies[fieldName] = getterName;
 
             // 'prototype' will be undefined except if we are doing an update
             // during incremental compilation. In this case we put the lazy
             // field directly on the isolate instead of the isolateProperties.
-            prototype = prototype || $isolateProperties;
+            prototype = prototype || $isolatePropertiesName;
             var sentinelUndefined = {};
             var sentinelInProgress = {};
             prototype[fieldName] = sentinelUndefined;
 
             prototype[getterName] = function () {
               var result = this[fieldName];
               try {
                 if (result === sentinelUndefined) {
                   this[fieldName] = sentinelInProgress;
 
@@ skipping 78 matching lines @@
             'interceptorsByTag': interceptorsByTagAccess,
             'leafTags': leafTagsAccess,
             'finishedClasses': finishedClassesAccess,
             'needsLazyInitializer': needsLazyInitializer,
             'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
             'isolatePropertiesName': namer.isolatePropertiesName,
             'outputContainsConstantList': task.outputContainsConstantList,
             'makeConstListProperty': makeConstListProperty,
             'hasIncrementalSupport': compiler.hasIncrementalSupport,
             'lazyInitializerProperty': lazyInitializerProperty,});
-
-    output.addBuffer(
-        jsAst.prettyPrint(decl, compiler, monitor: compiler.dumpInfoTask));
-    if (compiler.enableMinification) {
-      output.add('\n');
-    }
   }
 
-  void emitConvertToFastObjectFunction(CodeOutput output) {
+  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));
         }'''));
     }
 
-    jsAst.Statement convertToFastObject = 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]);
-
-    output.addBuffer(jsAst.prettyPrint(convertToFastObject, compiler));
-    output.add(N);
   }
 
-  void emitConvertToSlowObjectFunction(CodeOutput output) {
-    jsAst.Statement convertToSlowObject = js.statement(r'''
+  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;
     }''');
-
-    output.addBuffer(jsAst.prettyPrint(convertToSlowObject, compiler));
-    output.add(N);
   }
 
-  void emitSupportsDirectProtoAccess(CodeOutput output) {
+  jsAst.Statement buildSupportsDirectProtoAccess() {
     jsAst.Statement supportsDirectProtoAccess;
 
     if (compiler.hasIncrementalSupport) {
       supportsDirectProtoAccess = js.statement(r'''
         var supportsDirectProtoAccess = false;
       ''');
     } else {
       supportsDirectProtoAccess = js.statement(r'''
         var supportsDirectProtoAccess = (function () {
           var cls = function () {};
           cls.prototype = {'p': {}};
           var object = new cls();
           return object.__proto__ &&
                  object.__proto__.p === cls.prototype.p;
          })();
       ''');
     }
 
-    output.addBuffer(jsAst.prettyPrint(supportsDirectProtoAccess, compiler));
-    output.add(N);
+    return supportsDirectProtoAccess;
   }
 
   jsAst.Expression generateLibraryDescriptor(LibraryElement library,
                                              Fragment fragment) {
     var uri = "";
     if (!compiler.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.outputUri != null) {
         uri = relativize(compiler.outputUri, library.canonicalUri, false);
       }
@@ skipping 19 matching lines @@
       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.name(namer.globalObjectFor(library)))
+         ..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,
                                       String constructorName,
@@ skipping 65 matching lines @@
       String constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<String> fieldNames = [];
       assemblePrecompiledConstructor(mainOutputUnit,
                                      constructorName,
                                      constructorAst,
                                      fieldNames);
     }
   }
 
-  void emitMangledNames(CodeOutput output) {
+  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}));
+      } else {
+        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(
+          '#globalObject = convertToFastObject(#globalObject);',
+          {"globalObject": globalObject}));
+    }
+
+    return new jsAst.Block(parts);
+  }
+
+  jsAst.Statement buildDebugFastObjectCode() {
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
+
+    if (DEBUG_FAST_OBJECTS) {
+      parts.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 helper object: "
+                   + String(Object.getOwnPropertyNames(H).length)
+                   + ", fast properties " + HasFastProperties(H));
+            print("Size of global platform object: "
+                   + String(Object.getOwnPropertyNames(P).length)
+                   + ", fast properties " + HasFastProperties(P));
+            print("Size of global dart:html object: "
+                   + String(Object.getOwnPropertyNames(W).length)
+                   + ", fast properties " + HasFastProperties(W));
+            print("Size of isolate properties object: "
+                   + String(Object.getOwnPropertyNames($).length)
+                   + ", fast properties " + HasFastProperties($));
+            print("Size of constant object: "
+                   + 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('''
+          if (typeof print === "function") {
+            print("Size of " + #objectString + ": "
+                  + String(Object.getOwnPropertyNames(#object).length)
+                  + ", fast properties " + HasFastProperties(#object));
+          }
+        ''', {"object": object, "objectString": js.string(object)}));
+      }
+    }
+
+    return new jsAst.Block(parts);
+  }
+
+  jsAst.Statement buildMangledNames() {
+    List<jsAst.Statement> parts = <jsAst.Statement>[];
+
     if (!mangledFieldNames.isEmpty) {
       var keys = mangledFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledFieldNames[key]}');
         properties.add(new jsAst.Property(js.string(key), value));
       }
 
       jsAst.Expression mangledNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
-      output.addBuffer(
-          jsAst.prettyPrint(
-              js.statement('# = #', [mangledNamesAccess, map]),
-              compiler,
-              monitor: compiler.dumpInfoTask));
-      if (compiler.enableMinification) {
-        output.add(';');
-      }
+      parts.add(js.statement('# = #', [mangledNamesAccess, map]));
     }
+
     if (!mangledGlobalFieldNames.isEmpty) {
       var keys = mangledGlobalFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledGlobalFieldNames[key]}');
         properties.add(new jsAst.Property(js.string(key), value));
       }
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
-      output.addBuffer(
-          jsAst.prettyPrint(
-              js.statement('# = #', [mangledGlobalNamesAccess, map]),
-              compiler,
-              monitor: compiler.dumpInfoTask));
-      if (compiler.enableMinification) {
-        output.add(';');
-      }
+      parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
+
+    return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
     if (!compiler.hasIncrementalSupport) {
       pendingStatics =
           Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
       pendingStatics.forEach((element) =>
           compiler.reportInfo(
@@ skipping 41 matching lines @@
       codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
     }
 
     CodeOutput mainOutput =
         new StreamCodeOutput(compiler.outputProvider('', 'js'),
                              codeOutputListeners);
     outputBuffers[mainOutputUnit] = mainOutput;
 
     bool isProgramSplit = program.isSplit;
 
-    mainOutput.add(buildGeneratedBy());
-    addComment(HOOKS_API_USAGE, mainOutput);
+    List<jsAst.Statement> statements = <jsAst.Statement>[];
+
+    statements..add(buildGeneratedBy())
+              ..add(js.comment(HOOKS_API_USAGE));
 
     if (isProgramSplit) {
       /// 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.
-      mainOutput.add(
-          'self.${deferredInitializers} = self.${deferredInitializers} || '
-          'Object.create(null);$n');
+      statements.add(
+          js.statement('self.#deferredInitializers = '
+                       'self.#deferredInitializers || Object.create(null);',
+                       {'deferredInitializers': deferredInitializers}));
     }
 
-    // Using a named function here produces easier to read stack traces in
-    // Chrome/V8.
-    mainOutput.add('(function(${namer.currentIsolate})$_{\n');
-    emitSupportsDirectProtoAccess(mainOutput);
-    if (compiler.hasIncrementalSupport) {
-      mainOutput.addBuffer(jsAst.prettyPrint(js.statement(
-          """
-{
-  #helper = #helper || Object.create(null);
-  #helper.patch = function(a) { eval(a)};
-  #helper.schemaChange = #schemaChange;
-  #helper.addMethod = #addMethod;
-  #helper.extractStubs = function(array, name, isStatic, originalDescriptor) {
-    var descriptor = Object.create(null);
-    this.addStubs(descriptor, array, name, isStatic, []);
-    return descriptor;
-  };
-}""",
-          { 'helper': js('this.#', [namer.incrementalHelperName]),
-            'schemaChange': buildSchemaChangeFunction(),
-            'addMethod': buildIncrementalAddMethod() }), compiler));
-    }
-    if (isProgramSplit) {
-      /// We collect all the global state, so it can be passed to the
-      /// initializer of deferred files.
-      mainOutput.add('var ${globalsHolder}$_=${_}Object.create(null)$N');
-    }
-
-    jsAst.Statement mapFunction = js.statement('''
-// [map] returns an object that V8 shouldn't try to optimize with a hidden
-// class. This prevents a potential performance problem where V8 tries to build
-// a hidden class for an object used as a hashMap.
-// It requires fewer characters to declare a variable as a parameter than
-// with `var`.
-  function map(x) {
-    x = Object.create(null);
-    x.x = 0;
-    delete x.x;
-    return x;
-  }
-''');
-    mainOutput.addBuffer(jsAst.prettyPrint(mapFunction, compiler));
-    for (String globalObject in Namer.reservedGlobalObjectNames) {
-      // 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]).
-      mainOutput.add('var ${globalObject}$_=${_}');
-      if(isProgramSplit) {
-        mainOutput.add('${globalsHolder}.$globalObject$_=${_}');
-      }
-      mainOutput.add('map()$N');
-    }
-
-    mainOutput.add('function ${namer.isolateName}()$_{}\n');
-    if (isProgramSplit) {
-      mainOutput.add(
-          '${globalsHolder}.${namer.isolateName}$_=$_${namer.isolateName}$N'
-          '${globalsHolder}.$initName$_=${_}$initName$N'
-          '${globalsHolder}.$setupProgramName$_=$_'
-            '$setupProgramName$N');
-    }
-    mainOutput.add('init()$N$n');
-    mainOutput.add('$isolateProperties$_=$_$isolatePropertiesName$N');
-
-    emitFunctionThatReturnsNull(mainOutput);
-
-    Iterable<LibraryElement> libraries =
-        task.outputLibraryLists[mainOutputUnit];
-    if (libraries == null) libraries = [];
-    emitMangledNames(mainOutput);
-
+    // Collect the AST for the decriptors
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
+    Iterable<LibraryElement> libraries =
+        task.outputLibraryLists[mainOutputUnit];
+    if (libraries == null) libraries = [];
+
     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();
+      .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.hasIncrementalSupport);
         if (element is LibraryElement) {
           parts.add(generateLibraryDescriptor(element, mainFragment));
           descriptors.remove(element);
         }
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
-    bool needsNativeSupport = program.needsNativeSupport;
-    mainOutput.addBuffer(
-        jsAst.prettyPrint(
-            buildSetupProgram(program, compiler, backend, namer, this),
-            compiler));
+    // Using a named function here produces easier to read stack traces in
+    // Chrome/V8.
+    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;
 
-    // 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.
-    mainOutput..add('var dart =')
-              ..addBuffer(jsAst.prettyPrint(descriptorsAst, compiler,
-                                            monitor: compiler.dumpInfoTask))
-              ..add('$N');
-    if (compiler.useContentSecurityPolicy) {
-      jsAst.Statement precompiledFunctionAst =
-          buildCspPrecompiledFunctionFor(mainOutputUnit);
-      mainOutput.addBuffer(
-          jsAst.prettyPrint(
-              precompiledFunctionAst,
-              compiler,
-              monitor: compiler.dumpInfoTask,
-              allowVariableMinification: false));
-      mainOutput.add(N);
-    }
+       if (#hasIncrementalSupport) {
+         #helper = #helper || Object.create(null);
+         #helper.patch = function(a) { eval(a)};
+         #helper.schemaChange = #schemaChange;
+         #helper.addMethod = #addMethod;
+         #helper.extractStubs =
+           function(array, name, isStatic, originalDescriptor) {
+             var descriptor = Object.create(null);
+             this.addStubs(descriptor, array, name, isStatic, []);
+             return descriptor;
+            };
+       }
 
-    mainOutput.add('$setupProgramName(dart, 0)$N');
+       if (#isProgramSplit) {
+         /// We collect all the global state, so it can be passed to the
+         /// initializer of deferred files.
+         var #globalsHolder = Object.create(null)
+       }
 
-    interceptorEmitter.emitGetInterceptorMethods(mainOutput);
-    interceptorEmitter.emitOneShotInterceptors(mainOutput);
+       // [map] returns an object that V8 shouldn't try to optimize with a
+       // hidden class. This prevents a potential performance problem where V8
+       // tries to build a hidden class for an object used as a hashMap.
+       // It requires fewer characters to declare a variable as a parameter than
+       // with `var`.
+       function map(x) {
+         x = Object.create(null);
+         x.x = 0;
+         delete x.x;
+         return x;
+       }
 
-    if (task.outputContainsConstantList) {
-      emitMakeConstantList(mainOutput);
-    }
+       #globalObjectSetup;
 
-    // Constants in checked mode call into RTI code to set type information
-    // which may need getInterceptor (and one-shot interceptor) methods, so
-    // we have to make sure that [emitGetInterceptorMethods] and
-    // [emitOneShotInterceptors] have been called.
-    emitCompileTimeConstants(
-        mainOutput, mainFragment.constants, isMainFragment: true);
+       function #isolateName() {}
 
-    emitDeferredBoilerPlate(mainOutput, deferredLoadHashes);
+       if (#isProgramSplit) {
+         #globalsHolder.#isolateName = #isolateName;
+         #globalsHolder.#initName = #initName;
+         #globalsHolder.#setupProgramName = #setupProgramName;
+       }
+
+       init();
+
+       var ${namer.currentIsolate} = #isolatePropertiesName;
+
+       #functionThatReturnsNull;
+
+       #mangledNames;
+
+       #setupProgram;
+
+       // 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.
+       var dart = #descriptors;
+
+       #setupProgramName(dart, 0);
+
+       #cspPrecompiledFunctions;
+
+       #getInterceptorMethods;
+       #oneShotInterceptors;
+
+       #makeConstantList;
+
+       // Constants in checked mode call into RTI code to set type information
+       // which may need getInterceptor (and one-shot interceptor) methods, so
+       // we have to make sure that [emitGetInterceptorMethods] and
+       // [emitOneShotInterceptors] have been called.
+       #compileTimeConstants;
+
+       // Static field initializations require the classes and compile-time
+       // constants to be set up.
+       #staticNonFinalInitializers;
+
+       #deferredBoilerPlate;
+
+       #typeToInterceptorMap;
+
+       #lazyStaticFields;
+
+       ${namer.currentIsolate} = null;
+
+       #isolateName = $finishIsolateConstructorName(#isolateName);
+
+       ${namer.currentIsolate} = new #isolateName();
+
+       #metadata;
+
+       #convertToFastObject;
+       #convertToSlowObject;
+
+       #convertGlobalObjectsToFastObjects;
+       #debugFastObjects;
+
+       #init;
+
+       #main;
+    })();
+    """, {
+      "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
+      "hasIncrementalSupport": compiler.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(),
+      "compileTimeConstants":  buildCompileTimeConstants(mainFragment.constants,
+                                                         isMainFragment: true),
+      "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
+      "staticNonFinalInitializers": buildStaticNonFinalFieldInitializations(
+          mainOutputUnit),
+      "typeToInterceptorMap":
+          interceptorEmitter.buildTypeToInterceptorMap(program),
+      "lazyStaticFields": buildLazilyInitializedStaticFields(),
+      "metadata": buildMetadata(program, mainOutputUnit),
+      "convertToFastObject": buildConvertToFastObjectFunction(),
+      "convertToSlowObject": buildConvertToSlowObjectFunction(),
+      "convertGlobalObjectsToFastObjects":
+          buildConvertGlobalObjectToFastObjects(),
+      "debugFastObjects": buildDebugFastObjectCode(),
+      "init": buildInitFunction(),
+      "main": buildMain(mainFragment.invokeMain)
+    }));
+
+    mainOutput.addBuffer(jsAst.prettyPrint(new jsAst.Program(statements),
+                                           compiler,
+                                           monitor: compiler.dumpInfoTask));
 
     if (compiler.deferredMapUri != null) {
       outputDeferredMap();
     }
 
-    // Static field initializations require the classes and compile-time
-    // constants to be set up.
-    emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
-    interceptorEmitter.emitTypeToInterceptorMap(program, mainOutput);
-    if (compiler.enableMinification) {
-      mainOutput.add(';');
-    }
-    emitLazilyInitializedStaticFields(mainOutput);
-
-    mainOutput.add('\n');
-
-    emitMetadata(program, mainOutput, mainOutputUnit);
-
-    isolateProperties = isolatePropertiesName;
-    // The following code should not use the short-hand for the
-    // initialStatics.
-    mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
-
-    emitFinishIsolateConstructorInvocation(mainOutput);
-    mainOutput.add(
-        '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
-
-    emitConvertToFastObjectFunction(mainOutput);
-    emitConvertToSlowObjectFunction(mainOutput);
-
-    for (String globalObject in Namer.reservedGlobalObjectNames) {
-      mainOutput.add('$globalObject = convertToFastObject($globalObject)$N');
-    }
-    if (DEBUG_FAST_OBJECTS) {
-      mainOutput.add(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 helper object: "
-                   + String(Object.getOwnPropertyNames(H).length)
-                   + ", fast properties " + HasFastProperties(H));
-            print("Size of global platform object: "
-                   + String(Object.getOwnPropertyNames(P).length)
-                   + ", fast properties " + HasFastProperties(P));
-            print("Size of global dart:html object: "
-                   + String(Object.getOwnPropertyNames(W).length)
-                   + ", fast properties " + HasFastProperties(W));
-            print("Size of isolate properties object: "
-                   + String(Object.getOwnPropertyNames($).length)
-                   + ", fast properties " + HasFastProperties($));
-            print("Size of constant object: "
-                   + 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) {
-      mainOutput.add('''
-        if (typeof print === "function") {
-           print("Size of $object: "
-                 + String(Object.getOwnPropertyNames($object).length)
-                 + ", fast properties " + HasFastProperties($object));
-}
-''');
-      }
-    }
-
-    emitInitFunction(mainOutput);
-    emitMain(mainOutput, mainFragment.invokeMain);
-
-    mainOutput.add('})()\n');
-
-
     if (generateSourceMap) {
       mainOutput.add(
           generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
     }
 
     mainOutput.close();
 
     if (generateSourceMap) {
       outputSourceMap(mainOutput, lineColumnCollector, '',
           compiler.sourceMapUri, compiler.outputUri);
     }
   }
 
   /// Used by incremental compilation to patch up the prototype of
   /// [oldConstructor] for use as prototype of [newConstructor].
   jsAst.Fun buildSchemaChangeFunction() {
+    if (!compiler.hasIncrementalSupport) return null;
     return js('''
 function(newConstructor, oldConstructor, superclass) {
   // Invariant: newConstructor.prototype has no interesting properties besides
   // generated accessors. These are copied to oldPrototype which will be
   // updated by other incremental changes.
   if (superclass != null) {
     this.inheritFrom(newConstructor, superclass);
   }
   var oldPrototype = oldConstructor.prototype;
   var newPrototype = newConstructor.prototype;
@@ skipping 12 matching lines @@
   }
 
   /// Used by incremental compilation to patch up an object ([holder]) with a
   /// new (or updated) method.  [arrayOrFunction] is either the new method, or
   /// an array containing the method (see
   /// [ContainerBuilder.addMemberMethodFromInfo]). [name] is the name of the
   /// new method. [isStatic] tells if method is static (or
   /// top-level). [globalFunctionsAccess] is a reference to
   /// [embeddedNames.GLOBAL_FUNCTIONS].
   jsAst.Fun buildIncrementalAddMethod() {
+    if (!compiler.hasIncrementalSupport) return null;
     return js(r"""
 function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
   var arrayOrFunction = originalDescriptor[name];
   var method;
   if (arrayOrFunction.constructor === Array) {
     var existing = holder[name];
     var array = arrayOrFunction;
 
     // Each method may have a number of stubs associated. For example, if an
     // instance method supports multiple arguments, a stub for each matching
@@ skipping 100 matching lines @@
 
     return emitDeferredCode(program, outputs);
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
     assembleProgram(program);
 
-    // Shorten the code by using [namer.currentIsolate] as temporary.
-    isolateProperties = namer.currentIsolate;
-
     // 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(program);
     emitMainOutputUnit(program, deferredLoadHashes);
 
     if (backend.requiresPreamble &&
@@ skipping 32 matching lines @@
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
         .putIfAbsent(owner, () => new ClassBuilder(owner, namer));
   }
 
   /// Emits support-code for deferred loading into [output].
-  void emitDeferredBoilerPlate(CodeOutput output,
-                               Map<OutputUnit, String> deferredLoadHashes) {
-    jsAst.Statement functions = js.statement('''
+  jsAst.Statement buildDeferredBoilerPlate(
+      Map<OutputUnit, String> deferredLoadHashes) {
+    List<jsAst.Statement> parts = <jsAst.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.currentIsolate});
             #deferredInitialized[hunkHash] = true;
           };
         }
         ''', {"isHunkLoaded": generateEmbeddedGlobalAccess(
                   embeddedNames.IS_HUNK_LOADED),
               "isHunkInitialized": generateEmbeddedGlobalAccess(
                   embeddedNames.IS_HUNK_INITIALIZED),
               "initializeLoadedHunk": generateEmbeddedGlobalAccess(
                   embeddedNames.INITIALIZE_LOADED_HUNK),
               "deferredInitialized": generateEmbeddedGlobalAccess(
-                  embeddedNames.DEFERRED_INITIALIZED)});
-    output.addBuffer(jsAst.prettyPrint(functions,
-        compiler, monitor: compiler.dumpInfoTask));
+                  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<String>> deferredLibraryUris =
         new Map<String, List<String>>();
     Map<String, List<String>> deferredLibraryHashes =
         new Map<String, List<String>>();
     compiler.deferredLoadTask.hunksToLoad.forEach(
                   (String loadId, List<OutputUnit>outputUnits) {
@@ skipping 13 matching lines @@
       List<jsAst.Property> properties = new List<jsAst.Property>();
       mapping.forEach((String key, List<String> values) {
         properties.add(new jsAst.Property(js.escapedString(key),
             new jsAst.ArrayInitializer(
                 values.map(js.escapedString).toList())));
       });
       jsAst.Node initializer =
           new jsAst.ObjectInitializer(properties, isOneLiner: true);
 
       jsAst.Node globalName = generateEmbeddedGlobalAccess(name);
-      output.addBuffer(jsAst.prettyPrint(
-          js("# = #", [globalName, initializer]),
-          compiler, monitor: compiler.dumpInfoTask));
-      output.add('$N');
+      parts.add(js.statement("# = #", [globalName, initializer]));
     }
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
     emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
                 deferredLibraryHashes);
+
+    return new jsAst.Block(parts);
   }
 
   /// Emits code for all output units except the main.
   /// Returns a mapping from outputUnit to a hash of the corresponding hunk that
   /// can be used for calling the initializer.
   Map<OutputUnit, String> emitDeferredCode(
       Program program,
       Map<OutputUnit, jsAst.Expression> deferredAsts) {
 
     Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
@@ skipping 14 matching lines @@
       }
 
       String partPrefix =
           backend.deferredPartFileName(outputUnit.name, addExtension: false);
       CodeOutput output = new StreamCodeOutput(
           compiler.outputProvider(partPrefix, 'part.js'),
           outputListeners);
 
       outputBuffers[outputUnit] = output;
 
-      output
-          ..add(buildGeneratedBy())
-          ..add('${deferredInitializers}.current$_=$_'
-                   'function$_(${globalsHolder}) {$N');
+      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) {
-        output
-            .add('var $globalObject$_=$_'
-                     '${globalsHolder}.$globalObject$N');
+        body.add(js.statement('var #object = ${globalsHolder}.#object;',
+                              {'object': globalObject}));
       }
-      output
-          ..add('var init$_=$_${globalsHolder}.init$N')
-          ..add('var $setupProgramName$_=$_'
-                    '$globalsHolder.$setupProgramName$N')
-          ..add('var ${namer.isolateName}$_=$_'
-                    '${globalsHolder}.${namer.isolateName}$N');
+      body..add(js.statement('var init = ${globalsHolder}.init;'))
+          ..add(js.statement('var $setupProgramName = '
+                             '$globalsHolder.$setupProgramName;'))
+          ..add(js.statement('var ${namer.isolateName} = '
+                             '${globalsHolder}.${namer.isolateName};'));
       String typesAccess =
           generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
       if (libraryDescriptor != null) {
         // TODO(ahe): This defines a lot of properties on the
         // Isolate.prototype object.  We know this will turn it into a
         // slow object in V8, so instead we should do something similar
         // to Isolate.$finishIsolateConstructor.
-        output
-            ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
+        body..add(js.statement('var ${namer.currentIsolate} = '
+                               '$isolatePropertiesName;'))
             // 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.
-            ..add('var dart = $n ')
-            ..addBuffer(jsAst.prettyPrint(libraryDescriptor, compiler,
-                                          monitor: compiler.dumpInfoTask))
-            ..add('$N');
+            ..add(js.statement('var dart = #', libraryDescriptor));
 
         if (compiler.useContentSecurityPolicy) {
-          jsAst.Statement precompiledFunctionAst =
-              buildCspPrecompiledFunctionFor(outputUnit);
-
-          output.addBuffer(
-              jsAst.prettyPrint(
-                  precompiledFunctionAst, compiler,
-                  monitor: compiler.dumpInfoTask,
-                  allowVariableMinification: false));
-          output.add(N);
+          body.add(buildCspPrecompiledFunctionFor(outputUnit));
         }
-        output.add('$setupProgramName(dart, ${typesAccess}.length)$N');
+        body.add(
+            js.statement('$setupProgramName(dart, ${typesAccess}.length);'));
       }
 
       if (task.metadataCollector.types[outputUnit] != null) {
-        emitMetadata(program, output, outputUnit);
-        output.add('${typesAccess}.'
-                   'push.apply(${typesAccess},$_${namer.deferredTypesName})$N');
+        body..add(buildMetadata(program, outputUnit))
+            ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
+                               '${namer.deferredTypesName});'));
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup it must point to the current Isolate.
       // Otherwise all methods/functions accessing isolate variables will
       // access the wrong object.
-      output.add("${namer.currentIsolate}$_=${_}arguments[1]$N");
+      body.add(js.statement("${namer.currentIsolate} = arguments[1];"));
 
-      emitCompileTimeConstants(
-          output, fragment.constants, isMainFragment: false);
-      emitStaticNonFinalFieldInitializations(output, outputUnit);
+      body.add(buildCompileTimeConstants(fragment.constants,
+                                         isMainFragment: false));
+      body.add(buildStaticNonFinalFieldInitializations(outputUnit));
 
-      output.add('}$N');
+      List<jsAst.Statement> statements = <jsAst.Statement>[];
+
+      statements..add(buildGeneratedBy())
+          ..add(js.statement('${deferredInitializers}.current = '
+              """function (${globalsHolder}) {
+                   #
+                 }
+                             """, [body]));
+
+      output.addBuffer(jsAst.prettyPrint(new jsAst.Program(statements),
+                                         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('${deferredInitializers}["$hash"]$_=$_'
+      output.add('$N${deferredInitializers}["$hash"]$_=$_'
                        '${deferredInitializers}.current$N');
 
       if (generateSourceMap) {
-
         Uri mapUri, partUri;
         Uri sourceMapUri = compiler.sourceMapUri;
         Uri outputUri = compiler.outputUri;
 
         String partName = "$partPrefix.part";
 
         if (sourceMapUri != null) {
           String mapFileName = partName + ".js.map";
           List<String> mapSegments = sourceMapUri.pathSegments.toList();
           mapSegments[mapSegments.length - 1] = mapFileName;
@@ skipping 13 matching lines @@
                         mapUri, partUri);
       } else {
         output.close();
       }
 
       hunkHashes[outputUnit] = hash;
     }
     return hunkHashes;
   }
 
-  String buildGeneratedBy() {
-    var suffix = '';
+  jsAst.Comment buildGeneratedBy() {
+    String suffix = '';
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
-    return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
+    String msg = '// Generated by dart2js, the Dart to JavaScript '
+                 'compiler$suffix.';
+    return new jsAst.Comment(msg);
   }
 
   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].
@@ skipping 24 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }