Incremental compilation of libraries with multiple parts.

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,
+    CompilationUnitElement,
     Element,
     FunctionElement,
     LibraryElement,
     STATE_NOT_STARTED,
     ScopeContainerElement;
 
 import 'package:compiler/src/scanner/scannerlib.dart' show
     EOF_TOKEN,
     Listener,
     NodeListener,
@@ skipping 50 matching lines @@
     ElementX,
     FieldElementX,
     LibraryElementX;
 
 import 'package:compiler/src/universe/universe.dart' show
     Selector;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
+import 'package:compiler/src/library_loader.dart' show
+    TagState;
+
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 import 'dart2js_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalCompiler;
 
 typedef void Logger(message);
 
@@ skipping 72 matching lines @@
 
   final Set<ElementX> _removedElements = new Set<ElementX>();
 
   final Set<ClassElementX> _classesWithSchemaChanges =
       new Set<ClassElementX>();
 
   final IncrementalCompilerContext _context;
 
   final Map<Uri, Future> _sources = <Uri, Future>{};
 
+  /// Cached tokens of entry compilation units.
+  final Map<LibraryElementX, Token> _entryUnitTokens =
+      <LibraryElementX, Token>{};
+
+  /// Cached source files for entry compilation units.
+  final Map<LibraryElementX, SourceFile> _entrySourceFiles =
+      <LibraryElementX, SourceFile>{};
+
   bool _hasComputedNeeds = false;
 
   bool _hasCapturedCompilerState = false;
 
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.logTime,
       this.logVerbose,
       this._context) {
@@ skipping 32 matching lines @@
       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;
       }
+
+      bool isChanged = false;
+      List<Future<Script>> futureScripts = <Future<Script>>[];
+
       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);
-          });
+          isChanged = true;
+          futureScripts.add(_updatedScript(unit.script, library));
+        } else {
+          futureScripts.add(new Future.value(unit.script));
         }
       }
 
-      logTime("Reusing $library, source didn't change.");
-      // Source code of [library] wasn't changed.
-      return true;
+      if (!isChanged) {
+        logTime("Reusing $library, source didn't change.");
+        return true;
+      }
+
+      return Future.wait(futureScripts).then(
+          (List<Script> scripts) => canReuseLibrary(library, scripts));
+    }).whenComplete(() => _cleanUp(library));
+  }
+
+  void _cleanUp(LibraryElementX library) {
+    _entryUnitTokens.remove(library);
+    _entrySourceFiles.remove(library);
+  }
+
+  Future<Script> _updatedScript(Script before, LibraryElementX library) {
+    if (before == library.entryCompilationUnit.script &&
+        _entrySourceFiles.containsKey(library)) {
+      return new Future.value(before.copyWithFile(_entrySourceFiles[library]));
+    }
+
+    return _readUri(before.resourceUri).then((bytes) {
+      String filename = before.file.filename;
+      SourceFile sourceFile = bytes is String
+          ? new StringSourceFile(filename, bytes)
+          : new CachingUtf8BytesSourceFile(filename, bytes);
+      return before.copyWithFile(sourceFile);
     });
   }
 
   Future<bool> _haveTagsChanged(LibraryElement library) {
-    Uri uri = library.entryCompilationUnit.script.resourceUri;
-    if (!_context._uriHasUpdate(uri)) {
+    Script before = library.entryCompilationUnit.script;
+    if (!_context._uriHasUpdate(before.resourceUri)) {
       // The entry compilation unit hasn't been updated. So the tags aren't
       // changed.
       return new Future<bool>.value(false);
     }
 
-    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();
+    return _updatedScript(before, library).then((Script script) {
+      _entrySourceFiles[library] = script.file;
+      Token token = new Scanner(_entrySourceFiles[library]).tokenize();
+      _entryUnitTokens[library] = token;
       // 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) ||
@@ skipping 23 matching lines @@
     if (compiler == null) return;
 
     if (_hasCapturedCompilerState) return;
     _context._captureState(compiler);
     _hasCapturedCompilerState = true;
   }
 
   /// Returns true if [library] can be reused.
   ///
   /// This methods also computes the [updates] (patches) needed to have
-  /// [library] reflect the modifications in [bytes].
-  bool canReuseLibrary(LibraryElement library, bytes) {
+  /// [library] reflect the modifications in [scripts].
+  bool canReuseLibrary(LibraryElement library, List<Script> scripts) {
     logTime('Attempting to reuse ${library}.');
-    String newSource = bytes is String ? bytes : UTF8.decode(bytes);
-    logTime('Decoded UTF8');
 
-    Uri uri = library.entryCompilationUnit.script.resourceUri;
-    Script sourceScript = new Script(
-        uri, uri, new StringSourceFile('$uri', newSource));
-    var dartPrivacyIsBroken = compiler.libraryLoader;
-    LibraryElement newLibrary = dartPrivacyIsBroken.createLibrarySync(
-        null, sourceScript, uri);
+    Uri entryUri = library.entryCompilationUnit.script.resourceUri;
+    Script entryScript =
+        scripts.singleWhere((Script script) => script.resourceUri == entryUri);
+    LibraryElement newLibrary =
+        new LibraryElementX(entryScript, library.canonicalUri);
+    if (_entryUnitTokens.containsKey(library)) {
+      compiler.dietParser.dietParse(
+          newLibrary.entryCompilationUnit, _entryUnitTokens[library]);
+    } else {
+      compiler.scanner.scanLibrary(newLibrary);
+    }
+
+    TagState tagState = new TagState();
+    for (LibraryTag tag in newLibrary.tags) {
+      if (tag.isImport) {
+        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler);
+      } else if (tag.isExport) {
+        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler);
+      } else if (tag.isLibraryName) {
+        tagState.checkTag(TagState.LIBRARY, tag, compiler);
+        if (newLibrary.libraryTag == null) {
+          // Use the first if there are multiple (which is reported as an
+          // error in [TagState.checkTag]).
+          newLibrary.libraryTag = tag;
+        }
+      } else if (tag.isPart) {
+        tagState.checkTag(TagState.PART, tag, compiler);
+      }
+    }
+
+    // TODO(ahe): Process tags using TagState, not
+    // LibraryLoaderTask.processLibraryTags.
+    Link<CompilationUnitElement> units = library.compilationUnits;
+    for (Script script in scripts) {
+      CompilationUnitElementX unit = units.head;
+      units = units.tail;
+      if (script != entryScript) {
+        // TODO(ahe): Copied from library_loader.
+        CompilationUnitElement newUnit =
+            new CompilationUnitElementX(script, newLibrary);
+        compiler.withCurrentElement(newUnit, () {
+          compiler.scanner.scan(newUnit);
+          if (unit.partTag == null) {
+            compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
+          }
+        });
+      }
+    }
+
     logTime('New library synthesized.');
     return canReuseScopeContainerElement(library, newLibrary);
   }
 
   bool cannotReuse(context, String message) {
     _failedUpdates.add(new FailedUpdate(context, message));
     logVerbose(message);
     return false;
   }
 
@@ skipping 1064 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;