Include reasons for failing in StateError.

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 46 matching lines @@
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
     PartialElement after);
 
+class FailedUpdate {
+  /// Either an [Element] or a [Difference].
+  final context;
+  final String message;
+
+  FailedUpdate(this.context, this.message);
+
+  String toString() {
+    if (context == null) return '$message';
+    return 'In $context:\n  $message';
+  }
+}
+
 // 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;
+  final List<Update> updates = <Update>[];
 
-  bool onlySimpleUpdates = true;
-
-  final List<Update> updates = <Update>[];
+  final List<FailedUpdate> _failedUpdates = <FailedUpdate>[];
 
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
       this.logVerbose);
 
+  /// When [true], updates must be applied (using [applyUpdates]) before the
+  /// [compiler]'s state correctly reflects the updated program.
+  bool get hasPendingUpdates => !updates.isEmpty;
+
+  bool get failed => !_failedUpdates.isEmpty;
+
   JavaScriptBackend get backend => compiler.backend;
 
   Namer get namer => backend.namer;
 
   CodeEmitterTask get emitter => backend.emitter;
 
   /// Used as tear-off passed to [LibraryLoaderTask.resetAsync].
   Future<bool> reuseLibrary(LibraryElement library) {
     assert(compiler != null);
     if (library.isPlatformLibrary || library.isPackageLibrary) {
@@ skipping 27 matching lines @@
     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.');
     return canReuseScopeContainerElement(library, newLibrary);
   }
 
+  bool cannotReuse(context, String message) {
+    _failedUpdates.add(new FailedUpdate(context, message));
+    logVerbose(message);
+    return false;
+  }
+
   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;
+        cannotReuse(difference, "Can't reuse; Scope changed.");
+        continue;
       }
       Token diffToken = difference.token;
       if (diffToken == null) {
-        logVerbose('No token stored in difference.');
-        onlySimpleUpdates = false;
-        return false;
+        cannotReuse(difference, "No difference token.");
+        continue;
       }
       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;
+        cannotReuse(difference, "Don't know how to recompile.");
+        continue;
       }
       PartialElement before = difference.before;
       PartialElement after = difference.after;
 
       Reuser reuser;
 
       if (before is PartialFunctionElement && after is PartialFunctionElement) {
         reuser = canReuseFunction;
       } else if (before is PartialClassElement &&
                  after is PartialClassElement) {
         reuser = canReuseClass;
       } else {
-        reuser = cannotReuse;
+        reuser = unableToReuse;
       }
       if (!reuser(diffToken, before, after)) {
-        onlySimpleUpdates = false;
-        return false;
+        assert(!_failedUpdates.isEmpty);
+        continue;
       }
     }
-    hasPendingUpdates = true;
 
-    return true;
+    return _failedUpdates.isEmpty;
   }
 
   /// 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) {
-      logVerbose('Not a function expression.');
-      return false;
+      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)) {
-      logVerbose('Signature changed.');
-      return false;
+      return cannotReuse(after, 'Signature changed.');
     }
     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;
+      return cannotReuse(after, "Not a ClassNode: '$node'");
     }
     NodeList body = node.body;
     if (body == null) {
-      logVerbose('Class has no body.');
-      return false;
+      return cannotReuse(after, "Class has no body.");
     }
     if (isTokenBetween(diffToken, node.beginToken, body.beginToken)) {
-      logVerbose('Class header changed.');
-      return false;
+      return cannotReuse(after, "Class header changed.");
     }
     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(
+  bool unableToReuse(
       Token diffToken,
       PartialElement before,
       PartialElement after) {
-    logVerbose(
+    return cannotReuse(
+        after,
         'Unhandled change:'
         ' ${before} (${before.runtimeType} -> ${after.runtimeType}).');
-    return false;
   }
 
   List<Element> applyUpdates() {
-    if (!onlySimpleUpdates) {
-      throw new StateError("Can't compute update.");
+    if (!_failedUpdates.isEmpty) {
+      throw new StateError(
+          "Can't compute update.\n\n${_failedUpdates.join('\n\n')}");
     }
     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) {
@@ skipping 109 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();
   }
 }