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

runtime/lib/mirrors.cc

 // 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.
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 1407 matching lines @@
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_computeType, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
   const Type& type = Type::Handle(instance.GetType());
   // The static type of null is specified to be the bottom type, however, the
   // runtime type of null is the Null type, which we correctly return here.
   return type.Canonicalize();
 }
 
 
-DEFINE_NATIVE_ENTRY(ClosureMirror_apply, 3) {
-  GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
-  ASSERT(!closure.IsNull() && closure.IsCallable(NULL, NULL));
-  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(1));
-  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(2));
+DEFINE_NATIVE_ENTRY(ClosureMirror_apply, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(1));
 
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   const Object& result =
       Object::Handle(DartEntry::InvokeClosure(args, args_descriptor));
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
@@ skipping 80 matching lines @@
   return result_tuple.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClosureMirror_function, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
   ASSERT(!closure.IsNull());
 
   Function& function = Function::Handle();
   bool callable = closure.IsCallable(&function, NULL);
-  ASSERT(callable);
-
-  return CreateMethodMirror(function, Instance::null_instance());
+  if (callable) {
+    return CreateMethodMirror(function, Instance::null_instance());
+  }
+  return Instance::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_invoke, 5) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
@@ skipping 429 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
   return field.type();
 }
 
 }  // namespace dart