A round of edits to make mirrors.dart more like our current working

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;
 }
 
 class _LocalMirrorSystemImpl implements MirrorSystem {
-  _LocalMirrorSystemImpl(this.rootLibrary, this._libraries, this.isolate) {}
+  _LocalMirrorSystemImpl(this.libraries, this.isolate) {}
 
-  final LibraryMirror rootLibrary;
-  final Map<String, LibraryMirror> _libraries;
+  final Map<String, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
-  Map<String, LibraryMirror> libraries() { return _libraries; }
+  TypeMirror _dynamicType = null;
 
-  Mirror mirrorOf(Object reflectee) {
-    return _Mirrors.mirrorOf(reflectee);
+  TypeMirror get dynamicType() {
+    if (_dynamicType === null) {
+      _dynamicType =
+          new _LocalClassMirrorImpl(
+              null, 'Dynamic', false, null, null, [], null, const {});
+    }
+    return _dynamicType;
   }
 
-  InterfaceMirror _sharedDynamic = null;
+  TypeMirror _voidType = 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(
+  TypeMirror get voidType() {
+    if (_voidType === null) {
+      _voidType =
+          new _LocalClassMirrorImpl(
               null, 'void', false, null, null, [], null, const {});
     }
-    return _sharedVoid;
+    return _voidType;
   }
 
   String toString() {
     return "MirrorSystem for isolate '$debugName'";
   }
 }
 
 abstract class _LocalMirrorImpl implements Mirror {
+  int hashCode() {
+    throw new NotImplementedException('Mirror.hashCode() not yet implemented');
+  }
+
   // 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) {}
+  _LocalIsolateMirrorImpl(this.debugName, this._rootLibrary) {}
 
   final String debugName;
   final bool isCurrent = true;
 
+  var _rootLibrary;
+  LibraryMirror get rootLibrary() {
+    if (_rootLibrary is _LazyLibraryMirror) {
+      _rootLibrary = _rootLibrary.resolve(mirrors);
+    }
+    return _rootLibrary;
+  }
+
   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 {
 }
 
@@ skipping 125 matching lines @@
         break;
     }
     buf.add(output);
   }
   return buf.toString();
 }
 
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   _LocalInstanceMirrorImpl(ref,
-                           this._class,
+                           this._type,
                            this._reflectee) : super(ref) {}
 
-  var _class;
-  InterfaceMirror getClass() {
-    if (_class is _LazyInterfaceMirror) {
-      _class = _class.resolve(mirrors);
+  var _type;
+  ClassMirror get type() {
+    if (_type is _LazyClassMirror) {
+      _type = _type.resolve(mirrors);
     }
-    return _class;
+    return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
-  bool hasReflectee = true; 
+  bool hasReflectee = true;
 
   var _reflectee;
   get reflectee() => _reflectee;
 
   String toString() {
     if (isSimpleValue(_reflectee)) {
       if (_reflectee is String) {
         return "InstanceMirror on <'${_dartEscape(_reflectee)}'>";
       } else {
         return "InstanceMirror on <$_reflectee>";
       }
     } else {
-      return "InstanceMirror on instance of '${getClass().simpleName}'";
+      return "InstanceMirror on instance of '${type.simpleName}'";
     }
   }
 }
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
   _LocalClosureMirrorImpl(ref,
                           klass,
                           reflectee) : super(ref, klass, reflectee) {}
 
@@ skipping 18 matching lines @@
     try {
       completer.complete(
           _apply(this, positionalArguments));
     } catch (var exception) {
       completer.completeException(exception);
     }
     return completer.future;
   }
 
   Future<ObjectMirror> findInContext(String name) {
-    throw "asYetUnimplemented";
+    throw new NotImplementedException(
+        'ClosureMirror.findInContext() not implemented');
   }
 
   static _apply(ref, positionalArguments)
       native 'LocalClosureMirrorImpl_apply';
 }
 
