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 _unwarpAsyncArguments(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 311 matching lines @@
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
         super(ref);
 
   final _MirrorReference _reflectee;
 
   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 106 matching lines @@
   ClassMirror get genericDeclaration {
     throw new UnimplementedError(
         'ClassMirror.originalDeclaration is not implemented');
   }
 
   String toString() {
     String prettyName = isClass ? 'ClassMirror' : 'TypeMirror';
     return "$prettyName on '${_n(simpleName)}'";
   }
 
+  InstanceMirror invoke(Symbol memberName,
+                        List positionalArguments,
+                        [Map<Symbol, dynamic> namedArguments]) {
+    if (namedArguments != null) {
+      throw new UnimplementedError(
+          'named argument support is not implemented');
+    }
+    return reflect(_invoke(_reflectee,
+                           _n(memberName),
+                           positionalArguments.toList(growable:false))); 
+  }
+
+  Future<InstanceMirror> invokeAsync(Symbol memberName,
+                                     List positionalArguments,
+                                     [Map<Symbol, dynamic> namedArguments]) {
+    if (namedArguments != null) {
+      throw new UnimplementedError(
+          'named argument support is not implemented');
+    }
+
+    try {
+      var result = _invoke(_reflectee,
+                           _n(memberName),
+                           _unwarpAsyncArguments(positionalArguments));
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
+    }
+  }
+
+  InstanceMirror getField(Symbol memberName) {
+    return reflect(_invokeGetter(_reflectee,
+                                 _n(memberName))); 
+  }
+
+  Future<InstanceMirror> getFieldAsync(Symbol memberName) {
+   try {
+      var result = _invokeGetter(_reflectee,
+                                 _n(memberName));
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
+    }
+  }
+
+  InstanceMirror setField(Symbol memberName, Object value) {
+    return reflect(_invokeSetter(_reflectee,
+                                 _n(memberName),
+                                 value)); 
+  }
+
+  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";
+      }
+
+      var result = _invokeSetter(_reflectee,
+                                 _n(memberName),
+                                 unwrappedValue);
+      return new Future.value(reflect(result)); 
+    } on MirroredError catch(e) {
+      return new Future.error(e);
+    }
+  }
+
   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),
+                                      _unwarpAsyncArguments(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";
+
+  static _invoke(reflectee, constructorName, positionalArguments)
+      native 'ClassMirror_invoke';
+
+  static _invokeGetter(reflectee, getterName)
+      native 'ClassMirror_invokeGetter';
+
+  static _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 467 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }