Implement adding 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 44 matching lines @@
 
 import 'package:compiler/src/js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer;
 
 import 'package:compiler/src/util/util.dart' show
     Link,
     LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
+    ClassElementX,
     DeclarationSite,
-    ElementX;
+    ElementX,
+    LibraryElementX;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
@@ skipping 97 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);
+        canReuseAddedElement(difference.after, element);
         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 18 matching lines @@
       }
       if (!reuser(diffToken, before, after)) {
         assert(!_failedUpdates.isEmpty);
         continue;
       }
     }
 
     return _failedUpdates.isEmpty;
   }
 
-  bool canReuseAddedElement(PartialElement element) {
-    return cannotReuse(element, "Scope changed, element added.");
+  bool canReuseAddedElement(
+      PartialElement element,
+      ScopeContainerElement container) {
+    if (element is PartialFunctionElement) {
+      addFunction(element, container);
+      return true;
+    }
+    return cannotReuse(element, "Added element that isn't a function.");
+  }
+
+  void addFunction(
+      PartialFunctionElement element,
+      ScopeContainerElement container) {
+    invalidateScopesAffectedBy(element, container);
+
+    updates.add(new AddedFunctionUpdate(compiler, element, container));
   }
 
   bool canReuseRemovedElement(PartialElement element) {
     if (element is PartialFunctionElement) {
-      return canReuseRemovedFunction(element);
+      removeFunction(element);
+      return true;
     }
-    return cannotReuse(
-        element, "Removed element that isn't a method.");
+    return cannotReuse(element, "Removed element that isn't a function.");
   }
 
-  bool canReuseRemovedFunction(PartialFunctionElement element) {
+  void removeFunction(PartialFunctionElement element) {
     logVerbose("Removed method $element.");
 
-    ScopeContainerElement container = element.enclosingElement;
+    invalidateScopesAffectedBy(element, element.enclosingElement);
+
+    _removedElements.add(element);
+
+    updates.add(new RemovedFunctionUpdate(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);
         }
       });
     }
-
-    _removedElements.add(element);
-
-    updates.add(new RemovedFunctionUpdate(compiler, element));
-
-    return true;
   }
 
   /// Invoke [f] on each [DeclarationSite] in [element]. If [element] is a
   /// [ScopeContainerElement], invoke f on all local members as well.
   void scanSites(
       Element element,
       void f(ElementX element, DeclarationSite site)) {
     DeclarationSite site = declarationSite(element);
     if (site != null) {
       f(element, site);
@@ skipping 34 matching lines @@
     FunctionExpression node =
         after.parseNode(compiler).asFunctionExpression();
     if (node == null) {
       return cannotReuse(after, "Not a function expression: '$node'");
     }
     Token last = after.endToken;
     if (node.body != null) {
       last = node.body.getBeginToken();
     }
     if (isTokenBetween(diffToken, after.beginToken, last)) {
-      return cannotReuse(after, 'Signature changed.');
+      removeFunction(before);
+      addFunction(after, before.enclosingElement);
+      return true;
     }
     logVerbose('Simple modification of ${after} detected');
     updates.add(new FunctionUpdate(compiler, before, after));
     return true;
   }
 
   bool canReuseClass(
       Token diffToken,
       PartialClassElement before,
       PartialClassElement after) {
@@ skipping 120 matching lines @@
         jsAst.Node superAccess = namer.elementAccess(superclass);
         inherits.add(
             js.statement(
                 r'self.$dart_unsafe_eval.inheritFrom(#, #)',
                 [classAccess, superAccess]));
       }
     }
 
     updates.addAll(inherits);
 
+    for (RemovedFunctionUpdate update in removals) {
+      update.writeUpdateJsOn(updates);
+    }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (!element.isField) {
         updates.add(computeMemberUpdateJs(element));
       }
     }
-    for (RemovedFunctionUpdate update in removals) {
-      update.writeUpdateJsOn(updates);
-    }
 
     if (updates.length == 1) {
       return prettyPrintJs(updates.single);
     } else {
       return prettyPrintJs(js.statement('{#}', [updates]));
     }
   }
 
   jsAst.Node computeMemberUpdateJs(Element element) {
     MemberInfo info = emitter.oldEmitter.containerBuilder
@@ skipping 60 matching lines @@
 abstract class Update {
   final Compiler compiler;
 
   PartialElement get before;
 
   PartialElement get after;
 
   Update(this.compiler);
 
   /// Applies the update to [before] and returns that element.
-  PartialElement apply();
+  Element apply();
 
   bool get isRemoval => false;
 
   /// Called before any patches are applied to capture any state that is needed
   /// later.
   void captureState() {
   }
 }
 
 /// Represents an update of a function element.
@@ skipping 13 matching lines @@
 
   /// Destructively change the tokens in [before] to match those of [after].
   void patchElement() {
     before.beginToken = after.beginToken;
     before.endToken = after.endToken;
     before.getOrSet = after.getOrSet;
   }
 }
 
 abstract class ReuseFunction {
+  Compiler get compiler;
+
   PartialFunctionElement get before;
 
   /// Reset various caches and remove this element from the compiler's internal
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }
 
@@ skipping 32 matching lines @@
       if (backend.isAliasedSuperMember(element)) {
         superName = namer.getNameOfAliasedSuperMember(element);
       }
     } else {
       elementAccess = namer.elementAccess(element);
     }
 
     wasStateCaptured = true;
   }
 
-  PartialElement apply() {
+  PartialFunctionElement apply() {
     if (!wasStateCaptured) throw "captureState must be called before apply.";
     removeFromEnclosing();
     reuseElement();
     return null;
   }
 
   void removeFromEnclosing() {
     PartialClassElement cls = element.enclosingClass;
     if (cls == null) {
       removeFromLibrary(element.library);
@@ skipping 42 matching lines @@
       if (superName != null) {
         updates.add(
             js.statement('delete #.prototype.#', [elementAccess, superName]));
       }
     } else {
       updates.add(js.statement('delete #', [elementAccess]));
     }
   }
 }
 
+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";
+    }
+  }
+
+  PartialFunctionElement get before => null;
+
+  PartialElement get after => element;
+
+  PartialFunctionElement apply() {
+    Element enclosing = container;
+    if (enclosing.isLibrary) {
+      // TODO(ahe): Reuse compilation unit instead?
+      enclosing = enclosing.compilationUnit;
+    }
+    PartialFunctionElement copy = element.copyWithEnclosing(enclosing);
+    container.addMember(copy, compiler);
+    return copy;
+  }
+}
+
 /// Returns all qualified names in [element] with less than four identifiers. A
 /// qualified name is an identifier followed by a sequence of dots and
 /// identifiers, for example, "x", and "x.y.z". But not "x.y.z.w" ("w" is the
 /// fourth identifier).
 ///
 /// The longest possible name that can be resolved is three identifiers, for
 /// example, "prefix.MyClass.staticMethod". Since four or more identifiers
 /// cannot resolve to anything statically, they're not included in the returned
 /// value of this method.
 Set<String> qualifiedNamesIn(PartialElement element) {
@@ skipping 80 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;
   }
 }