Introduce a class encapsulating arguments descriptor arrays.

runtime/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"
 
 namespace dart {
 
 // Forward declarations.
 class Array;
 class Closure;
 class Context;
 class Function;
 class Instance;
 class Integer;
 class Library;
 class Object;
+class RawArray;
 class RawInstance;
 class RawObject;
 class String;
 
+// An arguments descriptor array consists of the total argument count; the
+// positional argument count; a sequence of (name, position) pairs, sorted
+// by name, for each named optional argument; and a terminating null to
+// simplify iterating in generated code.
+class ArgumentsDescriptor : public ValueObject {
+ public:
+  explicit ArgumentsDescriptor(RawObject* array);

[srdjan, 2012/12/05 18:27:52]

NEVER pass a raw object as argument, only handles.

[regis, 2012/12/05 18:39:24]

You should never pass a RawObject pointer as parameter.

[Kevin Millikin (Google), 2012/12/05 19:11:23]

Well, that's obviously a qualified NEVER, because I count over a dozen distinct
places that we do that (isolate, object_set, snapshot, symbols, Handle static
functions, etc).

I reasoned as follows: this is just a wrapped handle.  If Array::Handle is
allowed to take a RawArray*, then this should as well.

[srdjan, 2012/12/05 19:34:17]

Yes, it is a general rule, it should be deviated from only for very special
reasons.

+
+  // Accessors.
+  intptr_t Count() const;

[regis, 2012/12/05 18:39:24]

Currently, we name integer variables holding a count of things "num_things" and
their accessors "NumThings()". I would keep this convention for consistency.

[Kevin Millikin (Google), 2012/12/05 19:11:23]

I know bit it drives me nuts.  It directly contradicts the style guide to avoid
abbreviations.  "count" is only one (or fewer) character more than "num" because
you can turn the noun from plural to singular, and it is readable as an English
word unlike "num".

Count reads way better than Num (ArgumentsDescriptor::Num()?) and I'm not sure
this new class needs to be consistent with anything.

[srdjan, 2012/12/05 19:34:17]

The most important thing is to be consistent, pick one and stay with it. Let's
pick one, and fix other cases.

+  intptr_t PositionalCount() const;
+  intptr_t NamedCount() const { return Count() - PositionalCount(); }
+  RawObject* NameAt(intptr_t index) const;

[srdjan, 2012/12/05 18:27:52]

Maybe this should be RawString*?

[Kevin Millikin (Google), 2012/12/05 19:11:23]

It's too annoying, because we don't have a simple way to cast RawObject* to
RawString*.  It seemed more pleasant here to let the caller handle casting the
handle.

[srdjan, 2012/12/05 19:34:17]

It is a weird API. We know we can return only RawString.

+
+  // Generated code support.
+  static intptr_t count_offset();
+  static intptr_t positional_count_offset();
+  static intptr_t first_named_entry_offset();
+  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);
+
+ private:
+  // Absolute indexes into the array.
+  enum {
+    kCountIndex,
+    kPositionalCountIndex,
+    kFirstNamedEntryIndex,
+  };
+
+  // Relative indexes into each named argument entry.
+  enum {
+    kNameOffset,
+    kPositionOffset,
+    kNamedEntrySize,
+  };
+
+  static intptr_t LengthFor(intptr_t count) {
+    // Add 1 for the terminating null.
+    return kFirstNamedEntryIndex + (kNamedEntrySize * count) + 1;
+  }
+
+  const Array& array_;

[srdjan, 2012/12/05 18:27:52]

Add DISALLOW_YADA_YADA

+};
+
+
 // 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 Context& context);
 
@@ skipping 11 matching lines @@
       const Function& function,
       const GrowableArray<const Object*>& arguments,
       const Array& optional_arguments_names);
 
   // Invoke the specified closure object.
   // On success, returns a RawInstance.  On failure, a RawError.
   static RawObject* InvokeClosure(
       const Instance& closure,
       const GrowableArray<const Object*>& arguments,
       const Array& optional_arguments_names);
-
-  // Allocate and return an arguments descriptor.
-  // Let 'num_names' be the length of 'optional_arguments_names'.
-  // Treat the first 'num_arguments - num_names' arguments as positional and
-  // treat the following 'num_names' arguments as named optional arguments.
-  static const Array& ArgumentsDescriptor(
-      int num_arguments,
-      const Array& optional_arguments_names);
 };
 
 
 // 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_