Implement removal of top-level methods.

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 37 matching lines @@
     MemberInfo;
 
 import 'package:_internal/compiler/js_lib/shared/embedded_names.dart'
     as embeddedNames;
 
 import 'package:compiler/src/js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer;
 
 import 'package:compiler/src/util/util.dart' show
-    Link;
+    Link,
+    LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
     DeclarationSite,
     ElementX;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
@@ skipping 153 matching lines @@
 
   bool canReuseRemovedElement(PartialElement element) {
     if (element is PartialFunctionElement) {
       return canReuseRemovedFunction(element);
     }
     return cannotReuse(
         element, "Removed element that isn't a method.");
   }
 
   bool canReuseRemovedFunction(PartialFunctionElement element) {
-    if (!element.isInstanceMember) {
-      return cannotReuse(
-          element, "Removed function that isn't an instance method.");
-    }
-    logVerbose("Removed instance method $element.");
+    logVerbose("Removed method $element.");
 
     PartialClassElement cls = element.enclosingClass;
+    if (cls != null && !element.isInstanceMember) {
+      return cannotReuse(element, "Removed static method");
+    }
     for (ScopeContainerElement scope in scopesAffectedBy(element, cls)) {
       scanSites(scope, (Element member, DeclarationSite site) {
         // TODO(ahe): Cache qualifiedNamesIn to avoid quadratic behavior.
         Map<String, List<String>> names = qualifiedNamesIn(site);
         if (canNamesResolveTo(names, element, cls)) {
           _elementsToInvalidate.add(member);
         }
       });
     }
 
@@ skipping 271 matching lines @@
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }
 
 class RemovedFunctionUpdate extends Update with JsFeatures, ReuseFunction {
   final PartialFunctionElement element;
 
-  /// Name of property to remove using JavaScript "delete".
+  /// 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" (should imply that this field is
-  /// null for all non-instance methods).
+  /// 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;
 
   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);
+      if (backend.isAliasedSuperMember(element)) {
+        superName = namer.getNameOfAliasedSuperMember(element);
+      }
+    } else {
+      elementAccess = namer.elementAccess(element);
     }
 
     wasStateCaptured = true;
   }
 
   PartialElement apply() {
     if (!wasStateCaptured) throw "captureState must be called before apply.";
-    removeFromEnclosingClass();
+    removeFromEnclosing();
     reuseElement();
     return null;
   }
 
-  void removeFromEnclosingClass() {
+  void removeFromEnclosing() {
     PartialClassElement cls = element.enclosingClass;
+    if (cls == null) {
+      removeFromLibrary(element.library);
+    } else {
+      removeFromEnclosingClass(cls);
+    }
+  }
 
-    Link<Element> localMembersReversed = const Link<Element>();
-    bool foundElement = false;
-    cls.forEachLocalMember((member) {
-      if (member != element) {
-        localMembersReversed = localMembersReversed.prepend(member);
-      } else {
-        if (foundElement) {
-          throw "Found '$element' twice in '$cls'.";
-        }
-        foundElement = true;
+  void removeFromEnclosingClass(PartialClassElement cls) {
+    cls.localMembersCache = null;
+    cls.localMembersReversed =
+        copyLinkWithout(element, cls.localMembersReversed);
+    cls.localScope.contents.remove(element.name);
+  }
+
+  void removeFromLibrary(LibraryElementX library) {
+    library.localMembers = copyLinkWithout(element, library.localMembers);
+    library.localScope.contents.remove(element.name);
+  }
+
+  Link copyLinkWithout(e, Link link) {
+    // TODO(ahe): Consider adding to [Link].
+    LinkBuilder copy = new LinkBuilder();
+
+    for (; !link.isEmpty; link = link.tail) {
+      if (link.head != e) {
+        copy.addLast(e);
       }
-    });
-    if (!foundElement) {
-      throw "Don't find '$element' in '$cls'.";
     }
-    cls.localMembersCache = null;
-    cls.localMembersReversed = localMembersReversed;
-    cls.localScope.contents.remove(element.name);
 
-    return null;
+    return copy.toLink(link);
   }
 
   void writeUpdateJsOn(List<jsAst.Statement> updates) {
-    if (name == null) {
-      compiler.internalError(element, '${element.runtimeType}');
+    if (elementAccess == null) {
+      compiler.internalError(
+          element, 'No elementAccess for ${element.runtimeType}');
     }
     if (element.isInstanceMember) {
-      jsAst.Node elementAccess = namer.elementAccess(element.enclosingClass);
+      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 {
-      compiler.internalError(
-          element, 'Removal of non-instance methods not yest supported.');
+      updates.add(js.statement('delete #', [elementAccess]));
     }
   }
 }
 
 Map<String, List<String>> qualifiedNamesIn(PartialElement element) {
   Token beginToken = element.beginToken;
   Token endToken = element.endToken;
   Token token = beginToken;
   if (element is PartialClassElement) {
     ClassNode node = element.cachedNode;
@@ skipping 44 matching lines @@
 
 abstract class JsFeatures {
   Compiler get compiler;
 
   JavaScriptBackend get backend => compiler.backend;
 
   Namer get namer => backend.namer;
 
   CodeEmitterTask get emitter => backend.emitter;
 }