Patches to support Dart VM patch files in dart2js.

pkg/compiler/lib/src/library_loader.dart

 // Copyright (c) 2012, 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.library_loader;
 
 import 'dart:async';
 
 import 'common.dart';
 import 'common/names.dart' show Uris;
@@ skipping 168 matching lines @@
 /// Handle for creating synthesized/patch libraries during library loading.
 abstract class LibraryLoader {
   /// This method must be called when a new synthesized/patch library has been
   /// created to ensure that [library] will part of library dependency graph
   /// used for computing import/export scopes.
   void registerNewLibrary(LibraryElement library);
 
   /// This method must be called when a new synthesized/patch library has been
   /// scanned in order to process the library tags in [library] and thus handle
   /// imports/exports/parts in the synthesized/patch library.
-  Future processLibraryTags(LibraryElement library);
+  Future processLibraryTags(
+      LibraryElement library, {bool isPatchLibrary: false});
 }
 
 /**
  * [CombinatorFilter] is a succinct representation of a list of combinators from
  * a library dependency tag.
  */
 class CombinatorFilter {
   const CombinatorFilter();
 
   /**
@@ skipping 228 matching lines @@
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
    */
   Future processLibraryTags(
-      LibraryDependencyHandler handler, LibraryElementX library) {
+      LibraryDependencyHandler handler, LibraryElementX library,
+      {bool isPatchLibrary: false}) {
     TagState tagState = new TagState();
 
     bool importsDartCore = false;
     LinkBuilder<LibraryDependencyElementX> libraryDependencies =
         new LinkBuilder<LibraryDependencyElementX>();
     Uri base = library.entryCompilationUnit.script.readableUri;
 
     return Future.forEach(library.tags, (LibraryTag tag) {
       return reporter.withCurrentElement(library, () {
         Uri computeUri(LibraryDependency node) {
@@ skipping 53 matching lines @@
           if (library.libraryTag == null) {
             // Use the first if there are multiple (which is reported as an
             // error in [TagState.checkTag]).
             library.libraryTag = tag;
           }
         } else if (tag.isPart) {
           Part part = tag;
           StringNode uri = part.uri;
           Uri resolvedUri = base.resolve(uri.dartString.slowToString());
           tagState.checkTag(TagState.PART, part, reporter);
-          return scanPart(part, resolvedUri, library);
+          return scanPart(
+              part, resolvedUri, library, isPatchLibrary: isPatchLibrary);
         } else {
           reporter.internalError(tag, "Unhandled library tag.");
         }
       });
     }).then((_) {
       return listener.onLibraryScanned(library, handler);
     }).then((_) {
       return reporter.withCurrentElement(library, () {
         checkDuplicatedLibraryName(library);
 
@@ skipping 56 matching lines @@
               MessageKind.DUPLICATED_LIBRARY_NAME, {'libraryName': name});
         });
       }
     }
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
-  Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
+  Future scanPart(
+      Part part, Uri resolvedUri, LibraryElement library,
+      {bool isPatchLibrary: false}) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = uriTranslator.translate(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
     return reporter.withCurrentElement(library, () {
       return scriptLoader.readScript(readableUri, part).then((Script script) {
         if (script == null) return;
-        createUnitSync(script, library);
+        createUnitSync(script, library, isPatchLibrary: isPatchLibrary);
       });
     });
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope. If the tag does not contain a valid URI, then its dependency
    * is not registered in [handler].
    */
@@ skipping 109 matching lines @@
     return reporter.withCurrentElement(element, () {
       if (handler != null) {
         handler.registerNewLibrary(element);
         libraryCanonicalUriMap[resolvedUri] = element;
       }
       scanner.scanLibrary(element);
       return element;
     });
   }
 
-  CompilationUnitElement createUnitSync(Script script, LibraryElement library) {
+  CompilationUnitElement createUnitSync(
+      Script script, LibraryElement library, {bool isPatchLibrary: false}) {
     CompilationUnitElementX unit = new CompilationUnitElementX(script, library);
     reporter.withCurrentElement(unit, () {
-      scanner.scanUnit(unit);
-      if (unit.partTag == null && !script.isSynthesized) {
-        reporter.reportErrorMessage(unit, MessageKind.MISSING_PART_OF_TAG);
+      if (isPatchLibrary) {
+        compiler.patchParser.scanUnit(unit);
+      } else {
+        scanner.scanUnit(unit);
+        if (unit.partTag == null && !script.isSynthesized) {
+          reporter.reportErrorMessage(unit, MessageKind.MISSING_PART_OF_TAG);
+        }
       }
     });
     return unit;
   }
 }
 
 /// A state machine for checking script tags come in the correct order.
 class TagState {
   /// Initial state.
   static const int NO_TAG_SEEN = 0;
@@ skipping 549 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 
-  Future processLibraryTags(LibraryElement library) {
-    return task.processLibraryTags(this, library);
+  Future processLibraryTags(
+      LibraryElement library, {bool isPatchLibrary: false}) {
+    return task.processLibraryTags(
+        this, library, isPatchLibrary: isPatchLibrary);
   }
 }
 
 /// Information on the bulk of newly loaded libraries through a call to
 /// [LibraryLoader.loadLibrary].
 abstract class LoadedLibraries {
   /// The uri passed to [LibraryLoader.loadLibrary].
   Uri get rootUri;
 
   /// Returns `true` if a library with canonical [uri] was loaded in this bulk.
@@ skipping 56 matching lines @@
     void computeSuffixes(LibraryElement library, Link<Uri> prefix) {
       if (aborted) return;
 
       Uri canonicalUri = library.canonicalUri;
       prefix = prefix.prepend(canonicalUri);
       if (suffixChainMap.containsKey(library)) return;
       suffixChainMap[library] = const <Link<Uri>>[];
       List<Link<Uri>> suffixes = [];
       if (targetUri != canonicalUri) {
         LibraryDependencyNode node = nodeMap[library];
+        if (node == null) return;
 
         /// Process the import (or export) of [importedLibrary].
         void processLibrary(LibraryElement importedLibrary) {
           bool suffixesArePrecomputed =
               suffixChainMap.containsKey(importedLibrary);
 
           if (!suffixesArePrecomputed) {
             computeSuffixes(importedLibrary, prefix);
             if (aborted) return;
           }
@@ skipping 114 matching lines @@
   /// Called after a request to load a library. The [results] will include all
   /// transitive libraries loaded as a result of the initial request.
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }