Incremental compiler detects when library graph changes.

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/src/dart2jslib.dart' show
     Compiler,
     EnqueueTask,
     Script;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     Element,
     FunctionElement,
     LibraryElement,
     STATE_NOT_STARTED,
     ScopeContainerElement;
 
 import 'package:compiler/src/scanner/scannerlib.dart' show
     EOF_TOKEN,
+    Listener,
+    NodeListener,
+    Parser,
     PartialClassElement,
     PartialElement,
     PartialFieldList,
     PartialFunctionElement,
+    Scanner,
     Token;
 
 import 'package:compiler/src/source_file.dart' show
+    CachingUtf8BytesSourceFile,
+    SourceFile,
     StringSourceFile;
 
 import 'package:compiler/src/tree/tree.dart' show
     ClassNode,
     FunctionExpression,
-    NodeList;
+    LibraryTag,
+    NodeList,
+    Part,
+    StringNode,
+    unparse;
 
 import 'package:compiler/src/js/js.dart' show
     js;
 
 import 'package:compiler/src/js/js.dart' as jsAst;
 
 import 'package:compiler/src/js_emitter/js_emitter.dart' show
     ClassBuilder,
     ClassEmitter,
     CodeEmitterTask,
@@ skipping 24 matching lines @@
     Selector;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 import 'dart2js_incremental.dart' show
+    IncrementalCompilationFailed,
     IncrementalCompiler;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
     PartialElement after);
 
 class FailedUpdate {
@@ skipping 64 matching lines @@
 
   final Set<ElementX> _elementsToInvalidate = new Set<ElementX>();
 
   final Set<ElementX> _removedElements = new Set<ElementX>();
 
   final Set<ClassElementX> _classesWithSchemaChanges =
       new Set<ClassElementX>();
 
   final IncrementalCompilerContext _context;
 
+  final Map<Uri, Future> _sources = <Uri, Future>{};
+
   bool _hasComputedNeeds = false;
 
   bool _hasCapturedCompilerState = false;
 
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.logTime,
       this.logVerbose,
       this._context) {
@@ skipping 24 matching lines @@
   bool get failed => !_failedUpdates.isEmpty;
 
   /// Used as tear-off passed to [LibraryLoaderTask.resetAsync].
   Future<bool> reuseLibrary(LibraryElement library) {
     _ensureCompilerStateCaptured();
     assert(compiler != null);
     if (library.isPlatformLibrary) {
       logTime('Reusing $library (assumed read-only).');
       return new Future.value(true);
     }
-    for (CompilationUnitElementX unit in library.compilationUnits) {
-      Uri uri = unit.script.resourceUri;
-      if (_context._uriHasUpdate(uri)) {
-        if (!library.compilationUnits.tail.isEmpty) {
-          // TODO(ahe): Remove this restriction.
-          cannotReuse(library, "Multiple compilation units not supported.");
-          return new Future.value(true);
+    return _haveTagsChanged(library).then((bool haveTagsChanged) {
+      if (haveTagsChanged) {
+        cannotReuse(
+            library,
+            "Changes to library, import, export, or part declarations not"
+            " supported.");
+        return true;
+      }
+      for (CompilationUnitElementX unit in library.compilationUnits) {
+        Uri uri = unit.script.resourceUri;
+        if (_context._uriHasUpdate(uri)) {
+          if (!library.compilationUnits.tail.isEmpty) {
+            // TODO(ahe): Remove this restriction.
+            cannotReuse(
+                library,
+                "Multiple compilation units not supported"
+                " (${library.compilationUnits}).");
+            return true;
+          }
+          return _readUri(uri).then((bytes) {
+            return canReuseLibrary(library, bytes);
+          });
         }
-        return inputProvider(uri).then((bytes) {
-          return canReuseLibrary(library, bytes);
-        });
       }
+
+      logTime("Reusing $library, source didn't change.");
+      // Source code of [library] wasn't changed.
+      return true;
+    });
+  }
+
+  Future<bool> _haveTagsChanged(LibraryElement library) {
+    Uri uri = library.entryCompilationUnit.script.resourceUri;
+    if (!_context._uriHasUpdate(uri)) {
+      // The entry compilation unit hasn't been updated. So the tags aren't
+      // changed.
+      return new Future<bool>.value(false);
     }
 
-    logTime("Reusing $library, source didn't change.");
-    // Source code of [library] wasn't changed.
-    return new Future.value(true);
+    return _readUri(uri).then((bytes) {
+      String filename = '$uri';
+      SourceFile sourceFile = bytes is String
+          ? new StringSourceFile(filename, bytes)
+          : new CachingUtf8BytesSourceFile(filename, bytes);
+      Token token = new Scanner(sourceFile).tokenize();
+      // Using two parsers to only create the nodes we want ([LibraryTag]).
+      Parser parser = new Parser(new Listener());
+      NodeListener listener = new NodeListener(
+          compiler, library.entryCompilationUnit);
+      Parser nodeParser = new Parser(listener);
+      Iterator<LibraryTag> tags = library.tags.iterator;
+      while (token.kind != EOF_TOKEN) {
+        token = parser.parseMetadataStar(token);
+        if (parser.optional('library', token) ||
+            parser.optional('import', token) ||
+            parser.optional('export', token) ||
+            parser.optional('part', token)) {
+          if (!tags.moveNext()) return true;
+          token = nodeParser.parseTopLevelDeclaration(token);
+          LibraryTag tag = listener.popNode();
+          assert(listener.nodes.isEmpty);
+          if (unparse(tags.current) != unparse(tag)) {
+            return true;
+          }
+        } else {
+          break;
+        }
+      }
+      return tags.moveNext();
+    });
+  }
+
+  Future _readUri(Uri uri) {
+    return _sources.putIfAbsent(uri, () => inputProvider(uri));
   }
 
   void _ensureCompilerStateCaptured() {
     // TODO(ahe): [compiler] shouldn't be null, remove the following line.
     if (compiler == null) return;
 
     if (_hasCapturedCompilerState) return;
     _context._captureState(compiler);
     _hasCapturedCompilerState = true;
   }
@@ skipping 334 matching lines @@
   }
 
   /// Apply the collected [updates]. Return a list of elements that needs to be
   /// recompiled after applying the updates. Any elements removed as a
   /// consequence of applying the patches are added to [removals] if provided.
   List<Element> applyUpdates([List<Update> removals]) {
     for (Update update in updates) {
       update.captureState();
     }
     if (!_failedUpdates.isEmpty) {
-      throw new StateError(
-          "Can't compute update.\n\n${_failedUpdates.join('\n\n')}");
+      throw new IncrementalCompilationFailed(_failedUpdates.join('\n\n'));
     }
     for (ElementX element in _elementsToInvalidate) {
       compiler.forgetElement(element);
       element.reuseElement();
     }
     List<Element> elementsToInvalidate = <Element>[];
     for (ElementX element in _elementsToInvalidate) {
       if (!_removedElements.contains(element)) {
         elementsToInvalidate.add(element);
       }
@@ skipping 735 matching lines @@
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder);
     return builder.fields;
   }
 }
 
 // TODO(ahe): Remove this method.
 NO_WARN(x) => x;