Support named and optional positional arguments in reflective invocation.

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.
 
 import "dart:collection";
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
@@ skipping 63 matching lines @@
   var map = new Map<Uri, LibraryMirror>();
   list.forEach((LibraryMirror mirror) => map[mirror.uri] = mirror);
   return map;
 }
 
 List _metadata(reflectee)
   native 'DeclarationMirror_metadata';
 
 // This will verify the argument types, unwrap them, and ensure we have a fixed
 // array.
-List _unwarpAsyncPositionals(wrappedArgs){
+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";
+    } else {
+      throw "positional argument $i ($wrappedArg) was "
+            "not a simple value or InstanceMirror";
     }
   }
   return unwrappedArgs;
 }
+Map _unwarpAsyncNamed(wrappedArgs) {
+  if (wrappedArgs==null) return null;
+  Map unwrappedArgs = new Map();
+  wrappedArgs.forEach((name, wrappedArg){
+    if(_isSimpleValue(wrappedArg)) {
+      unwrappedArgs[name] = wrappedArg;
+    } else if(wrappedArg is InstanceMirror) {
+      unwrappedArgs[name] = wrappedArg._reflectee;
+    } else {
+      throw "named argument ${_n(name)} ($wrappedArg) 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(List<LibraryMirror> libraries, this.isolate)
       : this.libraries = _createLibrariesMap(libraries);
 
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
   TypeMirror _dynamicType = null;
@@ skipping 40 matching lines @@
 
 abstract class _LocalObjectMirrorImpl extends _LocalMirrorImpl
     implements ObjectMirror {
   _LocalObjectMirrorImpl(this._reflectee);
 
   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');
+
+    int numPositionalArguments = positionalArguments.length;
+    int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
+    int numArguments = numPositionalArguments + numNamedArguments;
+    List arguments = new List(numArguments);
+    arguments.setRange(0, numPositionalArguments, positionalArguments);
+    List names = new List(numNamedArguments);
+    int argumentIndex = numPositionalArguments;
+    int nameIndex = 0;
+    if (numNamedArguments > 0) {
+      namedArguments.forEach((name, value) {
+        arguments[argumentIndex++] = value;
+        names[nameIndex++] = _n(name);
+      });
     }
+
     return reflect(this._invoke(_reflectee,
                                 _n(memberName),
-                                positionalArguments.toList(growable:false))); 
+                                arguments,
+                                names));
   }
 
   InstanceMirror getField(Symbol memberName) {
     return reflect(this._invokeGetter(_reflectee,
                                       _n(memberName))); 
   }
 
   InstanceMirror setField(Symbol memberName, Object value) {
     this._invokeSetter(_reflectee,
                        _n(memberName),
                        value);
     return reflect(value);
   }
 
   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 = this._invoke(_reflectee,
-                                _n(memberName),
-                                _unwarpAsyncPositionals(positionalArguments));
-      return new Future.value(reflect(result)); 
-    } catch(e) {
-      return new Future.error(e);
-    }
+    return new Future(() {
+      return this.invoke(memberName,
+                         _unwarpAsyncPositionals(positionalArguments),
+                         _unwarpAsyncNamed(namedArguments));
+    });
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol memberName) {
    try {
       var result = this._invokeGetter(_reflectee,
                                       _n(memberName));
       return new Future.value(reflect(result)); 
     } catch(e) {
       return new Future.error(e);
     }
@@ skipping 87 matching lines @@
     // successive invocations.
     var h = _reflectee is num ? _reflectee.hashCode : _identityHash(_reflectee);
     // Avoid hash collisions with the reflectee. This constant is in Smi range
     // and happens to be the inner padding from RFC 2104.
     return h ^ 0x36363636;
   }
 
   static _identityHash(reflectee)
       native "InstanceMirror_identityHash";
 
-  _invoke(reflectee, functionName, positionalArguments)
+  // Override to include the receiver in the arguments.
+  InstanceMirror invoke(Symbol memberName,
+                        List positionalArguments,
+                        [Map<Symbol, dynamic> namedArguments]) {
+
+    int numPositionalArguments = positionalArguments.length + 1;  // Receiver.
+    int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
+    int numArguments = numPositionalArguments + numNamedArguments;
+    List arguments = new List(numArguments);
+    arguments[0] = _reflectee;  // Receiver.
+    arguments.setRange(1, numPositionalArguments, positionalArguments);
+    List names = new List(numNamedArguments);
+    int argumentIndex = numPositionalArguments;
+    int nameIndex = 0;
+    if (numNamedArguments > 0) {
+      namedArguments.forEach((name, value) {
+        arguments[argumentIndex++] = value;
+        names[nameIndex++] = _n(name);
+      });
+    }
+
+    return reflect(this._invoke(_reflectee,
+                                _n(memberName),
+                                arguments,
+                                names));
+  }
+
+  _invoke(reflectee, functionName, arguments, argumentNames)
       native 'InstanceMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'InstanceMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'InstanceMirror_invokeSetter';
 
   static _computeType(reflectee)
       native 'Object_runtimeType';
