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 834 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, isolateProperties);
-        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('''
+         {

[herhut, 2015/04/01 07:43:05]

Why the block? If you were hoping for a new variable scope, JavaScript won't
give that to you. For that, you need a function. Maybe a layout like

(function(lazies) { ...code...})([lazieslist])

would be better anyway.

[zarah, 2015/04/01 11:05:08]

No it was to have a single statement. Changed it to your suggestion.

+           var lazies = #laziesInfo;
+           for (var i = 0; i < lazies.length; i += 5) {
+             var prototype = lazies[i];
+             var staticName = lazies[i + 1];
+             var fieldName = lazies [i + 2];
+             var getterName = lazies[i + 3];
+             var lazyValue = lazies[i + 4];
+
+             // We build the lazy-check here:
+             //   lazyInitializer(prototype, staticName, fieldName, getterName,
+             //                   lazyValue);
+             // The staticName is used for error reporting. The 'lazyValue' must
+             // be a closure that constructs the initial value.
+             #lazy(prototype, staticName, fieldName, getterName, lazyValue);

[herhut, 2015/04/01 07:43:05]

This has become a little more complicated now, as staticName may or may not
exist depending on whether we are in minified mode.

[zarah, 2015/04/01 11:05:08]

Changed to handle this.

+           }
+         }
+      ''', {'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
+            'lazy': js(lazyInitializerName)});
+
+      output.addBuffer(
+          jsAst.prettyPrint(code, compiler, monitor: compiler.dumpInfoTask));
+      output.add("$N");
     }
   }
 
-  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(prototype, 'name', fieldName, getterName, initial);
-    // The name is used for error reporting. The 'initial' must be a
-    // closure that constructs the initial value.
-    return js('#(#,#,#,#,#)',
-        [js(lazyInitializerName),
-            js(isolateProperties),
-            js.string(element.name),
-            js.string(namer.globalPropertyName(element)),
-            js.string(namer.lazyInitializerName(element)),
-            code]);
+  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;
+      laziesInfo.addAll([js(isolateProperties),
+                     js.string(element.name),

[floitsch, 2015/03/24 16:28:17]

nit: indentation seems off.

[zarah, 2015/04/01 11:05:08]

Done.

+                     js.string(namer.globalPropertyName(element)),
+                     js.string(namer.lazyInitializerName(element)),
+                     code]);
+    }
+    return laziesInfo;
   }
 
   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) {
          if (data != 'null') {
@@ skipping 1233 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }