Deal with deferred loading in the VM mirrors.

sdk/lib/mirrors/mirrors.dart

 // Copyright (c) 2013, 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.
 
 // For the purposes of the mirrors library, we adopt a naming
 // convention with respect to getters and setters.  Specifically, for
 // some variable or field...
 //
 //   var myField;
 //
@@ skipping 37 matching lines @@
  *
  * ## Status: Unstable
  *
  * The dart:mirrors library is unstable and its API might change slightly as a
  * result of user feedback. This library is platform dependent and therefore it
  * has implementations for both dart2js and the Dart VM. Both are under
  * development and may not support all operations yet.
  */
 library dart.mirrors;
 
+import 'dart:async' show Future;
+
 /**
  * A [MirrorSystem] is the main interface used to reflect on a set of
  * associated libraries.
  *
  * At runtime each running isolate has a distinct [MirrorSystem].
  *
  * It is also possible to have a [MirrorSystem] which represents a set
  * of libraries which are not running -- perhaps at compile-time.  In
  * this case, all available reflective functionality would be
  * supported, but runtime functionality (such as invoking a function
  * or inspecting the contents of a variable) would fail dynamically.
  */
 abstract class MirrorSystem {
   /**
    * Returns an immutable map from URIs to mirrors for all
    * libraries known to this mirror system.
    */
   Map<Uri, LibraryMirror> get libraries;

[siva, 2015/04/22 17:28:00]

There is a subtle difference here now, the documentation states 'all libraries
known to the mirror system' but now the implementation only returns a list of
libraries that are loaded.
I am wondering if the API needs to change to allow people to query and get both
lists
- list of libraries known to the mirror system
- list of libraries loaded

[rmacnak, 2015/04/22 18:05:44]

I think some of the vagueness here is to allow for source mirror systems, whose
known libraries would depend on what source the mirror system was constructed
with. Gilad, PTAL at the clarification I added that runtime mirror systems only
include loaded libraries.

 
   /**
    * Returns the unique library named [libraryName] if it exists.
    *
    * If no unique library exists, an error is thrown.
    */
   LibraryMirror findLibrary(Symbol libraryName) {
     return libraries.values.singleWhere(
         (library) => library.simpleName == libraryName);
   }
@@ skipping 519 matching lines @@
   bool get isExport;
 
   /// Returns true iff this dependency is a deferred import. Otherwise returns
   /// false.
   bool get isDeferred;
 
   /// Returns the library mirror of the library that imports or exports the
   /// [targetLibrary].
   LibraryMirror get sourceLibrary;
 
-  /// Returns the library mirror of the library that is imported or exported.
+  /// Returns the library mirror of the library that is imported or exported,
+  /// or null if the library is not loaded.
   LibraryMirror get targetLibrary;
 
   /// Returns the prefix if this is a prefixed import and `null` otherwise.
   Symbol get prefix;
 
   /// Returns the list of show/hide combinators on the import/export
   /// declaration.
   List<CombinatorMirror> get combinators;
 
   /// Returns the source location for this import/export declaration.
   SourceLocation get location;
 
   List<InstanceMirror> get metadata;
+
+  /// Returns a future that completes with a library mirror on the library being
+  /// imported or exported when it is loaded, and initiates a load of that
+  /// library if it is not loaded.
+  Future<LibraryMirror> loadLibrary();
 }
 
 /// A mirror on a show/hide combinator declared on a library dependency.
 abstract class CombinatorMirror implements Mirror {
   /// The list of identifiers on the combinator.
   List<Symbol> get identifiers;
 
   /// Is `true` if this is a 'show' combinator.
   bool get isShow;
 
@@ skipping 622 matching lines @@
    *
    * When used as metadata on an import of "dart:mirrors", this metadata does
    * not apply to the library in which the annotation is used, but instead
    * applies to the other libraries (all libraries if "*" is used).
    */
   final override;
 
   const MirrorsUsed(
       {this.symbols, this.targets, this.metaTargets, this.override});
 }