dart2js: lazily load fields in their own deferred parts

pkg/compiler/lib/src/js_emitter/full_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.
 
 library dart2js.js_emitter.full_emitter;
 
 import 'dart:convert';
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 656 matching lines @@
           reporter.withCurrentElement(element, () {
             parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
 
     return new jsAst.Block(parts);
   }
 
-  jsAst.Statement buildLazilyInitializedStaticFields() {
-    JavaScriptConstantCompiler handler = backend.constants;
-    List<VariableElement> lazyFields =
-        handler.getLazilyInitializedFieldsForEmission();
+  jsAst.Statement buildLazilyInitializedStaticFields(Fragment fragment) {
+    List<StaticField> lazyFields = fragment.staticLazilyInitializedFields;
     if (lazyFields.isNotEmpty) {
       needsLazyInitializer = true;
-      List<jsAst.Expression> laziesInfo = buildLaziesInfo(lazyFields);
+      List<jsAst.Expression> laziesInfo =
+          buildLaziesInfo(lazyFields, fragment.isMainFragment);
       return js.statement('''
       (function(lazies) {
         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++];
-
+          if (#isDeferredFragment) {
+            var fieldHolder = 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 (#notMinified) {
-            #lazy(fieldName, getterName, lazyValue, staticName);
+          if (#isMainFragment) {

[floitsch, 2016/01/12 13:38:38]

Do we do the right thing for "if / else" when the condition is a boolean?
Maybe you need to change it to two "ifs".

[Harry Terkelsen, 2016/01/12 18:37:52]

From examining the output, it looks like it is doing the right thing.

+            if (#notMinified) {
+              #lazy(fieldName, getterName, lazyValue, staticName);
+            } else {
+              #lazy(fieldName, getterName, lazyValue);
+            }
           } else {
-            #lazy(fieldName, getterName, lazyValue);
+            if (#notMinified) {

[floitsch, 2016/01/12 13:38:38]

ditto.

[Harry Terkelsen, 2016/01/12 18:37:52]

Done.

+              #lazy(fieldName, getterName, lazyValue, staticName, fieldHolder);
+            } else {
+              #lazy(fieldName, getterName, lazyValue, null, fieldHolder);
+            }
           }
         }
       })(#laziesInfo)
       ''', {'notMinified': !compiler.enableMinification,
             'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
-            'lazy': js(lazyInitializerName)});
+            'lazy': js(lazyInitializerName),
+            'isMainFragment': fragment.isMainFragment,
+            'isDeferredFragment': !fragment.isMainFragment});
     } else {
       return js.comment("No lazy statics.");
     }
   }
 
-  List<jsAst.Expression> buildLaziesInfo(List<VariableElement> lazies) {
+  List<jsAst.Expression> buildLaziesInfo(
+      List<StaticField> lazies, bool isMainFragment) {
     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.add(js.quoteName(namer.globalPropertyName(element)));
-      laziesInfo.add(js.quoteName(namer.lazyInitializerName(element)));
+    for (StaticField field in lazies) {

[floitsch, 2016/01/12 13:38:38]

Why don't you sort by position anymore?

[Harry Terkelsen, 2016/01/12 18:37:52]

fragment.staticLazilyInitializedFields is already sorted by position. See
https://github.com/dart-lang/sdk/blob/d0f456a910675bab3b47b80fddf1fda5ee9b7fa...

+      laziesInfo.add(js.quoteName(field.name));
+      laziesInfo.add(js.quoteName(namer.deriveLazyInitializerName(field.name)));
       if (!compiler.enableMinification) {

[floitsch, 2016/01/12 13:38:38]

maybe move the optional minification next to the optional holder.

(Not necessary, but it looks like you only need to change line 688+ and the line
here).

[Harry Terkelsen, 2016/01/12 18:37:52]

Done.

-        laziesInfo.add(js.string(element.name));
+        laziesInfo.add(js.quoteName(field.name));
       }
-      laziesInfo.add(code);
+      laziesInfo.add(field.code);
+      if (!isMainFragment) {
+        laziesInfo.add(js('#', field.holder.name));

[floitsch, 2016/01/12 13:38:38]

I believe that the field.holder.name will always be "$" (the static-state
holder), but that's probably ok.

The full emitter is a bit more complicated because it contains code for
incremental updates...

[Harry Terkelsen, 2016/01/12 18:37:52]

I think you're right. I considered doing 'namer.staticStateHolder' instead but
this seemed cleaner.

+      }
     }
     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
@@ skipping 826 matching lines @@
       "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
       "makeConstantList":
           buildMakeConstantList(program.outputContainsConstantList),
       "compileTimeConstants":  buildCompileTimeConstants(mainFragment.constants,
                                                          isMainFragment: true),
       "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
       "staticNonFinalInitializers": buildStaticNonFinalFieldInitializations(
           mainOutputUnit),
       "typeToInterceptorMap":
           interceptorEmitter.buildTypeToInterceptorMap(program),
-      "lazyStaticFields": buildLazilyInitializedStaticFields(),
+      "lazyStaticFields": buildLazilyInitializedStaticFields(mainFragment),

[floitsch, 2016/01/12 13:38:38]

I'm ok with this, but I prefer, when we only send in the data that is needed.
It makes it more explicit what buildLazilyInitializedStaticFields depends on.

[Harry Terkelsen, 2016/01/12 18:37:52]

Done.

       "metadata": buildMetadata(program, mainOutputUnit),
       "convertToFastObject": buildConvertToFastObjectFunction(),
       "convertToSlowObject": buildConvertToSlowObjectFunction(),
       "convertGlobalObjectsToFastObjects":
           buildConvertGlobalObjectToFastObjects(),
       "debugFastObjects": buildDebugFastObjectCode(),
       "init": buildInitFunction(program.outputContainsConstantList),
       "main": buildMain(mainFragment.invokeMain)
     }));
 
@@ skipping 405 matching lines @@
             js.statement('$setupProgramName(dart, ${typesAccess}.length);'));
       }
 
       body..add(buildMetadata(program, outputUnit))
           ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
                              '${namer.deferredTypesName});'));
 
       body.add(buildCompileTimeConstants(fragment.constants,
                                          isMainFragment: false));
       body.add(buildStaticNonFinalFieldInitializations(outputUnit));
+      body.add(buildLazilyInitializedStaticFields(fragment));
 
       List<jsAst.Statement> statements = <jsAst.Statement>[];
 
       statements
           ..add(buildGeneratedBy())
           ..add(buildDeferredHeader())
           ..add(js.statement('${deferredInitializers}.current = '
                              """function (#, ${namer.staticStateHolder}) {
                                   #
                                 }
@@ skipping 121 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }