Implement the invoke methods (invoke, getField, setField, newInstance, apply) as internal natives.

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 55 matching lines @@
     var result = new Map<Uri, LibraryMirror>();
     map.forEach((String url, LibraryMirror mirror) {
       result[Uri.parse(url)] = mirror;
     });
     return result;
 }
 
 List<InstanceMirror> _metadata(mirror) 
   native 'Mirrors_metadata';
 
+// This will verify the argument types, unwrap them, and ensure we have a fixed
+// array.
+List _unwarpAsyncPositionals(wrappedArgs){
+  List unwrappedArgs = new List(wrappedArgs.length);
+  for(int i = 0; i < wrappedArgs.length; i++){
+    var wrappedArg = wrappedArgs[i];
+    if(_isSimpleValue(wrappedArg)) {
+      unwrappedArgs[i] = wrappedArg;
+    } else if(wrappedArg is InstanceMirror) {
+      unwrappedArgs[i] = wrappedArg._reflectee;
+    } else { 
+      throw "positional argument $i ($arg) was not a simple value or InstanceMirror";
+    }
+  }
+  return unwrappedArgs;
+}
 
 class _LocalMirrorSystemImpl extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
   _LocalMirrorSystemImpl(Map<String, LibraryMirror> libraries, this.isolate)
       : this.libraries = _createLibrariesMap(libraries),
         _functionTypes = new Map<String, FunctionTypeMirror>();
 
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
@@ skipping 82 matching lines @@
 
   // For now, all VMObjects hold a VMReference.  We could consider
   // storing the Object reference itself here if the object is a Dart
   // language objects (except for objects of type VMReference, of
   // course).
   VMReference _reference;
 }
 
 abstract class _LocalObjectMirrorImpl extends _LocalVMObjectMirrorImpl
     implements ObjectMirror {
-  _LocalObjectMirrorImpl(ref) : super(ref) {}
+  _LocalObjectMirrorImpl(this._reflectee, ref) : super(ref) {}
+
+  final _reflectee; // May be a MirrorReference or an ordinary object
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
-    return _invoke(this, _n(memberName), positionalArguments, false); 
+    return reflect(this._invoke(_reflectee,
+                                _n(memberName),
+                                positionalArguments.toList(growable:false))); 
   }
 
-  InstanceMirror getField(Symbol fieldName) {
-    return _getField(this, _n(fieldName)); 
+  InstanceMirror getField(Symbol memberName) {
+    return reflect(this._invokeGetter(_reflectee,
+                                      _n(memberName))); 
   }
 
-  InstanceMirror setField(Symbol fieldName, Object arg) {
-    return _setField(this, _n(fieldName), arg, false); 
+  InstanceMirror setField(Symbol memberName, Object value) {
+    return reflect(this._invokeSetter(_reflectee,
+                                      _n(memberName),
+                                      value)); 
   }
 
   Future<InstanceMirror> invokeAsync(Symbol memberName,
                                      List positionalArguments,
                                      [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
-    // Walk the arguments and make sure they are legal.
-    for (int i = 0; i < positionalArguments.length; i++) {
-      var arg = positionalArguments[i];
-      _validateArgument(i, arg);
-    }
+
     try {
-      return new Future<InstanceMirror>.value(
-          _invoke(this, _n(memberName), positionalArguments, true));
-    } catch (exception, s) {
-      return new Future<InstanceMirror>.error(exception, s);
+      var result = this._invoke(_reflectee,
+                                _n(memberName),
+                                _unwarpAsyncPositionals(positionalArguments));
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
     }
   }
 
-  Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
-    try {
-      return new Future<InstanceMirror>.value(_getField(this, _n(fieldName)));
-    } catch (exception, s) {
-      return new Future<InstanceMirror>.error(exception, s);
+  Future<InstanceMirror> getFieldAsync(Symbol memberName) {
+   try {
+      var result = this._invokeGetter(_reflectee,
+                                      _n(memberName));
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
     }
   }
 
-  Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object arg) {
-    _validateArgument(0, arg);
+  Future<InstanceMirror> setFieldAsync(Symbol memberName, Object value) {
+    try {
+      var unwrappedValue;
+      if(_isSimpleValue(value)) {
+        unwrappedValue = value;
+      } else if(wrappedArg is InstanceMirror) {
+        unwrappedValue = value._reflectee;
+      } else { 
+        throw "setter argument ($value) must be a simple value or InstanceMirror";
+      }
 
-    try {
-      return new Future<InstanceMirror>.value(
-          _setField(this, _n(fieldName), arg, true));
-    } catch (exception, s) {
-      return new Future<InstanceMirror>.error(exception, s);
+      var result = this._invokeSetter(_reflectee,
+                                      _n(memberName),
+                                      unwrappedValue);
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
     }
   }
 
   static _validateArgument(int i, Object arg)
   {
     if (arg is Mirror) {
         if (arg is! InstanceMirror) {
           throw new MirrorException(
               'positional argument $i ($arg) was not an InstanceMirror');
         }
       } else if (!_isSimpleValue(arg)) {
         throw new MirrorException(
             'positional argument $i ($arg) was not a simple value');
       }
   }
-
-  static _invoke(ref, memberName, positionalArguments, async)
-      native 'LocalObjectMirrorImpl_invoke';
-
-  static _getField(ref, fieldName) // same for sync and async versions
-      native 'LocalObjectMirrorImpl_getField';
-
-  static _setField(ref, fieldName, value, async)
-      native 'LocalObjectMirrorImpl_setField';
 }
 
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
   _LocalInstanceMirrorImpl(ref,
                            this._type,
-                           this._reflectee) : super(ref) {}
+                           reflectee) : super(reflectee, ref) {}
 
   var _type;
   ClassMirror get type {
     if (_type is! Mirror) {
       _type = _type.resolve(mirrors);
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
   bool hasReflectee = true;
 
-  var _reflectee;
   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 =
-          _LocalObjectMirrorImpl._getField(mirror.type, '_invokeOnClosure')
-          .reflectee;
+          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';
 }
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
   _LocalClosureMirrorImpl(ref,
                           type,
                           reflectee,
                           this.function) : super(ref, type, reflectee) {}
 
   final MethodMirror 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(
           'named argument support is not implemented');
     }
-    return _apply(this, positionalArguments, false);
+    // It is tempting to implement this in terms of Function.apply, but then
+    // lazy compilation errors would be fatal.
+    return reflect(_apply(_reflectee,
+                          positionalArguments.toList(growable:false)));
   }
 
-  Future<InstanceMirror> applyAsync(List<Object> positionalArguments,
-                                    [Map<Symbol, Object> namedArguments]) {
+  Future<InstanceMirror> applyAsync(List positionalArguments,
+                                    [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is 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);
-    }
+
     try {
-      return new Future<InstanceMirror>.value(
-          _apply(this, positionalArguments, true));
-    } catch (exception) {
-      return new Future<InstanceMirror>.error(exception);
+      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');
   }
 
-  static _apply(ref, positionalArguments, async)
-      native 'LocalClosureMirrorImpl_apply';
+  static _apply(reflectee, positionalArguments)
+      native 'ClosureMirror_apply';
 
   String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
 }
 
 class _LazyTypeMirror {
   _LazyTypeMirror(String this.libraryUrl, String typeName)
       : this.typeName = _s(typeName);
 
   TypeMirror resolve(MirrorSystem mirrors) {
     if (libraryUrl == null) {
@@ skipping 13 matching lines @@
     }
     return resolved;
   }
 
   final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
-  _LocalClassMirrorImpl(this._reflectee,
+  _LocalClassMirrorImpl(reflectee,
                         ref,
                         String simpleName,
                         this.isClass,
                         this._owner,
                         this._superclass,
                         this._superinterfaces,
                         this._defaultFactory,
                         Map<String, Mirror> members,
                         Map<String, Mirror> constructors,
                         Map<String, Mirror> typeVariables)
       : this._simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
         this.constructors = _convertStringToSymbolMap(constructors),
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
-        super(ref);
-
-  final _MirrorReference _reflectee;
+        super(reflectee, ref);
 
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
-      _simpleName = _s(_ClassMirror_name(_reflectee));
+      _simpleName = _s(_name(_reflectee));
     }
     return _simpleName;
   }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
@@ skipping 113 matching lines @@
     return "$prettyName on '${_n(simpleName)}'";
   }
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
-    return _invokeConstructor(this,
-                              _n(constructorName),
-                              positionalArguments,
-                              false);
+    return reflect(_invokeConstructor(_reflectee,
+                                      _n(constructorName),
+                                      positionalArguments.toList(growable:false)));
   }
 
   Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
                                           List positionalArguments,
                                           [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is 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);
