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

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.
 
 // These values are allowed to be passed directly over the wire.
 bool isSimpleValue(var value) {
   return (value === null || value is num || value is String || value is bool);
 }
 
 Map filterMap(Map old_map, bool filter(key, value)) {
   Map new_map = new Map();
   old_map.forEach((key, value) {
       if (filter(key, value)) {
         new_map[key] = value;
       }
     });
   return new_map;
 }
 
-abstract class _LocalMirrorImpl implements Mirror {
-  // Local mirrors always return the same IsolateMirror.  This field
-  // is more interesting once we implement remote mirrors.
-  IsolateMirror get isolate() { return _Mirrors.currentIsolateMirror(); }
-}
+class _LocalMirrorSystemImpl implements MirrorSystem {
+  _LocalMirrorSystemImpl(this.rootLibrary, this._libraries, this.isolate) {}
 
-class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
-    implements IsolateMirror {
-  _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary, this._libraries) {}
-
-  final String debugName;
   final LibraryMirror rootLibrary;
   final Map<String, LibraryMirror> _libraries;
+  final IsolateMirror isolate;
 
   Map<String, LibraryMirror> libraries() { return _libraries; }
 
+  Mirror mirrorOf(Object reflectee) {
+    return _Mirrors.mirrorOf(reflectee);
+  }
+
   InterfaceMirror _sharedDynamic = null;
 
   InterfaceMirror _dynamicMirror() {
     if (_sharedDynamic === null) {
       _sharedDynamic =
           new _LocalInterfaceMirrorImpl(
               null, 'Dynamic', false, null, null, [], null, const {});
     }
     return _sharedDynamic;
   }
 
   InterfaceMirror _sharedVoid = null;
 
   InterfaceMirror _voidMirror() {
     if (_sharedVoid === null) {
       _sharedVoid =
           new _LocalInterfaceMirrorImpl(
               null, 'void', false, null, null, [], null, const {});
     }
     return _sharedVoid;
   }
 
   String toString() {
+    return "MirrorSystem for isolate '$debugName'";
+  }
+}
+
+abstract class _LocalMirrorImpl implements Mirror {
+  // Local mirrors always return the same MirrorSystem.  This field
+  // is more interesting once we implement remote mirrors.
+  MirrorSystem get mirrors() { return _Mirrors.currentMirrorSystem(); }
+}
+
+class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
+    implements IsolateMirror {
+  _LocalIsolateMirrorImpl(this.debugName) {}
+
+  final String debugName;
+  final bool isCurrent = true;
+
+  String toString() {
     return "IsolateMirror on '$debugName'";
   }
 }
 
 // A VMReference is used to hold a reference to a VM-internal object,
 // which can include things like libraries, classes, etc.
 class VMReference extends NativeFieldWrapperClass1 {
 }
 
 abstract class _LocalVMObjectMirrorImpl extends _LocalMirrorImpl {
@@ skipping 96 matching lines @@
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   _LocalInstanceMirrorImpl(ref,
                            this._class,
                            this.hasSimpleValue,
                            this._simpleValue) : super(ref) {}
 
   var _class;
   InterfaceMirror getClass() {
     if (_class is _LazyInterfaceMirror) {
-      _class = _class.resolve(isolate);
+      _class = _class.resolve(mirrors);
     }
     return _class;
   }
 
   bool hasSimpleValue;
 
   var _simpleValue;
   get simpleValue() {
     if (!hasSimpleValue) {
       throw new MirrorException(
@@ skipping 12 matching lines @@
       }
     } else {
       return "InstanceMirror on instance of '${getClass().simpleName}'";
     }
   }
 }
 
 class _LazyInterfaceMirror {
   _LazyInterfaceMirror(this.libraryName, this.interfaceName) {}
 
-  InterfaceMirror resolve(IsolateMirror isolate) {
+  InterfaceMirror resolve(MirrorSystem mirrors) {
     if (libraryName === null) {
       if (interfaceName == 'Dynamic') {
-        return isolate._dynamicMirror();
+        return mirrors._dynamicMirror();
       } else if (interfaceName == 'void') {
-        return isolate._dynamicMirror();
+        return mirrors._dynamicMirror();
       } else {
         throw new NotImplementedException(
             "Mirror for type '$interfaceName' not implemented");
       }
     }
-    return isolate.libraries()[libraryName].members()[interfaceName];
+    return mirrors.libraries()[libraryName].members()[interfaceName];
   }
 
   final String libraryName;
   final String interfaceName;
 }
 
 class _LocalInterfaceMirrorImpl extends _LocalObjectMirrorImpl
     implements InterfaceMirror {
   _LocalInterfaceMirrorImpl(ref,
                             this.simpleName,
                             this.isClass,
                             this._library,
                             this._superclass,
                             this._superinterfaces,
                             this._defaultFactory,
                             this._members) : super(ref) {}
 
   final String simpleName;
   final bool isClass;
 
   var _library;
   LibraryMirror get library() {
     if (_library is _LazyLibraryMirror) {
-      _library = _library.resolve(isolate);
+      _library = _library.resolve(mirrors);
     }
     return _library;
   }
 
   var _superclass;
   InterfaceMirror superclass() {
     if (_superclass is _LazyInterfaceMirror) {
-      _superclass = _superclass.resolve(isolate);
+      _superclass = _superclass.resolve(mirrors);
     }
     return _superclass;
   }
 
   var _superinterfaces;
   List<InterfaceMirror> superinterfaces() {
     if (_superinterfaces.length > 0 &&
         _superinterfaces[0] is _LazyInterfaceMirror) {
       List<InterfaceMirror> resolved = new List<InterfaceMirror>();
       for (int i = 0; i < _superinterfaces.length; i++) {
-        resolved.add(_superinterfaces[i].resolve(isolate));
+        resolved.add(_superinterfaces[i].resolve(mirrors));
       }
       _superinterfaces = resolved;
     }
     return _superinterfaces;
   }
 
   var _defaultFactory;
   InterfaceMirror defaultFactory() {
     if (_defaultFactory is _LazyInterfaceMirror) {
-      _defaultFactory = _defaultFactory.resolve(isolate);
+      _defaultFactory = _defaultFactory.resolve(mirrors);
     }
     return _defaultFactory;
   }
 
   Map<String, InterfaceMirror> _members;
   Map<String, InterfaceMirror> _methods = null;
   Map<String, InterfaceMirror> _variables = null;
 
   Map<String, Mirror> members() { return _members; }
 
@@ skipping 14 matching lines @@
   }
 
   String toString() {
     return "InterfaceMirror on '$simpleName'";
   }
 }
 
 class _LazyLibraryMirror {
   _LazyLibraryMirror(this.libraryName) {}
 
-  LibraryMirror resolve(IsolateMirror isolate) {
-    return isolate.libraries()[libraryName];
+  LibraryMirror resolve(MirrorSystem mirrors) {
+    return mirrors.libraries()[libraryName];
   }
 
   final String libraryName;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(ref,
                           this.simpleName,
                           this.url,
@@ skipping 49 matching lines @@
                          this.isConstConstructor,
                          this.isGenerativeConstructor,
                          this.isRedirectingConstructor,
                          this.isFactoryConstructor) {}
 
   final String simpleName;
 
   var _owner;
   Mirror get owner() {
     if (_owner is! Mirror) {
-      _owner = _owner.resolve(isolate);
+      _owner = _owner.resolve(mirrors);
     }
     return _owner;
   }
 
   bool get isTopLevel() {
     return owner is LibraryMirror;
   }
 
   final bool isStatic;
 
@@ skipping 21 matching lines @@
   _LocalVariableMirrorImpl(this.simpleName,
                            this._owner,
                            this.isStatic,
                            this.isFinal) {}
 
   final String simpleName;
 
   var _owner;
   Mirror get owner() {
     if (_owner is! Mirror) {
-      _owner = _owner.resolve(isolate);
+      _owner = _owner.resolve(mirrors);
     }
     return _owner;
   }
 
   bool get isTopLevel() {
     return owner is LibraryMirror;
   }
 
   final bool isStatic;
   final bool isFinal;
 
   String toString() {
     return "VariableMirror on '$simpleName'";
   }
 }
 
 class _Mirrors {
   // Does a port refer to our local isolate?
   static bool isLocalPort(SendPort port) native 'Mirrors_isLocalPort';
 
-  static IsolateMirror _currentIsolateMirror = null;
+  static MirrorSystem _currentMirrorSystem = null;
 
-  // Creates a new local IsolateMirror.
-  static IsolateMirror makeLocalIsolateMirror()
-      native 'Mirrors_makeLocalIsolateMirror';
+  // Creates a new local MirrorSystem.
+  static MirrorSystem makeLocalMirrorSystem()
+      native 'Mirrors_makeLocalMirrorSystem';
 
-  // The IsolateMirror for the current isolate.
-  static IsolateMirror currentIsolateMirror() {
-    if (_currentIsolateMirror === null) {
-      _currentIsolateMirror = makeLocalIsolateMirror();
+  // The MirrorSystem for the current isolate.
+  static MirrorSystem currentMirrorSystem() {
+    if (_currentMirrorSystem === null) {
+      _currentMirrorSystem = makeLocalMirrorSystem();
     }
-    return _currentIsolateMirror;
+    return _currentMirrorSystem;
   }
 
-  static Future<IsolateMirror> isolateMirrorOf(SendPort port) {
-    Completer<IsolateMirror> completer = new Completer<IsolateMirror>();
+  static Future<MirrorSystem> mirrorSystemOf(SendPort port) {
+    Completer<MirrorSystem> completer = new Completer<MirrorSystem>();
     if (isLocalPort(port)) {
-      // Make a local isolate mirror.
+      // Make a local mirror system.
       try {
-        completer.complete(currentIsolateMirror());
+        completer.complete(currentMirrorSystem());
       } catch (var exception) {
         completer.completeException(exception);
       }
     } else {
-      // Make a remote isolate mirror.
+      // Make a remote mirror system
       throw new NotImplementedException('Remote mirrors not yet implemented');
     }
     return completer.future;
   }
 
   // Creates a new local InstanceMirror
   static InstanceMirror makeLocalInstanceMirror(Object reflectee)
       native 'Mirrors_makeLocalInstanceMirror';
 
-  // The IsolateMirror for the current isolate.
+  // Creates a new local mirror for some Object.
   static InstanceMirror mirrorOf(Object reflectee) {
     return makeLocalInstanceMirror(reflectee);
   }
 }