-class _LazyInterfaceMirror {
-  _LazyInterfaceMirror(this.libraryName, this.interfaceName) {}
+class _LazyClassMirror {
+  _LazyClassMirror(this.libraryName, this.interfaceName) {}
 
-  InterfaceMirror resolve(MirrorSystem mirrors) {
+  ClassMirror resolve(MirrorSystem mirrors) {
     if (libraryName === null) {
       if (interfaceName == 'Dynamic') {
-        return mirrors._dynamicMirror();
+        return mirrors.dynamicType();
       } else if (interfaceName == 'void') {
-        return mirrors._dynamicMirror();
+        return mirrors.voidType();
       } else {
         throw new NotImplementedException(
             "Mirror for type '$interfaceName' not implemented");
       }
     }
-    return mirrors.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) {}
+class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
+    implements ClassMirror {
+  _LocalClassMirrorImpl(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(mirrors);
     }
     return _library;
   }
 
   var _superclass;
-  InterfaceMirror superclass() {
-    if (_superclass is _LazyInterfaceMirror) {
+  ClassMirror get superclass() {
+    if (_superclass is _LazyClassMirror) {
       _superclass = _superclass.resolve(mirrors);
     }
     return _superclass;
   }
 
   var _superinterfaces;
-  List<InterfaceMirror> superinterfaces() {
+  List<ClassMirror> get superinterfaces() {
     if (_superinterfaces.length > 0 &&
-        _superinterfaces[0] is _LazyInterfaceMirror) {
-      List<InterfaceMirror> resolved = new List<InterfaceMirror>();
+        _superinterfaces[0] is _LazyClassMirror) {
+      List<ClassMirror> resolved = new List<ClassMirror>();
       for (int i = 0; i < _superinterfaces.length; i++) {
         resolved.add(_superinterfaces[i].resolve(mirrors));
       }
       _superinterfaces = resolved;
     }
     return _superinterfaces;
   }
 
   var _defaultFactory;
-  InterfaceMirror defaultFactory() {
-    if (_defaultFactory is _LazyInterfaceMirror) {
+  ClassMirror get defaultFactory() {
+    if (_defaultFactory is _LazyClassMirror) {
       _defaultFactory = _defaultFactory.resolve(mirrors);
     }
     return _defaultFactory;
   }
 
-  Map<String, InterfaceMirror> _members;
-  Map<String, InterfaceMirror> _methods = null;
-  Map<String, InterfaceMirror> _variables = null;
+  final Map<String, ClassMirror> members;
 
-  Map<String, Mirror> members() { return _members; }
+  Map<String, ClassMirror> _methods = null;
+  Map<String, ClassMirror> _variables = null;
 
-  Map<String, MethodMirror> methods() {
+  Map<String, MethodMirror> get methods() {
     if (_methods == null) {
-      _methods = filterMap(members(),
+      _methods = filterMap(members,
                            (key, value) => (value is MethodMirror));
     }
     return _methods;
   }
 
-  Map<String, VariableMirror> variables() {
+  Map<String, VariableMirror> get variables() {
     if (_variables == null) {
-      _variables = filterMap(members(),
+      _variables = filterMap(members,
                              (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   String toString() {
-    return "InterfaceMirror on '$simpleName'";
+    return "ClassMirror on '$simpleName'";
   }
 
   Future<InstanceMirror> newInstance(String constructorName,
                                 List positionalArguments,
                                 [Map<String,Dynamic> namedArguments]) {
     if (namedArguments !== null) {
       throw new NotImplementedException('named arguments not implemented');
     }
     // Walk the arguments and make sure they are legal.
     for (int i = 0; i < positionalArguments.length; i++) {
       var arg = positionalArguments[i];
       _LocalObjectMirrorImpl._validateArgument(i, arg);
     }
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
       completer.complete(
           _invokeConstructor(this, constructorName, positionalArguments));
     } catch (var exception) {
       completer.completeException(exception);
     }
     return completer.future;
   }
 
   static _invokeConstructor(ref, constructorName, positionalArguments)
-      native 'LocalInterfaceMirrorImpl_invokeConstructor';
+      native 'LocalClassMirrorImpl_invokeConstructor';
 }
 
 class _LazyLibraryMirror {
   _LazyLibraryMirror(this.libraryName) {}
 
   LibraryMirror resolve(MirrorSystem mirrors) {
-    return mirrors.libraries()[libraryName];
+    return mirrors.libraries[libraryName];
   }
 
   final String libraryName;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(ref,
                           this.simpleName,
                           this.url,
-                          this._members) : super(ref) {}
+                          this.members) : super(ref) {}
 
   final String simpleName;
   final String url;
-  Map<String, InterfaceMirror> _members;
-  Map<String, InterfaceMirror> _classes = null;
-  Map<String, InterfaceMirror> _functions = null;
-  Map<String, InterfaceMirror> _variables = null;
+  final Map<String, ClassMirror> members;
 
-  Map<String, Mirror> members() { return _members; }
+  Map<String, ClassMirror> _classes = null;
+  Map<String, ClassMirror> _functions = null;
+  Map<String, ClassMirror> _variables = null;
 
-  Map<String, InterfaceMirror> classes() {
+  Map<String, ClassMirror> get classes() {
     if (_classes == null) {
-      _classes = filterMap(members(),
-                           (key, value) => (value is InterfaceMirror));
+      _classes = filterMap(members,
+                           (key, value) => (value is ClassMirror));
     }
     return _classes;
   }
 
-  Map<String, MethodMirror> functions() {
+  Map<String, MethodMirror> get functions() {
     if (_functions == null) {
-      _functions = filterMap(members(),
+      _functions = filterMap(members,
                              (key, value) => (value is MethodMirror));
     }
     return _functions;
   }
 
-  Map<String, VariableMirror> variables() {
+  Map<String, VariableMirror> get variables() {
     if (_variables == null) {
-      _variables = filterMap(members(),
+      _variables = filterMap(members,
                              (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   String toString() {
     return "LibraryMirror on '$simpleName'";
   }
 }
 
@@ skipping 46 matching lines @@
   List<ParameterMirror> parameters() => _parameters;
 
   String toString() {
     return "MethodMirror on '$simpleName'";
   }
 }
 
 class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
     implements ParameterMirror {
   // TODO(rmacnak): Fill these mirrors will real information
-  _LocalParameterMirrorImpl(this.isOptional) 
+  _LocalParameterMirrorImpl(this.isOptional)
     : super(null, null, false, false) {}
-  
+
   final bool isOptional;
 
   TypeMirror get type() => null;
   String get defaultValue() => null;
   bool get hasDefaultValue() => null;
 }
 
 class _LocalVariableMirrorImpl extends _LocalMirrorImpl
     implements VariableMirror {
   _LocalVariableMirrorImpl(this.simpleName,
@@ skipping 55 matching lines @@
       throw new NotImplementedException('Remote mirrors not yet implemented');
     }
     return completer.future;
   }
 
   // Creates a new local InstanceMirror
   static InstanceMirror makeLocalInstanceMirror(Object reflectee)
       native 'Mirrors_makeLocalInstanceMirror';
 
   // Creates a new local mirror for some Object.
-  static InstanceMirror mirrorOf(Object reflectee) {
+  static InstanceMirror reflect(Object reflectee) {
     return makeLocalInstanceMirror(reflectee);
   }
 }