Changed the API in DartEntry for invoking dart code from C++ to make it more compatible with the re…

vm/dart_entry.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_DART_ENTRY_H_
 #define VM_DART_ENTRY_H_
 
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 
@@ skipping 35 matching lines @@
   static intptr_t name_offset() { return kNameOffset * kWordSize; }
   static intptr_t position_offset() { return kPositionOffset * kWordSize; }
   static intptr_t named_entry_size() { return kNamedEntrySize * kWordSize; }
 
   // Allocate and return an arguments descriptor.  The first
   // (count - optional_arguments_names.Length()) arguments are
   // positional and the remaining ones are named optional arguments.
   static RawArray* New(intptr_t count,
                        const Array& optional_arguments_names);
 
+  // Allocate and return an arguments descriptor that has no optional
+  // arguments. All arguments are positional.
+  static RawArray* New(intptr_t count);
+
  private:
   // Absolute indexes into the array.
   enum {
     kCountIndex,
     kPositionalCountIndex,
     kFirstNamedEntryIndex,
   };
 
   // Relative indexes into each named argument entry.
   enum {
@@ skipping 13 matching lines @@
 };
 
 
 // DartEntry abstracts functionality needed to resolve dart functions
 // and invoke them from C++.
 class DartEntry : public AllStatic {
  public:
   // On success, returns a RawInstance.  On failure, a RawError.
   typedef RawObject* (*invokestub)(uword entry_point,
                                    const Array& arguments_descriptor,
-                                   const Object** arguments,
+                                   const Array& arguments,
                                    const Context& context);
 
   // Invokes the specified instance function on the receiver.
   // On success, returns a RawInstance.  On failure, a RawError.
-  static RawObject* InvokeDynamic(
-      const Instance& receiver,
+  // This is used when there are no named arguments in the call.
+  static RawObject* InvokeDynamic(const Function& function,
+                                  const Array& arguments);
+
+  // Invokes the specified instance function on the receiver.
+  // On success, returns a RawInstance.  On failure, a RawError.
+  static RawObject* InvokeDynamicWithNamedArgs(

[regis, 2012/12/18 16:21:28]

It's great not to have to pass the arguments descriptor in the shorter form
above. The name of this longer form implies that we pass named arguments, but we
do not have to. I wonder if we could overload the name ("InvokeDynamic" as well)
and pass the arguments_descriptor last. We use overloading for New, for example.

[siva, 2012/12/18 21:18:13]

Agree, I have changed the name to just InvokeDynamic.

On 2012/12/18 16:21:28, regis wrote:

       const Function& function,
-      const GrowableArray<const Object*>& arguments,
-      const Array& optional_arguments_names);
+      const Array& arguments_descriptor,
+      const Array& arguments);
 
   // Invoke the specified static function.
   // On success, returns a RawInstance.  On failure, a RawError.
-  static RawObject* InvokeStatic(
+  // This is used when there are no named arguments in the call.
+  static RawObject* InvokeStatic(const Function& function,
+                                 const Array& arguments);
+
+  // Invoke the specified static function.
+  // On success, returns a RawInstance.  On failure, a RawError.
+  static RawObject* InvokeStaticWithNamedArgs(

[regis, 2012/12/18 16:21:28]

Overload "InvokeStatic" and swap arguments?

[siva, 2012/12/18 21:18:13]

Done.

       const Function& function,
-      const GrowableArray<const Object*>& arguments,
-      const Array& optional_arguments_names);
+      const Array& arguments_descriptor,
+      const Array& arguments);
 
   // Invoke the specified closure object.
   // On success, returns a RawInstance.  On failure, a RawError.
-  static RawObject* InvokeClosure(
+  // This is used when there are no named arguments in the call.
+  static RawObject* InvokeClosure(const Instance& closure,

[regis, 2012/12/18 16:21:28]

The closure is the first argument and does not need to be passed in. But I can
simplify this later.

[siva, 2012/12/18 21:18:13]

I thought about that too, but somehow felt it is more
readable this way it is more readable and consistent
with the way the InvokeDynamic and InvokeStatic are
structured (i.e the first parameter signifies what is being
invoked). We can discuss about this some more. I am going to
leave it as is for now.

On 2012/12/18 16:21:28, regis wrote:

[regis, 2012/12/18 21:34:46]

Sure. It is definitely more readable to repeat the closure.

+                                  const Array& arguments);
+
+  // Invoke the specified closure object.
+  // On success, returns a RawInstance.  On failure, a RawError.
+  static RawObject* InvokeClosureWithNamedArgs(

[regis, 2012/12/18 16:21:28]

Overload "InvokeClosure" and swap arguments?

[siva, 2012/12/18 21:18:13]

Swapped the arguments but retained the closure parameter per
my comment above.

On 2012/12/18 16:21:28, regis wrote:

       const Instance& closure,
-      const GrowableArray<const Object*>& arguments,
-      const Array& optional_arguments_names);
+      const Array& arguments_descriptor,
+      const Array& arguments);
 };
 
 
 // Utility functions to call from VM into Dart bootstrap libraries.
 // Each may return an exception object.
 class DartLibraryCalls : public AllStatic {
  public:
   // On success, returns a RawInstance.  On failure, a RawError.
   static RawObject* ExceptionCreate(
       const Library& library,
@@ skipping 23 matching lines @@
 
   // Gets the _id field of a SendPort/ReceivePort.
   //
   // Returns the value of _id on success, a RawError on failure.
   static RawObject* PortGetId(const Instance& port);
 };
 
 }  // namespace dart
 
 #endif  // VM_DART_ENTRY_H_