Support references to unserialized libraries.

pkg/compiler/lib/src/serialization/serialization.dart

 // Copyright (c) 2015, 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.serialization;
 
 import '../common.dart';
+import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
+import '../library_loader.dart' show LibraryProvider;
 import '../util/enumset.dart';
 
 import 'constant_serialization.dart';
 import 'element_serialization.dart';
 import 'json_serializer.dart';
 import 'keys.dart';
 import 'type_serialization.dart';
 import 'values.dart';
 
 export 'task.dart' show LibraryDeserializer;
@@ skipping 893 matching lines @@
   /// [element]. If not object is stored for [tag], [getDecoder] returns `null`.
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {}
 
   /// Called to deserialize custom data from [decoder].
   dynamic onData(ObjectDecoder decoder) {}
 }
 
 /// Context for parallel deserialization.
 class DeserializationContext {
   final DiagnosticReporter reporter;
+  final Resolution resolution;
+  final LibraryProvider libraryProvider;
   Map<Uri, LibraryElement> _uriMap = <Uri, LibraryElement>{};
   List<Deserializer> deserializers = <Deserializer>[];
   List<DeserializerPlugin> plugins = <DeserializerPlugin>[];
 
-  DeserializationContext(this.reporter);
+  DeserializationContext(this.reporter, this.resolution, this.libraryProvider);
 
   LibraryElement lookupLibrary(Uri uri) {
+    // TODO(johnniwinther): Move this to the library loader by making a
+    // [Deserializer] a [LibraryProvider].
     return _uriMap.putIfAbsent(uri, () {
       Uri foundUri;
       LibraryElement foundLibrary;
       for (Deserializer deserializer in deserializers) {
         LibraryElement library = deserializer.lookupLibrary(uri);
         if (library != null) {
           if (foundLibrary != null) {
             reporter.reportErrorMessage(NO_LOCATION_SPANNABLE,
                 MessageKind.DUPLICATE_SERIALIZED_LIBRARY, {
               'libraryUri': uri,
               'sourceUri1': foundUri,
               'sourceUri2': deserializer.sourceUri
             });
           }
           foundUri = deserializer.sourceUri;
           foundLibrary = library;
         }
       }
       return foundLibrary;
     });
   }
+
+  LibraryElement findLibrary(Uri uri) {
+    LibraryElement library = lookupLibrary(uri);
+    return library ?? libraryProvider.lookupLibrary(uri);
+  }
 }
 
 /// Deserializer for a closed collection of libraries.
 // TODO(johnniwinther): Support per-library deserialization and dependencies
 // between deserialized subcomponent.
 class Deserializer {
   final DeserializationContext context;
   final SerializationDecoder decoder;
   final Uri sourceUri;
   ObjectDecoder _headerObject;
@@ skipping 55 matching lines @@
   /// Returns the deserialized [Element] for [id].
   Element deserializeElement(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getElement(null)');
     Element element = _elementMap[id];
     if (element == null) {
       ObjectDecoder decoder = elements.getObject(id);
       SerializedElementKind elementKind =
           decoder.getEnum(Key.KIND, SerializedElementKind.values);
       if (elementKind == SerializedElementKind.EXTERNAL_LIBRARY) {
         Uri uri = decoder.getUri(Key.URI);
-        element = context.lookupLibrary(uri);
+        element = context.findLibrary(uri);
         if (element == null) {
           throw new StateError("Missing library for $uri.");
         }
       } else if (elementKind == SerializedElementKind.EXTERNAL_LIBRARY_MEMBER) {
         LibraryElement library = decoder.getElement(Key.LIBRARY);
         String name = decoder.getString(Key.NAME);
         bool isGetter = decoder.getBool(Key.GETTER, isOptional: true);
         element = library.find(name);
         if (element == null) {
           throw new StateError("Missing library member for $name in $library.");
         }
         if (isGetter != null) {
           AbstractFieldElement abstractField = element;
           element = isGetter ? abstractField.getter : abstractField.setter;
           if (element == null) {
             throw new StateError(
                 "Missing ${isGetter ? 'getter' : 'setter'} for "
                 "$name in $library.");
           }
         }
       } else if (elementKind == SerializedElementKind.EXTERNAL_CLASS_MEMBER) {
         ClassElement cls = decoder.getElement(Key.CLASS);
+        cls.ensureResolved(context.resolution);
         String name = decoder.getString(Key.NAME);
         bool isGetter = decoder.getBool(Key.GETTER, isOptional: true);
         element = cls.lookupLocalMember(name);
         if (element == null) {
           throw new StateError("Missing class member for $name in $cls.");
         }
         if (isGetter != null) {
           AbstractFieldElement abstractField = element;
           element = isGetter ? abstractField.getter : abstractField.setter;
           if (element == null) {
             throw new StateError(
                 "Missing ${isGetter ? 'getter' : 'setter'} for $name in $cls.");
           }
         }
       } else if (elementKind == SerializedElementKind.EXTERNAL_CONSTRUCTOR) {
         ClassElement cls = decoder.getElement(Key.CLASS);
+        cls.ensureResolved(context.resolution);
         String name = decoder.getString(Key.NAME);
         element = cls.lookupConstructor(name);
         if (element == null) {
           throw new StateError("Missing constructor for $name in $cls.");
         }
       } else {
         element = ElementDeserializer.deserialize(decoder, elementKind);
       }
       _elementMap[id] = element;
 
@@ skipping 40 matching lines @@
 
   /// Returns the value used to store [key] as a property in the encoding an
   /// [ObjectValue].
   ///
   /// Different encodings have different restrictions and capabilities as how
   /// to store a [Key] value. For instance: A JSON encoding needs to convert
   /// [Key] to a [String] to store it in a JSON object; a Dart encoding can
   /// choose to store a [Key] as an [int] or as the [Key] itself.
   getObjectPropertyValue(Key key);
 }