@@ skipping 11 matching lines @@
     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(
-          'named argument support is not implemented');
+    // TODO(iposva): When closures get an ordinary call method, this can be
+    // replaced with
+    //   return this.invoke(#call, positionalArguments, namedArguments);
+    // and the native ClosureMirror_apply can be removed.
+    
+    int numPositionalArguments = positionalArguments.length + 1;  // Receiver.
+    int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
+    int numArguments = numPositionalArguments + numNamedArguments;
+    List arguments = new List(numArguments);
+    arguments[0] = _reflectee;  // Receiver.
+    arguments.setRange(1, numPositionalArguments, positionalArguments);
+    List names = new List(numNamedArguments);
+    int argumentIndex = numPositionalArguments;
+    int nameIndex = 0;
+    if (numNamedArguments > 0) {
+      namedArguments.forEach((name, value) {
+        arguments[argumentIndex++] = value;
+        names[nameIndex++] = _n(name);
+      });
     }
+
     // 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)));
+    return reflect(_apply(_reflectee, arguments, names));
   }
 
   Future<InstanceMirror> applyAsync(List positionalArguments,
                                     [Map<Symbol, dynamic> namedArguments]) {
-    if (namedArguments != null) {
-      throw new UnimplementedError(
-          'named argument support is not implemented');
-    }
-
-    try {
-      var result = _apply(_reflectee,
-                          _unwarpAsyncPositionals(positionalArguments));
-      return new Future.value(reflect(result)); 
-    } on MirroredError catch(e) {
-      return new Future.error(e);
-    }
+    return new Future(() {
+      return this.apply(_unwarpAsyncPositionals(positionalArguments),
+                        _unwarpAsyncNamed(namedArguments));
+    });
   }
 
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
   String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
 
-  static _apply(reflectee, positionalArguments)
+  static _apply(reflectee, arguments, argumentNames)
       native 'ClosureMirror_apply';
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
                         this._reflectedType,
@@ skipping 222 matching lines @@
     }
   }
 
   String toString() {
     return "ClassMirror 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');
+    // Native code will add the 1 or 2 implicit arguments depending on whether
+    // we end up invoking a factory or constructor respectively.
+    int numPositionalArguments = positionalArguments.length;
+    int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
+    int numArguments = numPositionalArguments + numNamedArguments;
+    List arguments = new List(numArguments);
+    arguments.setRange(0, numPositionalArguments, positionalArguments);
+    List names = new List(numNamedArguments);
+    int argumentIndex = numPositionalArguments;
+    int nameIndex = 0;
+    if (numNamedArguments > 0) {
+      namedArguments.forEach((name, value) {
+        arguments[argumentIndex++] = value;
+        names[nameIndex++] = _n(name);
+      });
     }
+
     return reflect(_invokeConstructor(_reflectee,
                                       _n(constructorName),
-                                      positionalArguments.toList(growable:false)));
+                                      arguments,
+                                      names));
   }
 
   Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
                                           List positionalArguments,
                                           [Map<Symbol, dynamic> namedArguments]) {
-    if (namedArguments != null) {
-      throw new UnimplementedError(
-          'named argument support is not implemented');
-    }
-
-    try {
-      var result = _invokeConstructor(_reflectee,
-                                      _n(constructorName),
-                                      _unwarpAsyncPositionals(positionalArguments));
-      return new Future.value(reflect(result)); 
-    } catch(e) {
-      return new Future.error(e);
-    }
+    return new Future(() {
+      return this.newInstance(constructorName,
+                              _unwarpAsyncPositionals(positionalArguments),
+                              _unwarpAsyncNamed(namedArguments));
+    });
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return _metadata(_reflectee).map(reflect).toList(growable:false);
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
@@ skipping 17 matching lines @@
 
   static _computeMixin(reflectee)
       native "ClassMirror_mixin";
 
   _computeMembers(reflectee)
       native "ClassMirror_members";
   
   _computeConstructors(reflectee)
       native "ClassMirror_constructors";
 
-  _invoke(reflectee, memberName, positionalArguments)
+  _invoke(reflectee, memberName, arguments, argumentNames)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
-  static _invokeConstructor(reflectee, constructorName, positionalArguments)
+  static _invokeConstructor(reflectee, constructorName, arguments, argumentNames)
       native 'ClassMirror_invokeConstructor';
 
   static _ClassMirror_type_variables(reflectee)
       native "ClassMirror_type_variables";
 
   static _computeTypeArguments(reflectee)
       native "ClassMirror_type_arguments";
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
@@ skipping 269 matching lines @@
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee; 
   }
 
   int get hashCode => simpleName.hashCode;
 
-  _invoke(reflectee, memberName, positionalArguments)
+  _invoke(reflectee, memberName, arguments, argumentNames)
       native 'LibraryMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
       native "LibraryMirror_members";
@@ skipping 327 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }