- Add synchronous mirror API. Resurrects invoke, apply, newInstance,

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 144 matching lines @@
   // 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) {}
 
+  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); 
+  }
+
+  InstanceMirror getField(Symbol fieldName) {
+    return _getField(this, _n(fieldName)); 
+  }
+
+  InstanceMirror setField(Symbol fieldName, Object arg) {
+    return _setField(this, _n(fieldName), arg, false); 
+  }
+
   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);
     }
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
       completer.complete(
-          _invoke(this, _n(memberName), positionalArguments));
+          _invoke(this, _n(memberName), positionalArguments), true);
     } catch (exception, s) {
       completer.completeError(exception, s);
     }
     return completer.future;
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
       completer.complete(_getField(this, _n(fieldName)));
     } catch (exception, s) {
       completer.completeError(exception, s);
     }
     return completer.future;
   }
 
   Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object arg) {
     _validateArgument(0, arg);
 
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
-      completer.complete(_setField(this, _n(fieldName), arg));
+      completer.complete(_setField(this, _n(fieldName), arg, true));
     } catch (exception, s) {
       completer.completeError(exception, s);
     }
     return completer.future;
   }
 
   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)
+  static _invoke(ref, memberName, positionalArguments, async)
       native 'LocalObjectMirrorImpl_invoke';
 
-  static _getField(ref, fieldName)
+  static _getField(ref, fieldName) // same for sync and async versions
       native 'LocalObjectMirrorImpl_getField';
 
-  static _setField(ref, fieldName, value)
+  static _setField(ref, fieldName, value, async)
       native 'LocalObjectMirrorImpl_setField';
 }
 
 // Prints a string as it might appear in dart program text.
 // TODO(turnidge): Consider truncating.
 String _dartEscape(String str) {
   bool isNice(int code) => (code >= 32 && code <= 126);
 
   StringBuffer buf = new StringBuffer();
   for (int i = 0; i < str.length; i++) {
@@ skipping 79 matching lines @@
                           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);
+  }
+
   Future<InstanceMirror> applyAsync(List<Object> positionalArguments,
                                     [Map<Symbol, Object> 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);
     }
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
       completer.complete(
-          _apply(this, positionalArguments));
+          _apply(this, positionalArguments, true));
     } catch (exception) {
       completer.completeError(exception);
     }
     return completer.future;
   }
 
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
-  static _apply(ref, positionalArguments)
+  static _apply(ref, positionalArguments, async)
       native 'LocalClosureMirrorImpl_apply';
 }
 
 class _LazyTypeMirror {
   _LazyTypeMirror(String libraryName, String typeName)
       : this.libraryName = _s(libraryName),
         this.typeName = _s(typeName);
 
   TypeMirror resolve(MirrorSystem mirrors) {
     if (libraryName == null) {
@@ skipping 150 matching lines @@
         'ClassMirror.isOriginalDeclaration is not implemented');
   }
 
   ClassMirror get genericDeclaration {
     throw new UnimplementedError(
         'ClassMirror.originalDeclaration is not implemented');
   }
 
   String toString() => "ClassMirror on '$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);
+  }
+
   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);
     }
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
       completer.complete(
-          _invokeConstructor(this, _n(constructorName), positionalArguments));
+          _invokeConstructor(this,
+                             _n(constructorName),
+                             positionalArguments,
+                             true));
     } catch (exception) {
       completer.completeError(exception);
     }
     return completer.future;
   }
 
-  static _invokeConstructor(ref, constructorName, positionalArguments)
+  static _invokeConstructor(ref, constructorName, positionalArguments, async)
       native 'LocalClassMirrorImpl_invokeConstructor';
 }
 
 class _LazyFunctionTypeMirror {
   _LazyFunctionTypeMirror(this.returnType, this.parameters) {}
 
   ClassMirror resolve(MirrorSystem mirrors) {
     return mirrors._lookupFunctionTypeMirror(returnType.resolve(mirrors),
                                              parameters);
   }
@@ skipping 443 matching lines @@
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return makeLocalInstanceMirror(reflectee);
   }
 
   static ClassMirror reflectClass(Type reflectee) {
     throw new UnimplementedError('reflectClass is not implemented');
   }
 }