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) {
+            if (#notMinified) {
+              #lazy(fieldName, getterName, lazyValue, staticName);
+            } else {
+              #lazy(fieldName, getterName, lazyValue);
+            }
           } else {
-            #lazy(fieldName, getterName, lazyValue);
+            if (#notMinified) {
+              #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

[Siggi Cherem (dart-lang), 2016/01/08 22:50:37]

just to make sure I follow - we now emit null code also because we can't
distinguish between the code being inlined and code added later by a lazy
fragment?

[Harry Terkelsen, 2016/01/11 18:01:21]

We don't emit null code. The code here that filters the initializers is no
longer necessary because fragment.lazilyInitializedStaticFields has already
filtered out null code. It was necessary before because
handler.getLazilyInitializedFieldsForEmission() is not filtered.

-      // 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) {
+      laziesInfo.add(js.quoteName(field.name));
+      laziesInfo.add(js.quoteName(namer.deriveLazyInitializerName(field.name)));

[Siggi Cherem (dart-lang), 2016/01/08 22:50:37]

so this no longer makes the name globally unique, correct?

Does that mean that we need to make changes in other places to use the correct
calling convention? For example, do we need to update
isolateLazyInitializerAccess?

I can see that the startup-emitter does something similar to what you do here,
is that working properly or there might be a bug there too?

[Harry Terkelsen, 2016/01/11 18:01:21]

It seems to be working properly in my simple test case for both the full emitter
and the startup emitter. It looks like the name is globally unique (a lazy
initializer named x in the main part is called 'x' and a lazy initializer named
x in a deferred part is named x0).

       if (!compiler.enableMinification) {
-        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));
+      }
     }
     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),
       "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);
 
       }
     }
   }
 }