Implement reflect() with Dart code, InstanceMirror.type and ClosureMirror.function with internal co…

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);
 }
@@ skipping 250 matching lines @@
             'positional argument $i ($arg) was not a simple value');
       }
   }
 }
 
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
-  _LocalInstanceMirrorImpl(this._type,
-                           reflectee) : super(reflectee) {}
+  _LocalInstanceMirrorImpl(reflectee) : super(reflectee);
 
-  var _type;
+  ClassMirror _type;
   ClassMirror get type {
-    if (_type is! Mirror) {
-      _type = _type.resolve(mirrors);
+    if (_type == null) {
+      // Note it not safe to use reflectee.runtimeType because runtimeType may
+      // be overridden.
+      _type = reflectClass(_computeType(reflectee));
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
   bool hasReflectee = true;
 
   get reflectee => _reflectee;
 
   delegate(Invocation invocation) {
     if (_invokeOnClosure == null) {
       // TODO(ahe): This is a total hack.  We're using the mirror
       // system to access a private field in a different library.  For
       // some reason, that works.  On the other hand, calling a
       // private method does not work.
       
       _LocalInstanceMirrorImpl mirror =
-          _Mirrors.makeLocalInstanceMirror(invocation);
-      _invokeOnClosure =
-          reflectClass(invocation.runtimeType).getField(const Symbol('_invokeOnClosure')).reflectee;
+          reflect(invocation);
+      _invokeOnClosure = reflectClass(invocation.runtimeType)
+          .getField(const Symbol('_invokeOnClosure')).reflectee;
     }
     return _invokeOnClosure(reflectee, invocation);
   }
 
   String toString() => 'InstanceMirror on ${Error.safeToString(_reflectee)}';
 
   _invoke(reflectee, functionName, positionalArguments)
       native 'InstanceMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'InstanceMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'InstanceMirror_invokeSetter';
+
+  static _computeType(reflectee)
+      native 'Object_runtimeType';

[rmacnak, 2013/07/29 18:45:06]

Woo! Reusing a primitive.

 }
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
-  _LocalClosureMirrorImpl(type,
-                          reflectee,
-                          this.function) : super(type, reflectee) {}
+  _LocalClosureMirrorImpl(reflectee) : super(reflectee);
 
-  final MethodMirror function;
+  MethodMirror _function;
+  MethodMirror get function {
+    if (_function == null) {
+      _function = _computeFunction(reflectee);
+    }
+    return _function;
+  }
 
   String get source {
     throw new UnimplementedError(
         'ClosureMirror.source is not implemented');
   }
 
   InstanceMirror apply(List<Object> positionalArguments,
                        [Map<Symbol, Object> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
@@ skipping 14 matching lines @@
 
     try {
       var result = _apply(_reflectee,
                           _unwarpAsyncPositionals(positionalArguments));
       return new Future.value(reflect(result)); 
     } on MirroredError catch(e) {
       return new Future.error(e);
     }
   }
 
-
-
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
+  String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
+
   static _apply(reflectee, positionalArguments)
       native 'ClosureMirror_apply';
 
-  String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
+  static _computeFunction(reflectee)
+      native 'ClosureMirror_function';
 }
 
 class _LazyTypeMirror {
   _LazyTypeMirror(String this.libraryUrl, String typeName)
       : this.typeName = _s(typeName);
 
   TypeMirror resolve(MirrorSystem mirrors) {
     if (libraryUrl == null) {
       if (typeName == const Symbol('dynamic')) {
         return mirrors.dynamicType;
@@ skipping 834 matching lines @@
       } catch (exception) {
         return new Future<MirrorSystem>.error(exception);
       }
     } else {
       // Make a remote mirror system
       throw new UnimplementedError(
           'Remote mirror support is not implemented');
     }
   }
 
-  // Creates a new local InstanceMirror
-  static InstanceMirror makeLocalInstanceMirror(Object reflectee)
-      native 'Mirrors_makeLocalInstanceMirror';
-
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
-    return makeLocalInstanceMirror(reflectee);
+    return reflectee is Function 
+        ? new _LocalClosureMirrorImpl(reflectee)
+        : new _LocalInstanceMirrorImpl(reflectee);
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static Expando<ClassMirror> _classMirrorCache = new Expando("ClassMirror");
   static ClassMirror reflectClass(Type key) {
     var classMirror = _classMirrorCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
       _classMirrorCache[key] = classMirror;
     }
     return classMirror;
   }
 }