Support call operator in the vm.

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 1246 matching lines @@
 
 
 // Invoke Implicit Closure function.
 // Arg0: closure object.
 // Arg1: arguments descriptor (originally passed as dart instance invocation).
 // Arg2: arguments array (originally passed to dart instance invocation).
 DEFINE_RUNTIME_ENTRY(InvokeImplicitClosureFunction, 3) {
   ASSERT(arguments.ArgCount() ==
          kInvokeImplicitClosureFunctionRuntimeEntry.argument_count());
   const Instance& closure = Instance::CheckedHandle(arguments.ArgAt(0));
-  const Array& arg_descriptor = Array::CheckedHandle(arguments.ArgAt(1));
+  const Array& args_descriptor = Array::CheckedHandle(arguments.ArgAt(1));
   const Array& func_arguments = Array::CheckedHandle(arguments.ArgAt(2));
   const Function& function = Function::Handle(Closure::function(closure));
   ASSERT(!function.IsNull());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     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());
 
   // 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.
   // 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 = 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.
+  // 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,
+                 args_descriptor,
                  invoke_arguments.data(),
                  context));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver.
 // Arg1: ic-data.
@@ skipping 48 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, including non-closure object.
-// TODO(regis): Rename this entry?
-DEFINE_RUNTIME_ENTRY(ReportObjectNotClosure, 2) {
+// Arg1: arguments descriptor.
+// Arg2: arguments array, including non-closure object.
+DEFINE_RUNTIME_ENTRY(InvokeNonClosure, 3) {
   ASSERT(arguments.ArgCount() ==
-         kReportObjectNotClosureRuntimeEntry.argument_count());
+         kInvokeNonClosureRuntimeEntry.argument_count());
   const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
-  const Array& function_args = Array::CheckedHandle(arguments.ArgAt(1));
+  const Array& args_descriptor = Array::CheckedHandle(arguments.ArgAt(1));
+  const Array& function_args = Array::CheckedHandle(arguments.ArgAt(2));
+
+  // Resolve and invoke "call" method, if existing.
   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(&instance);
-  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(instance.clazz());
   Function& function =
       Function::Handle(instance_class.LookupDynamicFunction(function_name));
   while (function.IsNull()) {
     instance_class = instance_class.SuperClass();
     if (instance_class.IsNull()) break;
     function = instance_class.LookupDynamicFunction(function_name);
   }
   if (!function.IsNull()) {
-    const int total_num_parameters = function.NumParameters();
-    const Array& array = Array::Handle(Array::New(total_num_parameters - 1));
-    // Skip receiver.
-    for (int i = 1; i < total_num_parameters; i++) {
-      array.SetAt(i - 1, String::Handle(function.ParameterNameAt(i)));
+    if (!function.HasCode()) {
+      const Error& error = Error::Handle(Compiler::CompileFunction(function));
+      if (!error.IsNull()) {
+        Exceptions::PropagateError(error);
+      }
     }
-    dart_arguments.Add(&array);
+    const Code& code = Code::Handle(function.CurrentCode());
+    ASSERT(!code.IsNull());
+    const Instructions& instrs = Instructions::Handle(code.instructions());
+    ASSERT(!instrs.IsNull());
+
+    // The non-closure object is passed as implicit first argument (receiver).
+    // It is already included in the arguments array.
+    GrowableArray<const Object*> invoke_arguments(function_args.Length());
+    for (intptr_t i = 0; i < function_args.Length(); i++) {
+      const Object& value = Object::Handle(function_args.At(i));
+      invoke_arguments.Add(&value);
+    }
+
+    // Now call the invoke stub which will invoke the call method.
+    DartEntry::invokestub entrypoint = reinterpret_cast<DartEntry::invokestub>(
+        StubCode::InvokeDartCodeEntryPoint());
+    const Context& context = Context::ZoneHandle(
+        Isolate::Current()->object_store()->empty_context());
+    const Object& result = Object::Handle(
+        entrypoint(instrs.EntryPoint(),
+                   args_descriptor,
+                   invoke_arguments.data(),
+                   context));
+    CheckResultError(result);
+    arguments.SetReturn(result);
+    return;
   }
+  const Object& null_object = Object::Handle();
+  GrowableArray<const Object*> dart_arguments(5);
+  dart_arguments.Add(&instance);
+  dart_arguments.Add(&function_name);
+  dart_arguments.Add(&function_args);
+  dart_arguments.Add(&null_object);
+  // If a function "call" with different arguments exists, it will have been
+  // invoked above, so no need to handle this case here.
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
   ASSERT(arguments.ArgCount() ==
          kStackOverflowRuntimeEntry.argument_count());
   uword stack_pos = reinterpret_cast<uword>(&arguments);
 
@@ skipping 508 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