Some small changes to make the vm dart:mirrors somewhat closer to the

lib/mirrors/mirrors.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("mirrors");
 
 // The dart:mirrors library provides reflective access for Dart program.
 //
 // 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;
 //
 // ...the getter is named 'myField' and the setter is named
 // 'myField='.  This allows us to assign unique names to getters and
 // setters for the purposes of member lookup.
 //
 // TODO(turnidge): Finish implementing this api.
 
 /**
- * Returns an [IsolateMirror] for the current isolate.
+ * 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.
  */
-IsolateMirror currentIsolateMirror() {
-  return _Mirrors.currentIsolateMirror();
+interface MirrorSystem {
+  /**
+   * A mirror on the root library of the mirror system.
+   */
+  final LibraryMirror rootLibrary;
+
+  /**
+   * An immutable map from from library names to mirrors for all
+   * libraries known to this mirror system.
+  */
+  Map<String, LibraryMirror> libraries();
+
+  /**
+   * A mirror on the isolate associated with this [MirrorSystem].
+   * This may be null if this mirror system is not running.
+   */
+  IsolateMirror isolate;
+
+  /**
+   * Returns an [InstanceMirror] for some Dart language object.
+   *
+   * This only works if this mirror system is associated with the
+   * current running isolate.
+   */
+  InstanceMirror mirrorOf(Object reflectee);
 }
 
 /**
- * Returns an [InstanceMirror] for some Dart language object.
+ * Returns a [MirrorSystem] for the current isolate.
  */
-InstanceMirror mirrorOf(Object reflectee) {
-  return _Mirrors.mirrorOf(reflectee);
+MirrorSystem currentMirrorSystem() {
+  return _Mirrors.currentMirrorSystem();
 }
 
 /**
- * Creates an [IsolateMirror] on the isolate which is listening on
+ * Creates a [MirrorSystem] for the isolate which is listening on
  * the [SendPort].
  */
-Future<IsolateMirror> isolateMirrorOf(SendPort port) {
-  return _Mirrors.isolateMirrorOf(port);
+Future<MirrorSystem> mirrorSystemOf(SendPort port) {
+  return _Mirrors.mirrorSystemOf(port);
 }
 
 /**
  * A [Mirror] reflects some Dart language entity.
  *
- * Every [Mirror] originates from some [IsolateMirror].
+ * Every [Mirror] originates from some [MirrorSystem].
  */
 interface Mirror {
   /**
-   * A mirror on the originating isolate for this [Mirror].
+   * The originating [MirrorSystem] for this mirror.
    */
-  final IsolateMirror isolate;
+  final MirrorSystem mirrors;
 }
 
 /**
  * An [IsolateMirror] reflects an isolate.
  */
 interface IsolateMirror extends Mirror {
   /**
    * A unique name used to refer to an isolate in debugging messages.
    */
   final String debugName;
 
   /**
-   * A mirror on the root library of the reflectee.
+   * Does this mirror reflect the currently running isolate?
    */
-  final LibraryMirror rootLibrary;
-
-  /**
-   * An immutable map from from library names to mirrors for all
-   * libraries loaded in the reflectee.
-  */
-  Map<String, LibraryMirror> libraries();
+  final bool isCurrent;
 }
 
 
 /**
  * An [ObjectMirror] is a common superinterface of [InstanceMirror],
  * [InterfaceMirror], and [LibraryMirror] that represents their shared
  * functionality.
  *
  * For the purposes of the mirrors library, these types are all
  * object-like, in that they support method invocation and field
@@ skipping 37 matching lines @@
    *  - the value is of type [bool]
    *  - the value is of type [String]
    *
    * If you access [simpleValue] when [hasSimpleValue] is false an
    * exception is thrown.
    */
   final simpleValue;
 }
 
 /**
+ * A [TypeMirror] reflects a Dart language class, interface, typedef
+ * or type variable.
+ */
+interface TypeMirror extends Mirror {
+  /**
+   * The library in which this interface is declared.
+   */
+  final LibraryMirror library;
+}
+
+/**
  * An [InterfaceMirror] reflects a Dart language class or interface.
  */
-interface InterfaceMirror extends ObjectMirror {
+interface InterfaceMirror extends TypeMirror, ObjectMirror {
   /**
    * The name of this interface.
    */
   final String simpleName;
 
   /**
-   * The library in which this interface is declared.
-   */
-  final LibraryMirror library;
-
-  /**
    * Does this mirror represent a class?
    */
   final bool isClass;
 
   /**
    * Returns a mirror on the superclass on the reflectee.
    *
    * For interfaces, the superclass is Object.
    */
   InterfaceMirror superclass();
@@ skipping 280 matching lines @@
 
 /**
  * A [MirrorException] is used to indicate errors within the mirrors
  * framework.
  */
 class MirrorException implements Exception {
   const MirrorException(String this._message);
   String toString() => "MirrorException: '$_message'";
   final String _message;
 }