Incremental compilation of new lazy statics.

dart/pkg/dart2js_incremental/lib/library_updater.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_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 280 matching lines @@
     });
     for (FieldElementX field in fields) {
       // TODO(ahe): This only works when there's one field per
       // PartialFieldList.
       addField(field, container);
     }
   }
 
   void addField(FieldElementX element, ScopeContainerElement container) {
     invalidateScopesAffectedBy(element, container);
-    if (!element.isInstanceMember) {
-      cannotReuse(element, "Not an instance field.");
-    } else {
-      addInstanceField(element, container);
+    if (element.isInstanceMember) {
+      _classesWithSchemaChanges.add(container);
     }
-  }
-
-  void addInstanceField(FieldElementX element, ClassElementX cls) {
-    _classesWithSchemaChanges.add(cls);
-
-    updates.add(new AddedFieldUpdate(compiler, element, cls));
+    updates.add(new AddedFieldUpdate(compiler, element, container));
   }
 
   bool canReuseRemovedElement(
       PartialElement element,
       ScopeContainerElement container) {
     if (element is PartialFunctionElement) {
       removeFunction(element);
       return true;
     } else if (element is PartialClassElement) {
       removeClass(element);
@@ skipping 324 matching lines @@
       updates.add(
           js.statement(
               r'# = self.$dart_unsafe_eval.schemaChange(#, #, #)',
               [classAccess, invokeDefineClass(cls), classAccess, superAccess]));
     }
 
     for (RemovalUpdate update in removals) {
       update.writeUpdateJsOn(updates);
     }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
-      if (!element.isField) {
-        updates.add(computeMemberUpdateJs(element));
+      if (element.isField) {
+        updates.addAll(computeFieldUpdateJs(element));
       } else {
-        if (backend.constants.lazyStatics.contains(element)) {
-          throw new StateError("$element requires lazy initializer.");
-        }
+        updates.add(computeMethodUpdateJs(element));
       }
     }
 
     updates.add(js.statement(r'''
 if (self.$dart_unsafe_eval.pendingStubs) {
   self.$dart_unsafe_eval.pendingStubs.map(function(e) { return e(); });
   self.$dart_unsafe_eval.pendingStubs = void 0;
 }
 '''));
 
@@ skipping 10 matching lines @@
     return js(
         r'''
 (new Function(
     "$collectedClasses", "$desc",
     self.$dart_unsafe_eval.defineClass(#, #) +"\n;return " + #))({#: #})''',
         [js.string(name), js.stringArray(computeFields(cls)),
          js.string(name),
          js.string(name), descriptor]);
   }
 
-  jsAst.Node computeMemberUpdateJs(Element element) {
+  jsAst.Node computeMethodUpdateJs(Element element) {
     MemberInfo info = containerBuilder.analyzeMemberMethod(element);
     if (info == null) {
       compiler.internalError(element, '${element.runtimeType}');
     }
     ClassBuilder builder = new ClassBuilder(element, namer);
     containerBuilder.addMemberMethodFromInfo(info, builder);
     jsAst.Node partialDescriptor =
         builder.toObjectInitializer(omitClassDescriptor: true);
 
     String name = info.name;
@@ skipping 12 matching lines @@
 
     jsAst.Expression globalFunctionsAccess =
         emitter.generateEmbeddedGlobalAccess(embeddedNames.GLOBAL_FUNCTIONS);
 
     return js.statement(
         r'self.$dart_unsafe_eval.addMethod(#, #, #, #, #)',
         [partialDescriptor, js.string(name), holder,
          new jsAst.LiteralBool(isStatic), globalFunctionsAccess]);
   }
 
+  List<jsAst.Statement> computeFieldUpdateJs(FieldElementX element) {
+    if (element.isInstanceMember) {
+      // Any initializers are inlined in factory methods, and the field is
+      // declared by adding its class to [_classesWithSchemaChanges].
+      return const <jsAst.Statement>[];
+    }
+    // A static (or top-level) field.
+    if (backend.constants.lazyStatics.contains(element)) {
+      jsAst.Expression init =
+          emitter.oldEmitter.buildLazilyInitializedStaticField(
+              element, namer.currentIsolate);
+      if (init == null) {
+        throw new StateError("Initializer optimized away for $element");
+      }
+      return <jsAst.Statement>[init.toStatement()];
+    } else {
+      // TODO(ahe): When a field is referenced it is enqueued. If the field has
+      // no initializer, it will not have any associated code, so it will
+      // appear as if it was newly enqueued.
+      if (element.initializer == null) {
+        return const <jsAst.Statement>[];
+      } else {
+        throw new StateError("Don't know how to compile $element");
+      }
+    }
+  }
+
   String prettyPrintJs(jsAst.Node node) {
     jsAst.Printer printer = new jsAst.Printer(compiler, null);
     printer.blockOutWithoutBraces(node);
     return printer.outBuffer.getText();
   }
 
   String callNameFor(FunctionElement element) {
     // TODO(ahe): Call a method in the compiler to obtain this name.
     String callPrefix = namer.callPrefix;
     int parameterCount = element.functionSignature.parameterCount;
@@ skipping 328 matching lines @@
   final ScopeContainerElement container;
 
   AddedFieldUpdate(Compiler compiler, this.element, this.container)
       : super(compiler);
 
   PartialFieldList get before => null;
 
   PartialFieldList get after => element.declarationSite;
 
   FieldElementX apply() {
-    FieldElementX copy = element.copyWithEnclosing(container);
+    Element enclosing = container;
+    if (enclosing.isLibrary) {
+      // TODO(ahe): Reuse compilation unit of element instead?
+      enclosing = enclosing.compilationUnit;
+    }
+    FieldElementX copy = element.copyWithEnclosing(enclosing);
     NO_WARN(container).addMember(copy, compiler);
     return copy;
   }
 }
 
 
 class ClassUpdate extends Update with JsFeatures {
   final PartialClassElement before;
 
   final PartialClassElement after;
@@ skipping 125 matching lines @@
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder, "");
     return builder.fields;
   }
 }
 
 // TODO(ahe): Remove this method.
 NO_WARN(x) => x;