Tweak order of parts of lazy initializer list.

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;
@@ skipping 558 matching lines @@
 
   jsAst.Statement buildLazilyInitializedStaticFields() {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (lazyFields.isNotEmpty) {
       needsLazyInitializer = true;
       List<jsAst.Expression> laziesInfo = buildLaziesInfo(lazyFields);
       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];
+        for (var i = 0; i < lazies.length; ) {
+          var fieldName = lazies[i++];
+          var getterName = lazies[i++];
+          if (#notMinified) {
+            var staticName = lazies[i++];
           }
+          var lazyValue = lazies[i++];
 
           // 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) {
+          if (#notMinified) {
             #lazy(fieldName, getterName, lazyValue, staticName);
           } else {
             #lazy(fieldName, getterName, lazyValue);
           }
         }
       })(#laziesInfo)
-      ''', {'notInMinifiedMode': !compiler.enableMinification,
+      ''', {'notMinified': !compiler.enableMinification,
             'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
             'lazy': js(lazyInitializerName)});
     } 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.
       if (code == null) continue;
-      if (compiler.enableMinification) {
-        laziesInfo.addAll([js.quoteName(namer.globalPropertyName(element)),
-                           js.quoteName(namer.lazyInitializerName(element)),
-                           code]);
-      } else {
-        laziesInfo.addAll([js.quoteName(namer.globalPropertyName(element)),
-                           js.quoteName(namer.lazyInitializerName(element)),
-                           code,
-                           js.string(element.name)]);
+      laziesInfo.add(js.quoteName(namer.globalPropertyName(element)));
+      laziesInfo.add(js.quoteName(namer.lazyInitializerName(element)));
+      if (!compiler.enableMinification) {
+        laziesInfo.add(js.string(element.name));
       }
+      laziesInfo.add(code);
     }
     return laziesInfo;
   }
 
+  // TODO(sra): Remove this unused function.
   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);
@@ skipping 1362 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }