Test reflecting on an object that implements Function but has no call method.

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";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
@@ skipping 383 matching lines @@
   MethodMirror _function;
   MethodMirror get function {
     if (_function == null) {
       _function = _computeFunction(reflectee);
     }
     return _function;
   }
 
   InstanceMirror apply(List<Object> positionalArguments,
                        [Map<Symbol, Object> namedArguments]) {
-    // TODO(iposva): When closures get an ordinary call method, this can be
+    // TODO(12602): 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, arguments, names));
+    return reflect(_apply(arguments, names));
   }
 
   Future<InstanceMirror> applyAsync(List positionalArguments,
                                     [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
       return this.apply(_unwrapAsyncPositionals(positionalArguments),
                         _unwrapAsyncNamed(namedArguments));
     });
   }
 
   InstanceMirror findInContext(Symbol name, {ifAbsent: null}) {
     List<String> parts = _n(name).split(".").toList(growable: false);
     if (parts.length > 3) {
       throw new ArgumentError("Invalid symbol: ${name}");
     }
     List tuple = _computeFindInContext(_reflectee, parts);
     if (tuple[0]) {
       return reflect(tuple[1]);
     }
     return ifAbsent == null ? null : ifAbsent();
   }
 
   String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
 
-  static _apply(reflectee, arguments, argumentNames)
+  static _apply(arguments, argumentNames)
       native 'ClosureMirror_apply';
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 
   static _computeFindInContext(reflectee, name)
       native 'ClosureMirror_find_in_context';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
@@ skipping 1064 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }