Incremental compilation of added instance fields.

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 10 matching lines @@
     Element,
     FunctionElement,
     LibraryElement,
     STATE_NOT_STARTED,
     ScopeContainerElement;
 
 import 'package:compiler/src/scanner/scannerlib.dart' show
     EOF_TOKEN,
     PartialClassElement,
     PartialElement,
+    PartialFieldList,
     PartialFunctionElement,
     Token;
 
 import 'package:compiler/src/source_file.dart' show
     StringSourceFile;
 
 import 'package:compiler/src/tree/tree.dart' show
     ClassNode,
     FunctionExpression,
     NodeList;
@@ skipping 68 matching lines @@
   final Uri uri;
 
   final List<Update> updates = <Update>[];
 
   final List<FailedUpdate> _failedUpdates = <FailedUpdate>[];
 
   final Set<ElementX> _elementsToInvalidate = new Set<ElementX>();
 
   final Set<ElementX> _removedElements = new Set<ElementX>();
 
+  final Set<ClassElementX> _classesWithSchemaChanges =
+      new Set<ClassElementX>();
+
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
       this.logVerbose);
 
   /// When [true], updates must be applied (using [applyUpdates]) before the
   /// [compiler]'s state correctly reflects the updated program.
   bool get hasPendingUpdates => !updates.isEmpty;
@@ skipping 49 matching lines @@
 
   bool canReuseScopeContainerElement(
       ScopeContainerElement element,
       ScopeContainerElement newElement) {
     List<Difference> differences = computeDifference(element, newElement);
     logTime('Differences computed.');
     for (Difference difference in differences) {
       logTime('Looking at difference: $difference');
 
       if (difference.before == null && difference.after is PartialElement) {
-        canReuseAddedElement(difference.after, element);
+        canReuseAddedElement(difference.after, element, newElement);
         continue;
       }
       if (difference.after == null && difference.before is PartialElement) {
         canReuseRemovedElement(difference.before);
         continue;
       }
       Token diffToken = difference.token;
       if (diffToken == null) {
         cannotReuse(difference, "No difference token.");
         continue;
@@ skipping 20 matching lines @@
         assert(!_failedUpdates.isEmpty);
         continue;
       }
     }
 
     return _failedUpdates.isEmpty;
   }
 
   bool canReuseAddedElement(
       PartialElement element,
-      ScopeContainerElement container) {
+      ScopeContainerElement container,
+      ScopeContainerElement syntheticContainer) {
     if (element is PartialFunctionElement) {
       addFunction(element, container);
       return true;
     } else if (element is PartialClassElement) {
       addClass(element, container);
       return true;
+    } else if (element is PartialFieldList) {
+      addFields(element, container, syntheticContainer);
+      return true;
     }
-    return cannotReuse(element, "Added element that isn't a function.");
+    return cannotReuse(element, "Adding ${element.runtimeType} not supported.");
   }
 
   void addFunction(
       PartialFunctionElement element,
       /* ScopeContainerElement */ container) {
     invalidateScopesAffectedBy(element, container);
 
     updates.add(new AddedFunctionUpdate(compiler, element, container));
   }
 
   void addClass(
       PartialClassElement element,
       LibraryElementX library) {
     invalidateScopesAffectedBy(element, library);
 
     updates.add(new AddedClassUpdate(compiler, element, library));
   }
 
+  /// Called when a field in [definition] has changed.
+  ///
+  /// There's no direct link from a [PartialFieldList] to its implied
+  /// [FieldElementX], so instead we use [syntheticContainer], the (synthetic)
+  /// container created by [canReuseLibrary], or [canReuseClass] (through
+  /// [PartialClassElement.parseNode]). This container is scanned looking for
+  /// fields whose declaration site is [definition].
+  // TODO(ahe): It would be nice if [computeDifference] returned this
+  // information directly.
+  void addFields(
+      PartialFieldList definition,
+      ScopeContainerElement container,
+      ScopeContainerElement syntheticContainer) {
+    List<FieldElementX> fields = <FieldElementX>[];
+    syntheticContainer.forEachLocalMember((ElementX member) {
+      if (member.declarationSite == definition) {
+        fields.add(member);
+      }
+    });
+    for (FieldElementX field in fields) {
+      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);
+    }
+  }
+
+  void addInstanceField(FieldElementX element, ClassElementX cls) {
+    _classesWithSchemaChanges.add(cls);
+
+    updates.add(new AddedFieldUpdate(compiler, element, cls));
+  }
+
   bool canReuseRemovedElement(PartialElement element) {
     if (element is PartialFunctionElement) {
       removeFunction(element);
       return true;
     } else if (element is PartialClassElement) {
       removeClass(element);
       return true;
     }
     return cannotReuse(element, "Removed element that isn't a function.");
   }
@@ skipping 190 matching lines @@
         element.ensureResolved(compiler);
       }
     }
     compiler.processQueue(compiler.enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Clean this up. Don't call this method in analyze-only mode.
     if (compiler.analyzeOnly) return "/* analyze only */";
 
-    Set<PartialClassElement> changedClasses = new Set<PartialClassElement>();
+    Set<PartialClassElement> changedClasses =
+        new Set<PartialClassElement>.from(_classesWithSchemaChanges);
     for (Element element in updatedElements) {
       if (!element.isClass) {
         compiler.enqueuer.codegen.addToWorkList(element);
       } else {
         changedClasses.add(element);
       }
     }
     compiler.processQueue(compiler.enqueuer.codegen, null);
 
     List<jsAst.Statement> updates = <jsAst.Statement>[];
@@ skipping 403 matching lines @@
 
   PartialClassElement apply() {
     // TODO(ahe): Reuse compilation unit of element instead?
     CompilationUnitElementX compilationUnit = library.compilationUnit;
     PartialClassElement copy = element.copyWithEnclosing(compilationUnit);
     compilationUnit.addMember(copy, compiler);
     return copy;
   }
 }
 
+class AddedFieldUpdate extends Update with JsFeatures {
+  final FieldElementX element;
+
+  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);
+    container.addMember(copy, compiler);
+    return copy;
+  }
+}
+
+
 class ClassUpdate extends Update with JsFeatures {
   final PartialClassElement before;
 
   final PartialClassElement after;
 
   ClassUpdate(Compiler compiler, this.before, this.after)
       : super(compiler);
 
   PartialFunctionElement apply() {
     patchElement();
@@ skipping 114 matching lines @@
 
   ClassEmitter get classEmitter => backend.emitter.oldEmitter.classEmitter;
 
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder, "");
     return builder.fields;
   }
 }