dart2js --fast-startup emitter - elide unused phases

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js.js_emitter.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 911 matching lines @@
           inheritCalls
               .add(js.js.statement('# = #', [temp, superclassReference]));
         }
         for (Class cls in list) {
           inheritCalls.add(
               js.js.statement('inherit(#, #)', [classReference(cls), temp]));
         }
       }
     }
 
-    return wrapPhase(
-        'inheritance', js.js.statement('{#; #;}', [inheritCalls, mixinCalls]));
+    return wrapPhase('inheritance', inheritCalls.toList()..addAll(mixinCalls));
   }
 
   /// Emits the setup of method aliases.
   ///
   /// This step consists of simply copying JavaScript functions to their
   /// aliased names so they point to the same function.
   js.Statement emitInstanceMethodAliases(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
 
     for (Library library in fragment.libraries) {
@@ skipping 110 matching lines @@
           "optionalParameterDefaultValues": optionalParameterDefaultValues,
           "callNames": callNameArray,
           "funsOrNames": funsOrNamesArray,
           "funType": method.functionType,
         });
   }
 
   /// Wraps the statement in a named function to that it shows up as a unit in
   /// profiles.
   // TODO(sra): Should this be conditional?
-  js.Statement wrapPhase(String name, js.Statement statement) {
-    return js.js.statement('(function #(){#})();', [name, statement]);
+  js.Statement wrapPhase(String name, List<js.Statement> statements) {
+    js.Block block = new js.Block(statements);
+    if (statements.isEmpty) return block;
+    return js.js.statement('(function #(){#})();', [name, block]);
   }
 
   /// Emits the section that installs tear-off getters.
   js.Statement emitInstallTearOffs(Fragment fragment) {
     List<js.Statement> inits = <js.Statement>[];
     js.Expression temp;
 
     for (Library library in fragment.libraries) {
       for (StaticMethod method in library.statics) {
         // TODO(floitsch): can there be anything else than a StaticDartMethod?
@@ skipping 16 matching lines @@
           }
           // First call uses assignment to temp to cache the container.
           reference = js.js('# = #', [temp, container]);
         }
         for (InstanceMethod method in methods) {
           inits.add(emitInstallTearOff(reference, method));
           reference = temp; // Second and subsequent calls use temp.
         }
       }
     }
-    return wrapPhase('installTearOffs', new js.Block(inits));
+    return wrapPhase('installTearOffs', inits);
   }
 
   /// Emits the constants section.
   js.Statement emitConstants(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
     for (Constant constant in fragment.constants) {
       // TODO(floitsch): instead of just updating the constant holder, we should
       // find the constants that don't have any dependency on other constants
       // and create an object-literal with them (and assign it to the
       // constant-holder variable).
       var assignment = js.js.statement('#.# = #', [
         constant.holder.name,
         constant.name,
         constantEmitter.generate(constant.value)
       ]);
       compiler.dumpInfoTask.registerConstantAst(constant.value, assignment);
       assignments.add(assignment);
     }
-    return wrapPhase('constants', new js.Block(assignments));
+    return wrapPhase('constants', assignments);
   }
 
   /// Emits the static non-final fields section.
   ///
   /// This section initializes all static non-final fields that don't require
   /// an initializer.
   js.Statement emitStaticNonFinalFields(Fragment fragment) {
     List<StaticField> fields = fragment.staticNonFinalFields;
     // TODO(floitsch): instead of assigning the fields one-by-one we should
     // create a literal and assign it to the static-state holder.
     // TODO(floitsch): if we don't make a literal we should at least initialize
     // statics that have the same initial value in the same expression:
     //    `$.x = $.y = $.z = null;`.
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       assert(field.holder.isStaticStateHolder);
       return js.js
           .statement("#.# = #;", [field.holder.name, field.name, field.code]);
     });
-    return wrapPhase('staticFields', new js.Block(statements.toList()));
+    return wrapPhase('staticFields', statements.toList());
   }
 
   /// Emits lazy fields.
   ///
   /// This section initializes all static (final and non-final) fields that
   /// require an initializer.
   js.Statement emitLazilyInitializedStatics(Fragment fragment) {
     List<StaticField> fields = fragment.staticLazilyInitializedFields;
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       assert(field.holder.isStaticStateHolder);
       return js.js.statement("lazy(#, #, #, #);", [
         field.holder.name,
         js.quoteName(field.name),
         js.quoteName(namer.deriveLazyInitializerName(field.name)),
         field.code
       ]);
     });
 
-    return wrapPhase('lazyInitializers', new js.Block(statements.toList()));
+    return wrapPhase('lazyInitializers', statements.toList());
   }
 
   /// Emits the embedded globals that are needed for deferred loading.
   ///
   /// This function is only invoked for the main fragment.
   ///
   /// The [loadMap] contains a map from load-ids (for each deferred library)
   /// to the list of generated fragments that must be installed when the
   /// deferred library is loaded.
   Iterable<js.Property> emitEmbeddedGlobalsForDeferredLoading(
@@ skipping 293 matching lines @@
           }
         }
       }
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(
         js.js.statement("setOrUpdateLeafTags(#);", js.objectLiteral(leafTags)));
     statements.addAll(subclassAssignments);
 
-    return wrapPhase('nativeSupport', new js.Block(statements));
+    return wrapPhase('nativeSupport', statements);
   }
 }