-    }
+
     try {
-      return new Future<InstanceMirror>.value(
-          _invokeConstructor(this,
-                             _n(constructorName),
-                             positionalArguments,
-                             true));
-    } catch (exception) {
-      return new Future<InstanceMirror>.error(exception);
+      var result = _invokeConstructor(_reflectee,
+                                      _n(constructorName),
+                                      _unwarpAsyncPositionals(positionalArguments));
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
     }
   }
 
   // get the metadata objects, convert them into InstanceMirrors using
   // reflect() and then make them into a Dart list
   List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
 
-  static _invokeConstructor(ref, constructorName, positionalArguments, async)
-      native 'LocalClassMirrorImpl_invokeConstructor';
 
-  static String _ClassMirror_name(reflectee)
+  static _name(reflectee)
       native "ClassMirror_name";
+
+  _invoke(reflectee, memberName, positionalArguments)
+      native 'ClassMirror_invoke';
+
+  _invokeGetter(reflectee, getterName)
+      native 'ClassMirror_invokeGetter';
+
+  _invokeSetter(reflectee, setterName, value)
+      native 'ClassMirror_invokeSetter';
+
+  static _invokeConstructor(reflectee, constructorName, positionalArguments)
+      native 'ClassMirror_invokeConstructor';
 }
 
 class _LazyFunctionTypeMirror {
   _LazyFunctionTypeMirror(this.returnType, this.parameters) {}
 
   ClassMirror resolve(MirrorSystem mirrors) {
     return mirrors._lookupFunctionTypeMirror(returnType.resolve(mirrors),
                                              parameters);
   }
 
@@ skipping 147 matching lines @@
 
   LibraryMirror resolve(MirrorSystem mirrors) {
     return mirrors.libraries[Uri.parse(libraryUrl)];
   }
 
   final String libraryUrl;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
-  _LocalLibraryMirrorImpl(ref,
+  _LocalLibraryMirrorImpl(reflectee,
+                          ref,
                           String simpleName,
                           String url,
                           Map<String, Mirror> members)
       : this.simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
         this.uri = Uri.parse(url),
-        super(ref);
+        super(reflectee, ref);
 
   final Symbol simpleName;
 
   // The simple name and the qualified name are the same for a library.
   Symbol get qualifiedName => simpleName;
 
   // Always null for libraries.
   final DeclarationMirror owner = null;
 
   // Always false for libraries.
@@ skipping 54 matching lines @@
                               (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   // get the metadata objects, convert them into InstanceMirrors using
   // reflect() and then make them into a Dart list
   List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
+
+  _invoke(reflectee, memberName, positionalArguments)
+      native 'LibraryMirror_invoke';
+
+  _invokeGetter(reflectee, getterName)
+      native 'LibraryMirror_invokeGetter';
+
+  _invokeSetter(reflectee, setterName, value)
+      native 'LibraryMirror_invokeSetter';
 }
 
 class _LocalMethodMirrorImpl extends _LocalMirrorImpl
     implements MethodMirror {
   _LocalMethodMirrorImpl(this._reflectee,
                          this._owner,
                          this.parameters,
                          this._returnType,
                          this.isStatic,
                          this.isAbstract,
@@ skipping 228 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }