Support serialization of the compiler backbone.

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 'dart2jslib.dart' show
     Compiler,
@@ skipping 464 matching lines @@
    */
   Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
     return compiler.withCurrentElement(library, () {
       return compiler.readScript(part, readableUri).
           then((Script sourceScript) {
             if (sourceScript == null) return;
 
-            CompilationUnitElement unit =
+            CompilationUnitElementX unit =
                 new CompilationUnitElementX(sourceScript, library);
             compiler.withCurrentElement(unit, () {
               compiler.scanner.scan(unit);
               if (unit.partTag == null && !sourceScript.isSynthesized) {
                 compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
               }
             });
           });
     });
   }
@@ skipping 20 matching lines @@
     }
     return createLibrary(handler, library, resolvedUri, tag.uri)
         .then((LibraryElement loadedLibrary) {
           if (loadedLibrary == null) return;
           compiler.withCurrentElement(library, () {
             handler.registerDependency(library, tag, loadedLibrary);
           });
         });
   }
 
+  Future<LibraryElement> readLibrary(LibraryDependencyHandler handler,
+                                     Uri resolvedUri,
+                                     LibraryElement library) async {
+    compiler.onLibraryCreated(library);
+    libraryCanonicalUriMap[resolvedUri] = library;
+    await compiler.onLibraryScanned(library, handler);
+    for (LibraryTag tag in library.tags) {
+      LibraryElement dependency = library.getLibraryFromTag(tag);
+      await createLibrary(handler, library, dependency.canonicalUri);
+    }
+    return library;
+  }
+
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
   Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
                                        LibraryElement importingLibrary,
                                        Uri resolvedUri,
                                        [Node node]) {
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
     LibraryElement library = libraryCanonicalUriMap[resolvedUri];
     if (library != null) {
       return new Future.value(library);
     }
+    library = compiler.serialization.readLibrary(resolvedUri);

[floitsch, 2015/06/26 20:54:04]

This is confusing:
we have two readLibrary, but they don't do the same thing.
It seems like the second "readLibrary" doesn't have a good name.

[Johnni Winther, 2015/07/03 12:13:44]

Done.

+    if (library != null) {
+      return readLibrary(handler, resolvedUri, library);
+    }
     var readScript = compiler.readScript;
     if (readableUri == null) {
       readableUri = resolvedUri;
       readScript = compiler.synthesizeScript;
     }
     return compiler.withCurrentElement(importingLibrary, () {
       return readScript(node, readableUri).then((Script script) {
         if (script == null) return null;
         LibraryElement element =
             createLibrarySync(handler, script, resolvedUri);
@@ skipping 642 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }