Pass the proper invocation mirror argument to noSuchMethod.

runtime/vm/code_generator.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 "vm/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1166 matching lines @@
   const String& original_function_name = String::Handle(ic_data.target_name());
   const int kNumArguments = 1;
   const int kNumNamedArguments = 0;
   const String& getter_function_name =
       String::Handle(Field::GetterName(original_function_name));
   Function& function = Function::ZoneHandle(
       Resolver::ResolveDynamic(receiver,
                                getter_function_name,
                                kNumArguments,
                                kNumNamedArguments));
-  Code& code = Code::Handle();
+  const Object& null_object = Object::Handle();
   if (function.IsNull()) {
-    arguments.SetReturn(code);
+    arguments.SetReturn(null_object);
     return;  // No getter function found so can't be an implicit closure.
   }
   GrowableArray<const Object*> invoke_arguments(0);
   const Array& kNoArgumentNames = Array::Handle();
   const Object& result =
       Object::Handle(DartEntry::InvokeDynamic(receiver,
                                               function,
                                               invoke_arguments,
                                               kNoArgumentNames));
   if (result.IsError()) {
     if (result.IsUnhandledException()) {
       // If the getter throws an exception, treat as no such method.
-      arguments.SetReturn(code);
+      arguments.SetReturn(null_object);
       return;
     } else {
       Exceptions::PropagateError(Error::Cast(result));
     }
   }
   if (!result.IsSmi()) {
     const Class& cls = Class::Handle(result.clazz());
     ASSERT(!cls.IsNull());
     function = cls.signature_function();
     if (!function.IsNull()) {
       arguments.SetReturn(result);
       return;  // Return closure object.
     }
   }
   // The result instance is not a closure, try to invoke method "call" before
   // throwing a NoSuchMethodError.
 
   // TODO(regis): Factorize the following code.
 
   // TODO(regis): Args should be passed.
   const Array& function_args = Array::Handle();
   const String& function_name = String::Handle(Symbols::Call());
   GrowableArray<const Object*> dart_arguments(5);
 
   // TODO(regis): Resolve and invoke "call" method, if existing.
 
-  const Object& null_object = Object::Handle();
   dart_arguments.Add(&result);
   dart_arguments.Add(&function_name);
   dart_arguments.Add(&function_args);
   dart_arguments.Add(&null_object);
 
   // Report if a function "call" with different arguments has been found.
   {
     Class& instance_class = Class::Handle(result.clazz());
     Function& function =
         Function::Handle(instance_class.LookupDynamicFunction(function_name));
@@ skipping 34 matching lines @@
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   const Context& context = Context::Handle(Closure::context(closure));
   const Code& code = Code::Handle(function.CurrentCode());
   ASSERT(!code.IsNull());
   const Instructions& instrs = Instructions::Handle(code.instructions());
   ASSERT(!instrs.IsNull());
 
-  // Receiver parameter has already been skipped by caller.
   // The closure object is passed as implicit first argument to closure
   // functions, since it may be needed to throw a NoSuchMethodError, in case
   // the wrong number of arguments is passed.
-  GrowableArray<const Object*> invoke_arguments(func_arguments.Length() + 1);
+  // Replace the original receiver in the arguments array by the closure.
+  GrowableArray<const Object*> invoke_arguments(func_arguments.Length());
   invoke_arguments.Add(&closure);
-  for (intptr_t i = 0; i < func_arguments.Length(); i++) {
+  for (intptr_t i = 1; i < func_arguments.Length(); i++) {
     const Object& value = Object::Handle(func_arguments.At(i));
     invoke_arguments.Add(&value);
   }
 
   // Now Call the invoke stub which will invoke the closure.
   DartEntry::invokestub entrypoint = reinterpret_cast<DartEntry::invokestub>(
       StubCode::InvokeDartCodeEntryPoint());
   ASSERT(context.isolate() == Isolate::Current());
   const Object& result = Object::Handle(
       entrypoint(instrs.EntryPoint(),
                  arg_descriptor,
                  invoke_arguments.data(),
                  context));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver.
 // Arg1: ic-data.
 // Arg2: original arguments descriptor array.
 // Arg3: original arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodFunction, 4) {
   ASSERT(arguments.ArgCount() ==
          kInvokeNoSuchMethodFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
-  ASSERT(!Array::CheckedHandle(arguments.ArgAt(2)).IsNull());
+  const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(2));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(3));
   // Allocate an InvocationMirror object.
-  // TODO(regis): Fill in the InvocationMirror object correctly at
-  // this point we do not deal with named arguments and treat them
-  // all as positional.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& invocation_mirror_name = String::Handle(
       Symbols::InvocationMirror());
   Class& invocation_mirror_class = Class::Handle(
       core_lib.LookupClassAllowPrivate(invocation_mirror_name));
   ASSERT(!invocation_mirror_class.IsNull());
   const String& allocation_function_name = String::Handle(
       Symbols::AllocateInvocationMirror());
   const Function& allocation_function = Function::ZoneHandle(
       Resolver::ResolveStaticByName(invocation_mirror_class,
                                     allocation_function_name,
                                     Resolver::kIsQualified));
   ASSERT(!allocation_function.IsNull());
-  GrowableArray<const Object*> allocation_arguments(2);
+  GrowableArray<const Object*> allocation_arguments(3);
   allocation_arguments.Add(&original_function_name);
+  allocation_arguments.Add(&orig_arguments_desc);
   allocation_arguments.Add(&orig_arguments);
   const Array& kNoArgumentNames = Array::Handle();
   const Object& invocation_mirror = Object::Handle(
       DartEntry::InvokeStatic(allocation_function,
                               allocation_arguments,
                               kNoArgumentNames));
 
   const int kNumArguments = 2;
   const int kNumNamedArguments = 0;
   const String& function_name = String::Handle(Symbols::NoSuchMethod());
@@ skipping 11 matching lines @@
                                invoke_arguments,
                                kNoArgumentNames));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
 // A non-closure object was invoked as a closure, so call the "call" method
 // on it.
 // Arg0: non-closure object.
-// Arg1: arguments array.
+// Arg1: arguments array, including non-closure object.
 // TODO(regis): Rename this entry?
 DEFINE_RUNTIME_ENTRY(ReportObjectNotClosure, 2) {
   ASSERT(arguments.ArgCount() ==
          kReportObjectNotClosureRuntimeEntry.argument_count());
   const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const Array& function_args = Array::CheckedHandle(arguments.ArgAt(1));
   const String& function_name = String::Handle(Symbols::Call());
   GrowableArray<const Object*> dart_arguments(5);
 
   // TODO(regis): Resolve and invoke "call" method, if existing.
@@ skipping 543 matching lines @@
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   const Bigint& big_left = Bigint::Handle(left);
   const Bigint& big_right = Bigint::Handle(right);
   return BigintOperations::Compare(big_left, big_right);
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart