dart2js: emit info on lazy fields in array.

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 502 matching lines @@
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeOutput output) {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
-      for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
-        jsAst.Expression init =
-            buildLazilyInitializedStaticField(element);
-        if (init == null) continue;
-        output.addBuffer(
-            jsAst.prettyPrint(init, compiler, monitor: compiler.dumpInfoTask));
-        output.add("$N");
-      }
+      List<jsAst.Expression> laziesInfo = buildLaziesInfo(lazyFields);
+      jsAst.Statement code = 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");
     }
   }
 
+  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.string(namer.globalPropertyName(element)),
+                           js.string(namer.lazyInitializerName(element)),
+                           code]);
+      } else {
+        laziesInfo.addAll([js.string(namer.globalPropertyName(element)),
+                           js.string(namer.lazyInitializerName(element)),
+                           code,
+                           js.string(element.name)]);
+      }
+    }
+    return laziesInfo;
+  }
+
   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.string(namer.globalPropertyName(element)),
            js.string(namer.lazyInitializerName(element)),
            code,
            js.string(element.name),
            isolateProperties]);
     }
 
     if (compiler.enableMinification) {
       return js('#(#,#,#)',
           [js(lazyInitializerName),
-              js.string(namer.globalPropertyName(element)),
-              js.string(namer.lazyInitializerName(element)),
-              code]);
+           js.string(namer.globalPropertyName(element)),
+           js.string(namer.lazyInitializerName(element)),
+           code]);
     } else {
       return js('#(#,#,#,#)',
           [js(lazyInitializerName),
-              js.string(namer.globalPropertyName(element)),
-              js.string(namer.lazyInitializerName(element)),
-              code,
-              js.string(element.name)]);
+           js.string(namer.globalPropertyName(element)),
+           js.string(namer.lazyInitializerName(element)),
+           code,
+           js.string(element.name)]);
     }
   }
 
   void emitMetadata(Program program, CodeOutput output) {
 
    addMetadataGlobal(List<String> list, String global) {
      String globalAccess = generateEmbeddedGlobalAccessString(global);
      output.add('$globalAccess$_=$_[');
      for (String data in list) {
        if (data is String) {
@@ skipping 154 matching lines @@
                   try {
                     result = this[fieldName] = lazyValue();
                   } finally {
                     // Use try-finally, not try-catch/throw as it destroys the
                     // stack trace.
                     if (result === sentinelUndefined)
                       this[fieldName] = null;
                   }
                 } else {
                   if (result === sentinelInProgress)
-                    // In minified mode, static name might not have been
-                    // provided, so fall back to the minified fieldName.
+                    // In minified mode, static name is not provided, so fall
+                    // back to the minified fieldName.
                     #cyclicThrow(staticName || fieldName);
                 }
 
                 return result;
               } finally {
                 this[getterName] = function() { return this[fieldName]; };
               }
             }
           }
         }
@@ skipping 521 matching lines @@
     emitDeferredBoilerPlate(mainOutput, deferredLoadHashes);
 
     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);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
@@ skipping 525 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }