Incremental compilation of removed class.

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 237 matching lines @@
       LibraryElementX library) {
     invalidateScopesAffectedBy(element, library);
 
     updates.add(new AddedClassUpdate(compiler, element, library));
   }
 
   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.");
   }
 
   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.enclosingElement);
+
+    _removedElements.add(element);
+    element.forEachLocalMember((ElementX member) {
+      _removedElements.add(member);
+    });
+
+    updates.add(new RemovedClassUpdate(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.
         Map<String, List<String>> names = qualifiedNamesIn(site);
         if (canNamesResolveStaticallyTo(names, element, container)) {
           _elementsToInvalidate.add(member);
         }
@@ skipping 327 matching lines @@
   PartialFunctionElement get before;
 
   /// Reset various caches and remove this element from the compiler's internal
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }
 
-class RemovedFunctionUpdate extends Update with JsFeatures, ReuseFunction {
-  final PartialFunctionElement element;
+class RemovalUpdate extends Update {
+  ElementX get element;
 
-  /// Name of property to remove using JavaScript "delete". Null for
-  /// non-instance methods.
-  String name;
-
-  /// Name of super-alias property to remove using JavaScript "delete".  Null
-  /// for methods that aren't "super aliased", and non-instance methods.
-  String superName;
-
-  /// For instance methods, access to class object. Otherwise, access to the
-  /// method itself.
-  jsAst.Node elementAccess;
-
-  bool wasStateCaptured = false;
-
-  RemovedFunctionUpdate(Compiler compiler, this.element)
+  RemovalUpdate(Compiler compiler)
       : super(compiler);
 
-  PartialFunctionElement get before => element;
-
-  PartialElement get after => null;
-
   bool get isRemoval => true;
 
-  void captureState() {
-    if (wasStateCaptured) throw "captureState was called twice.";
-
-    if (element.isInstanceMember) {
-      elementAccess = namer.elementAccess(element.enclosingClass);
-      name = namer.getNameOfMember(element);
-      if (backend.isAliasedSuperMember(element)) {
-        superName = namer.getNameOfAliasedSuperMember(element);
-      }
-    } else {
-      elementAccess = namer.elementAccess(element);
-    }
-
-    wasStateCaptured = true;
-  }
-
-  PartialFunctionElement apply() {
-    if (!wasStateCaptured) throw "captureState must be called before apply.";
-    removeFromEnclosing();
-    reuseElement();
-    return null;
-  }
+  void writeUpdateJsOn(List<jsAst.Statement> updates);
 
   void removeFromEnclosing() {
     // TODO(ahe): Need to recompute duplicated elements logic again. Simplest
     // solution is probably to remove all elements from enclosing scope and add
     // them back.
     PartialClassElement cls = element.enclosingClass;
     if (cls == null) {
       removeFromLibrary(element.library);
     } else {
       removeFromEnclosingClass(cls);
@@ skipping 17 matching lines @@
     LinkBuilder copy = new LinkBuilder();
 
     for (; !link.isEmpty; link = link.tail) {
       if (link.head != e) {
         copy.addLast(e);
       }
     }
 
     return copy.toLink(link);
   }
+}
+
+class RemovedFunctionUpdate extends RemovalUpdate
+    with JsFeatures, ReuseFunction {
+  final PartialFunctionElement element;
+
+  /// Name of property to remove using JavaScript "delete". Null for
+  /// non-instance methods.
+  String name;
+
+  /// Name of super-alias property to remove using JavaScript "delete".  Null
+  /// for methods that aren't "super aliased", and non-instance methods.
+  String superName;
+
+  /// For instance methods, access to class object. Otherwise, access to the
+  /// method itself.
+  jsAst.Node elementAccess;
+
+  bool wasStateCaptured = false;
+
+  RemovedFunctionUpdate(Compiler compiler, this.element)
+      : super(compiler);
+
+  PartialFunctionElement get before => element;
+
+  PartialFunctionElement get after => null;
+
+  void captureState() {
+    if (wasStateCaptured) throw "captureState was called twice.";
+    wasStateCaptured = true;
+
+    if (element.isInstanceMember) {
+      elementAccess = namer.elementAccess(element.enclosingClass);
+      name = namer.getNameOfMember(element);
+      if (backend.isAliasedSuperMember(element)) {
+        superName = namer.getNameOfAliasedSuperMember(element);
+      }
+    } else {
+      elementAccess = namer.elementAccess(element);
+    }
+  }
+
+  PartialFunctionElement apply() {
+    if (!wasStateCaptured) throw "captureState must be called before apply.";
+    removeFromEnclosing();
+    reuseElement();
+    return null;
+  }
 
   void writeUpdateJsOn(List<jsAst.Statement> updates) {
     if (elementAccess == null) {
       compiler.internalError(
           element, 'No elementAccess for ${element.runtimeType}');
     }
     if (element.isInstanceMember) {
       if (name == null) {
         compiler.internalError(element, 'No name for ${element.runtimeType}');
       }
       updates.add(
           js.statement('delete #.prototype.#', [elementAccess, name]));
 
       if (superName != null) {
         updates.add(
             js.statement('delete #.prototype.#', [elementAccess, superName]));
       }
     } else {
       updates.add(js.statement('delete #', [elementAccess]));
     }
   }
 }
 
+class RemovedClassUpdate extends RemovalUpdate with JsFeatures {
+  final PartialClassElement element;
+
+  bool wasStateCaptured = false;
+
+  final List<jsAst.Node> accessToStatics = <jsAst.Node>[];
+
+  RemovedClassUpdate(Compiler compiler, this.element)
+      : super(compiler);
+
+  PartialClassElement get before => element;
+
+  PartialClassElement get after => null;
+
+  bool get isRemoval => true;

[Johnni Winther, 2014/11/19 12:43:53]

Not needed. Is already declared in RemovalUpdate.

[ahe, 2014/11/21 10:47:45]

Done.

+
+  void captureState() {
+    if (wasStateCaptured) throw "captureState was called twice.";
+    wasStateCaptured = true;
+
+    accessToStatics.add(namer.elementAccess(element));
+
+    element.forEachLocalMember((ElementX member) {
+      if (!member.isInstanceMember) {
+        accessToStatics.add(namer.elementAccess(member));
+      }
+    });
+  }
+
+  PartialClassElement apply() {
+    if (!wasStateCaptured) {
+      throw new StateError("captureState must be called before apply.");
+    }
+
+    removeFromEnclosing();
+
+    element.forEachLocalMember((ElementX member) {
+      compiler.forgetElement(before);
+      member.reuseElement();
+    });
+
+    compiler.forgetElement(element);
+    element.reuseElement();
+
+    return null;
+  }
+
+  void writeUpdateJsOn(List<jsAst.Statement> updates) {
+    if (accessToStatics.isEmpty) {
+      throw
+          new StateError("captureState must be called before writeUpdateJsOn.");
+    }
+
+    for (jsAst.Node access in accessToStatics) {
+      updates.add(js.statement('delete #', [access]));
+    }
+  }
+}
+
 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 129 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;
   }
 }