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

runtime/lib/mirrors_impl.dart

Index: runtime/lib/mirrors_impl.dart
===================================================================
--- runtime/lib/mirrors_impl.dart	(revision 24826)
+++ runtime/lib/mirrors_impl.dart	(working copy)
@@ -73,6 +73,22 @@
 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.
@@ -404,7 +420,7 @@
     // 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;
   }
@@ -531,6 +547,77 @@
     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]) {
@@ -538,10 +625,9 @@
       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,
@@ -551,19 +637,14 @@
       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);
     }
   }
 
@@ -571,11 +652,21 @@
   // 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 {