Incremental compilation of new lazy statics.

dart/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 141 matching lines @@
   String get generateAccessorHolder
       => '$isolatePropertiesName.\$generateAccessor';
   String get finishClassesProperty
       => r'$finishClasses';
   String get finishClassesName
       => '${namer.isolateName}.$finishClassesProperty';
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
+  String get lazyInitializerProperty
+      => r'$lazy';
   String get lazyInitializerName
-      => '${namer.isolateName}.\$lazy';
+      => '${namer.isolateName}.${lazyInitializerProperty}';
   String get initName => 'init';
   String get makeConstListProperty
       => namer.getMappedInstanceName('makeConstantList');
 
   /// The name of the property that contains all field names.
   ///
   /// This property is added to constructors when isolate support is enabled.
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
@@ skipping 507 matching lines @@
            'leafTagsAccess': leafTagsAccess,
            'allowNativesSubclassing': true});
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its fields with the initial (and often final) value of all globals.
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
-    return js('''
+    return js(
+        """
       function (oldIsolate) {
-        var isolateProperties = oldIsolate.#;  // isolatePropertiesName
+        var isolateProperties = oldIsolate.#isolatePropertiesName;
         function Isolate() {
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           for (var staticName in isolateProperties)
             if (hasOwnProperty.call(isolateProperties, staticName))
               this[staticName] = isolateProperties[staticName];
 
           // Reset lazy initializers to null.
           // When forcing the object to fast mode (below) v8 will consider
           // functions as part the object's map. Since we will change them
           // (after the first call to the getter), we would have a map
@@ skipping 11 matching lines @@
           new ForceEfficientMap();
 
           // Now, after being a fast map we can set the lazies again.
           for (var lazyInit in lazies) {
             var lazyInitName = lazies[lazyInit];
             this[lazyInitName] = isolateProperties[lazyInitName];
           }
         }
         Isolate.prototype = oldIsolate.prototype;
         Isolate.prototype.constructor = Isolate;
-        Isolate.# = isolateProperties;  // isolatePropertiesName
-        if (#)  // needsDefineClass.
-          Isolate.# = oldIsolate.#;  // finishClassesProperty * 2
-        if (#)  // outputContainsConstantList
-          Isolate.# = oldIsolate.#; // makeConstListProperty * 2
-        return Isolate;
-      }''',
-        [namer.isolatePropertiesName, namer.isolatePropertiesName,
-         needsDefineClass, finishClassesProperty, finishClassesProperty,
-         task.outputContainsConstantList,
-         makeConstListProperty, makeConstListProperty ]);
+        Isolate.#isolatePropertiesName = isolateProperties;
+        if (#needsDefineClass)
+          Isolate.#finishClassesProperty = oldIsolate.#finishClassesProperty;
+        if (#outputContainsConstantList)
+          Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
+        if (#hasIncrementalSupport)
+          Isolate.#lazyInitializerProperty =
+              oldIsolate.#lazyInitializerProperty;
+         return Isolate;
+      }
+""",
+        { 'isolatePropertiesName': namer.isolatePropertiesName,
+          'needsDefineClass': needsDefineClass,
+          'finishClassesProperty': finishClassesProperty,
+          'outputContainsConstantList': task.outputContainsConstantList,
+          'makeConstListProperty': makeConstListProperty,
+          'hasIncrementalSupport': compiler.hasIncrementalSupport,
+          'lazyInitializerProperty': lazyInitializerProperty,
+        });
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.currentIsolate;
     jsAst.Expression cyclicThrow =
         staticFunctionAccess(backend.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
     return js('''
@@ skipping 270 matching lines @@
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
-        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;
-        // 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.
-        jsAst.Expression init = js('#(#,#,#,#,#)',
-            [js(lazyInitializerName),
-                js(isolateProperties),
-                js.string(element.name),
-                js.string(namer.getNameX(element)),
-                js.string(namer.getLazyInitializerName(element)),
-                code]);
-        buffer.write(jsAst.prettyPrint(init, compiler,
-                                       monitor: compiler.dumpInfoTask));
+        jsAst.Expression init =
+            buildLazilyInitializedStaticField(element, isolateProperties);
+        if (init == null) continue;
+        buffer.write(
+            jsAst.prettyPrint(init, compiler, monitor: compiler.dumpInfoTask));
         buffer.write("$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.getNameX(element)),
+            js.string(namer.getLazyInitializerName(element)),
+            code]);
+  }
+
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
@@ skipping 531 matching lines @@
         .write('${globalsHolder}.${namer.isolateName}$_=$_'
                '${namer.isolateName}$N'
                '${globalsHolder}.$initName$_=${_}$initName$N');
     }
     mainBuffer.add('init()$N$n');
     mainBuffer.add('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
     // Only output the classesCollector if we actually have any classes.
-    if (!(nativeClasses.isEmpty &&
+    if (needsDefineClass ||
+        !(nativeClasses.isEmpty &&
           compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
           outputClassLists.values.every((classList) => classList.isEmpty) &&
           typedefsNeededForReflection.isEmpty)) {
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector$_=${_}Object.create(null)$N$n');
     }
 
     if (!nativeClasses.isEmpty) {
       addComment('Native classes', mainBuffer);
@@ skipping 585 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }