Incremental compilation of removed 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 176 matching lines @@
     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, newElement);
         continue;
       }
       if (difference.after == null && difference.before is PartialElement) {
-        canReuseRemovedElement(difference.before);
+        canReuseRemovedElement(difference.before, element);
         continue;
       }
       Token diffToken = difference.token;
       if (diffToken == null) {
         cannotReuse(difference, "No difference token.");
         continue;
       }
       if (difference.after is! PartialElement &&
           difference.before is! PartialElement) {
         cannotReuse(difference, "Don't know how to recompile.");
@@ skipping 67 matching lines @@
       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) {
+      // 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);
     }
   }
 
   void addInstanceField(FieldElementX element, ClassElementX cls) {
     _classesWithSchemaChanges.add(cls);
 
     updates.add(new AddedFieldUpdate(compiler, element, cls));
   }
 
-  bool canReuseRemovedElement(PartialElement element) {
+  bool canReuseRemovedElement(
+      PartialElement element,
+      ScopeContainerElement container) {
     if (element is PartialFunctionElement) {
       removeFunction(element);
       return true;
     } else if (element is PartialClassElement) {
       removeClass(element);
       return true;
+    } else if (element is PartialFieldList) {
+      removeFields(element, container);
+      return true;
     }
-    return cannotReuse(element, "Removed element that isn't a function.");
+    return cannotReuse(
+        element, "Removing ${element.runtimeType} not supported.");
   }
 
   void removeFunction(PartialFunctionElement element) {
     logVerbose("Removed method $element.");
 
     invalidateScopesAffectedBy(element, element.enclosingElement);
 
     _removedElements.add(element);
 
     updates.add(new RemovedFunctionUpdate(compiler, element));
   }
 
   void removeClass(PartialClassElement element) {
     logVerbose("Removed class $element.");
 
     invalidateScopesAffectedBy(element, element.library);
 
     _removedElements.add(element);
     element.forEachLocalMember((ElementX member) {
       _removedElements.add(member);
     });
 
     updates.add(new RemovedClassUpdate(compiler, element));
   }
 
+  void removeFields(
+      PartialFieldList definition,
+      ScopeContainerElement container) {
+    List<FieldElementX> fields = <FieldElementX>[];
+    container.forEachLocalMember((ElementX member) {
+      if (member.declarationSite == definition) {
+        fields.add(member);
+      }
+    });
+    for (FieldElementX field in fields) {
+      // TODO(ahe): This only works when there's one field per
+      // PartialFieldList.
+      removeField(field);
+    }
+  }
+
+  void removeField(FieldElementX element) {
+    logVerbose("Removed field $element.");
+    if (!element.isInstanceMember) {
+      cannotReuse(element, "Not an instance field.");
+    } else {
+      removeInstanceField(element);
+    }
+  }
+
+  void removeInstanceField(FieldElementX element) {
+    PartialClassElement cls = element.enclosingClass;
+
+    _classesWithSchemaChanges.add(cls);
+    invalidateScopesAffectedBy(element, cls);
+
+    _removedElements.add(element);
+
+    updates.add(new RemovedFieldUpdate(compiler, element));
+  }
+
   void invalidateScopesAffectedBy(
       ElementX element,
       /* ScopeContainerElement */ container) {
     for (ScopeContainerElement scope in scopesAffectedBy(element, container)) {
       scanSites(scope, (Element member, DeclarationSite site) {
         // TODO(ahe): Cache qualifiedNamesIn to avoid quadratic behavior.
         Set<String> names = qualifiedNamesIn(site);
         if (canNamesResolveStaticallyTo(names, element, container)) {
           _elementsToInvalidate.add(member);
         }
@@ skipping 517 matching lines @@
       throw
           new StateError("captureState must be called before writeUpdateJsOn.");
     }
 
     for (jsAst.Node access in accessToStatics) {
       updates.add(js.statement('delete #', [access]));
     }
   }
 }
 
+class RemovedFieldUpdate extends RemovalUpdate with JsFeatures {
+  final FieldElementX element;
+
+  bool wasStateCaptured;
+
+  jsAst.Node elementAccess;
+
+  String getterName;
+
+  String setterName;
+
+  RemovedFieldUpdate(Compiler compiler, this.element)
+      : super(compiler);
+
+  void captureState() {
+    if (wasStateCaptured) throw "captureState was called twice.";
+    wasStateCaptured = true;
+
+    elementAccess = namer.elementAccess(element.enclosingClass);
+    getterName = namer.getterName(element);
+    setterName = namer.setterName(element);
+  }
+
+  FieldElementX apply() {
+    if (!wasStateCaptured) {
+      throw new StateError("captureState must be called before apply.");
+    }
+
+    removeFromEnclosing();
+
+    return element;
+  }
+
+  void writeUpdateJsOn(List<jsAst.Statement> updates) {
+    if (!wasStateCaptured) {
+      throw new StateError(
+          "captureState must be called before writeUpdateJsOn.");
+    }
+
+    updates.add(
+        js.statement('delete #.prototype.#', [elementAccess, getterName]));
+    updates.add(
+        js.statement('delete #.prototype.#', [elementAccess, setterName]));
+  }
+}
+
 class AddedFunctionUpdate extends Update with JsFeatures {
   final PartialFunctionElement element;
 
   final /* ScopeContainerElement */ container;
 
   AddedFunctionUpdate(Compiler compiler, this.element, this.container)
       : super(compiler) {
     if (container == null) {
       throw "container is null";
     }
@@ skipping 183 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;
   }
 }