Deal with deferred loading in the VM mirrors.

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 import "dart:collection" show UnmodifiableListView, UnmodifiableMapView;
+import "dart:async" show Future;
 
+var dirty = false;
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new UnmodifiableMapView({});
 
 class _InternalMirrorError {
   final String _msg;
   const _InternalMirrorError(String this._msg);
   String toString() => _msg;
 }
 
 String _n(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
@@ skipping 192 matching lines @@
 
   Function operator [](String key) {
     var index = scanFor(key);
     var assoc = table[index];
     if (null == assoc) return null;
     assoc.usedSinceGrowth = true;
     return assoc.value;
   }
 }
 
+class _LocalMirrorSystem extends MirrorSystem {
+  final TypeMirror dynamicType = new _SpecialTypeMirror('dynamic');
+  final TypeMirror voidType = new _SpecialTypeMirror('void');
 
-class _LocalMirrorSystem extends MirrorSystem {
-  final Map<Uri, LibraryMirror> libraries;
-  final IsolateMirror isolate;
+  var _libraries;
+  Map<Uri, LibraryMirror> get libraries {
+    if ((_libraries == null) || dirty) {
+      _libraries = new Map<Uri, LibraryMirror>.fromIterable(
+          _computeLibraries(), key: (e) => e.uri);
+    }
+    return _libraries;
+  }
+  static _computeLibraries() native "MirrorSystem_libraries";
 
-  _LocalMirrorSystem(List<LibraryMirror> libraries, this.isolate)
-      : this.libraries = new Map<Uri, LibraryMirror>.fromIterable(
-            libraries, key: (e) => e.uri);
-
-  TypeMirror _dynamicType = null;
-  TypeMirror get dynamicType {
-    if (_dynamicType == null) {
-      _dynamicType = new _SpecialTypeMirror('dynamic');
+  var _isolate;
+  IsolateMirror get isolate {
+    if (_isolate == null) {
+      _isolate = _computeIsolate();
     }
-    return _dynamicType;
+    return _isolate;
   }
-
-  TypeMirror _voidType = null;
-  TypeMirror get voidType {
-    if (_voidType == null) {
-      _voidType = new _SpecialTypeMirror('void');
-    }
-    return _voidType;
-  }
+  static _computeIsolate() native "MirrorSystem_isolate";
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
 
 class _SourceLocation implements SourceLocation {
   _SourceLocation(uriString, this.line, this.column)
       : this.sourceUri = Uri.parse(uriString);
 
   // Line and column positions are 1-origin, or 0 if unknown.
   final int line;
@@ skipping 1033 matching lines @@
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
       native "LibraryMirror_members";
 }
 
 class _LocalLibraryDependencyMirror
     extends _LocalMirror implements LibraryDependencyMirror {
   final LibraryMirror sourceLibrary;
-  final LibraryMirror targetLibrary;
+  var _targetMirrorOrPrefix;
   final List<CombinatorMirror> combinators;
   final Symbol prefix;
   final bool isImport;
   final bool isDeferred;
   final List<InstanceMirror> metadata;
 
   _LocalLibraryDependencyMirror(this.sourceLibrary,
-                                this.targetLibrary,
+                                this._targetMirrorOrPrefix,
                                 this.combinators,
                                 prefixString,
                                 this.isImport,
                                 this.isDeferred,
                                 unwrappedMetadata)
       : prefix = _s(prefixString),
         metadata = new UnmodifiableListView(unwrappedMetadata.map(reflect));
 
   bool get isExport => !isImport;
+
+  LibraryMirror get targetLibrary {
+    if (_targetMirrorOrPrefix is _LocalLibraryMirror) {
+      return _targetMirrorOrPrefix;
+    }
+    var mirrorOrNull = _tryUpgradePrefix(_targetMirrorOrPrefix);
+    if (mirrorOrNull != null) {
+      _targetMirrorOrPrefix = mirrorOrNull;
+    }
+    return mirrorOrNull;
+  }
+
+  Future<LibraryMirror> loadLibrary() {
+    if (_targetMirrorOrPrefix is _LocalLibraryMirror) {
+      return new Future.value(_targetMirrorOrPrefix);
+    }
+    var savedPrefix = _targetMirrorOrPrefix;
+    return savedPrefix.loadLibrary().then((_) {
+      return _tryUpgradePrefix(savedPrefix);
+    });
+  }
+
+  static _tryUpgradePrefix(libraryPrefix) native "LibraryMirror_fromPrefix";
 }
 
 class _LocalCombinatorMirror extends _LocalMirror implements CombinatorMirror {
   final List<Symbol> identifiers;
   final bool isShow;
 
   _LocalCombinatorMirror(identifierString, this.isShow)
       : this.identifiers = [_s(identifierString)];
 
   bool get isHide => !isShow;
@@ skipping 248 matching lines @@
   }
 
   List<TypeVariableMirror> get typeVariables => emptyList;
   List<TypeMirror> get typeArguments => emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   Symbol get qualifiedName => simpleName;
 
-  // TODO(11955): Remove once dynamicType and voidType are canonical objects in
-  // the object store.
   bool operator ==(other) {
     if (other is! _SpecialTypeMirror) {
       return false;
     }
     return this.simpleName == other.simpleName;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "TypeMirror on '${_n(simpleName)}'";
 
   bool isSubtypeOf(TypeMirror other) {
     return simpleName == #dynamic || other is _SpecialTypeMirror;
   }
 
   bool isAssignableTo(TypeMirror other) {
     return simpleName == #dynamic || other is _SpecialTypeMirror;
   }
 }
 
 class _Mirrors {
-  static MirrorSystem _currentMirrorSystem = null;
-
-  // Creates a new local MirrorSystem.
-  static MirrorSystem makeLocalMirrorSystem()
-      native 'Mirrors_makeLocalMirrorSystem';
-
-  // The MirrorSystem for the current isolate.
+  static MirrorSystem _currentMirrorSystem = new _LocalMirrorSystem();
   static MirrorSystem currentMirrorSystem() {
-    if (_currentMirrorSystem == null) {
-      _currentMirrorSystem = makeLocalMirrorSystem();
-    }
     return _currentMirrorSystem;
   }
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return reflectee is Function
         ? new _LocalClosureMirror(reflectee)
         : new _LocalInstanceMirror(reflectee);
   }
 
@@ skipping 22 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }