Apply updates to static 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
     UTF8;
 
 import 'package:compiler/compiler.dart' as api;
 
 import 'package:compiler/implementation/dart2jslib.dart' show
     Compiler,
     Script;
 
 import 'package:compiler/implementation/elements/elements.dart' show
     Element,
     FunctionElement,
-    LibraryElement;
+    LibraryElement,
+    ScopeContainerElement;
 
 import 'package:compiler/implementation/scanner/scannerlib.dart' show
     EOF_TOKEN,
+    PartialClassElement,
     PartialElement,
     PartialFunctionElement,
     Token;
 
 import 'package:compiler/implementation/source_file.dart' show
     StringSourceFile;
 
 import 'package:compiler/implementation/tree/tree.dart' show
-    FunctionExpression;
+    ClassNode,
+    FunctionExpression,
+    NodeList;
 
 import 'package:compiler/implementation/js/js.dart' show
     js;
 
 import 'package:compiler/implementation/js/js.dart' as jsAst;
 
 import 'package:compiler/implementation/js_emitter/js_emitter.dart' show
     CodeEmitterTask,
     MemberInfo;
 
 import 'package:compiler/js_lib/shared/embedded_names.dart' as embeddedNames;
 
 import 'package:compiler/implementation/js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
+typedef bool Reuser(
+    Token diffToken,
+    PartialElement before,
+    PartialElement after);
+
 // TODO(ahe): Generalize this class. For now only works for Compiler.mainApp,
 // and only if that library has exactly one compilation unit.
 class LibraryUpdater {
   final Compiler compiler;
 
   final api.CompilerInputProvider inputProvider;
 
   final Logger logTime;
 
   final Logger logVerbose;
 
   // TODO(ahe): Get rid of this field. It assumes that only one library has
   // changed.
   final Uri uri;
 
   // When [true], updates must be applied (using [applyUpdates]) before the
   // [compiler]'s state correctly reflects the updated program.
   bool hasPendingUpdates = false;
 
+  bool onlySimpleUpdates = true;
+
   final List<Update> updates = <Update>[];
 
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
       this.logVerbose);
 
   JavaScriptBackend get backend => compiler.backend;
@@ skipping 33 matching lines @@
       return true;
     }
 
     logTime("Source did change");
     Script sourceScript = new Script(
         uri, uri, new StringSourceFile('$uri', newSource));
     var dartPrivacyIsBroken = compiler.libraryLoader;
     LibraryElement newLibrary = dartPrivacyIsBroken.createLibrarySync(
         null, sourceScript, uri);
     logTime('New library synthesized.');
-    List<Difference> differences = computeDifference(library, newLibrary);
+    return canReuseScopeContainerElement(library, newLibrary);
+  }
+
+  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 == null) {
         logVerbose('Scope changed in $difference');
         // Scope changed, don't reuse library.
+        onlySimpleUpdates = false;
         return false;
       }
       Token diffToken = difference.token;
       if (diffToken == null) {
         logVerbose('No token stored in difference.');
+        onlySimpleUpdates = false;
         return false;
       }
       if (difference.after is! PartialElement &&
           difference.before is! PartialElement) {
         logVerbose('Not a PartialElement: $difference');
         // Don't know how to recompile element.
+        onlySimpleUpdates = false;
         return false;
       }
       PartialElement before = difference.before;
       PartialElement after = difference.after;
 
+      Reuser reuser;
+
       if (before is PartialFunctionElement && after is PartialFunctionElement) {
-        if (!canReuseFunction(diffToken, before, after)) {
-          return false;
-        }
+        reuser = canReuseFunction;
+      } else if (before is PartialClassElement &&
+                 after is PartialClassElement) {
+        reuser = canReuseClass;
       } else {
-        // Unhandled kind of element.
+        reuser = cannotReuse;
+      }
+      if (!reuser(diffToken, before, after)) {
+        onlySimpleUpdates = false;
         return false;
       }
     }
     hasPendingUpdates = true;
 
     return true;
   }
 
   /// Returns true if function [before] can be reused to reflect the changes in
   /// [after].
   ///
   /// If [before] can be reused, an update (patch) is added to [updates].
   bool canReuseFunction(
       Token diffToken,
       PartialFunctionElement before,
       PartialFunctionElement after) {
     FunctionExpression node =
         after.parseNode(compiler).asFunctionExpression();
     if (node == null) {
-      print('Not a function expression.');
+      logVerbose('Not a function expression.');
       return false;
     }
     Token last = after.endToken;
     if (node.body != null) {
       last = node.body.getBeginToken();
     }
-    Token token = after.beginToken;
-    while (token != last && token.kind != EOF_TOKEN) {
-      if (token == diffToken) {
-        logVerbose('Signature changed');
-        return false;
-      }
-      token = token.next;
+    if (isTokenBetween(diffToken, after.beginToken, last)) {
+      logVerbose('Signature changed.');
+      return false;
     }
-    print('Simple modification of ${after} detected');
+    logVerbose('Simple modification of ${after} detected');
     updates.add(new FunctionUpdate(compiler, before, after));
     return true;
   }
 
+  bool canReuseClass(
+      Token diffToken,
+      PartialClassElement before,
+      PartialClassElement after) {
+    ClassNode node = after.parseNode(compiler).asClassNode();
+    if (node == null) {
+      logVerbose('Not a ClassNode.');
+      return false;
+    }
+    NodeList body = node.body;
+    if (body == null) {
+      logVerbose('Class has no body.');
+      return false;
+    }
+    if (isTokenBetween(diffToken, node.beginToken, body.beginToken)) {
+      logVerbose('Class header changed.');
+      return false;
+    }
+    logVerbose('Simple modification of ${after} detected');
+    return canReuseScopeContainerElement(before, after);
+  }
+
+  bool isTokenBetween(Token token, Token first, Token last) {
+    Token current = first;
+    while (current != last && current.kind != EOF_TOKEN) {
+      if (current == token) {
+        return true;
+      }
+      current = current.next;
+    }
+    return false;
+  }
+
+  bool cannotReuse(
+      Token diffToken,
+      PartialElement before,
+      PartialElement after) {
+    logVerbose(
+        'Unhandled change:'
+        ' ${before} (${before.runtimeType} -> ${after.runtimeType}).');
+    return false;
+  }
+
   List<Element> applyUpdates() {
+    if (!onlySimpleUpdates) {
+      throw new StateError("Can't compute update.");
+    }
     return updates.map((Update update) => update.apply()).toList();
   }
 
   String computeUpdateJs() {
     List<Element> updatedElements = applyUpdates();
     if (compiler.progress != null) {
       compiler.progress.reset();
     }
     for (Element element in updatedElements) {
       compiler.enqueuer.resolution.addToWorkList(element);
@@ skipping 102 matching lines @@
     before.getOrSet = after.getOrSet;
   }
 
   /// Reset various caches and remove this element from the compiler's internal
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }