Add a first class GrowableObjectArray type in the VM and use it internally in the VM at all spots w…

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 3281 matching lines @@
   // Creates and returns a new array with 'new_length'. Copies all elements from
   // 'source' to the new array. 'new_length' must be greater than or equal to
   // 'source.Length()'. 'source' can be null.
   static RawArray* Grow(const Array& source,
                         int new_length,
                         Heap::Space space = Heap::kNew);
 
   // Returns the preallocated empty array, used to initialize array fields.
   static RawArray* Empty();
 
+  // Make an Array object from a growable Array by truncating it to the

[cshapiro, 2012/03/06 00:56:31]

This is a bit confusing to me.  A growable array contains an array, right?  If
so, I would imagine this returning the underlying array object, right?  What
happens to the growable array?

[siva, 2012/03/06 23:32:33]

Yes it returns the underlying array but truncates it to the appropriate size
(used size).
The data part of the growable array is set to an empty array.

I have reworded the comment, see if it makes more sense now.

[cshapiro, 2012/03/07 00:12:53]

This is much better, however it does not mention that the backing array is
returned.  I would modify the second sentence to say, 

  This is done by first truncating the Growable Object Array's backing array to
the currently used size and then returning the truncated backing array.

[siva, 2012/03/08 00:51:56]

Done.

+  // actual size if needed, the truncated part is marked as an Array object
+  // or a regular Object so that it can be traversed during garbage collection.
+  static RawArray* MakeArray(const GrowableObjectArray& growable_array);
+
  protected:
   static RawArray* New(const Class& cls,
                        intptr_t len,
                        Heap::Space space = Heap::kNew);
 
  private:
   // Make sure that the array size cannot wrap around.
   static const intptr_t kMaxArrayElements = 512 * 1024 * 1024;
 
   RawObject** ObjectAddr(intptr_t index) const {
@@ skipping 16 matching lines @@
 class ImmutableArray : public Array {
  public:
   static RawImmutableArray* New(intptr_t len, Heap::Space space = Heap::kNew);
 
  private:
   HEAP_OBJECT_IMPLEMENTATION(ImmutableArray, Array);
   friend class Class;
 };
 
 
+class GrowableObjectArray : public Instance {

[cshapiro, 2012/03/06 00:56:31]

Class documentation?  (I am not so good about this myself, feel free to bug me
too.)

[siva, 2012/03/06 23:32:33]

I was trying to stick to the comment style used in this file for classes.

On 2012/03/06 00:56:31, cshapiro wrote:

+ public:
+  intptr_t Capacity() const {
+    ASSERT(!IsNull());
+    return raw_ptr()->capacity_;
+  }
+  intptr_t Length() const {
+    ASSERT(!IsNull());
+    return raw_ptr()->length_;
+  }
+
+  RawObject* At(intptr_t index) const {
+    ASSERT(!IsNull());
+    ASSERT(index < Length());
+    const Array& contents = Array::Handle(data());

[hausner, 2012/03/06 00:30:47]

Is there no way around accessing a growable array without allocating a handle on
each access?

[siva, 2012/03/06 23:32:33]

I have modified this code to avoid creation of the handle.

On 2012/03/06 00:30:47, hausner wrote:

[hausner, 2012/03/06 23:53:58]

Nice, thank you.

On 2012/03/06 23:32:33, asiva wrote:

+    return contents.At(index);
+  }
+  void SetAt(intptr_t index, const Object& value) const {
+    ASSERT(!IsNull());
+    ASSERT(index < Length());
+    const Array& contents = Array::Handle(data());
+    contents.SetAt(index, value);
+  }
+
+  void Add(const Object& value, Heap::Space space = Heap::kNew) const;
+  RawObject* RemoveLast() const;
+
+  virtual RawAbstractTypeArguments* GetTypeArguments() const {
+    const Array& contents = Array::Handle(data());
+    return contents.GetTypeArguments();
+  }
+  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
+    const Array& contents = Array::Handle(data());
+    contents.SetTypeArguments(value);
+  }
+
+  virtual bool Equals(const Instance& other) const;
+
+  static intptr_t capacity_offset() {
+    return OFFSET_OF(RawGrowableObjectArray, capacity_);
+  }
+  static intptr_t length_offset() {
+    return OFFSET_OF(RawGrowableObjectArray, length_);
+  }
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawGrowableObjectArray, data_);
+  }
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawGrowableObjectArray));
+  }
+
+  static RawGrowableObjectArray* New(Heap::Space space = Heap::kNew) {
+    return New(kDefaultInitialCapacity, space);
+  }
+  static RawGrowableObjectArray* New(intptr_t capacity,
+                                     Heap::Space space = Heap::kNew);
+
+ private:
+  RawArray* data() const { return raw_ptr()->data_; }
+  void set_length(intptr_t value) const { raw_ptr()->length_ = value; }
+  void set_capacity(intptr_t value) const { raw_ptr()->capacity_ = value; }
+  void set_data(const Array& value) const { raw_ptr()->data_ = value.raw(); }
+
+  static const int kDefaultInitialCapacity = 4;
+
+  HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
+  friend class Class;
+  friend class Array;
+};
+
+
 class ByteArray : public Instance {
  public:
   virtual intptr_t Length() const;
 
   static void Copy(uint8_t* dst,
                    const ByteArray& src,
                    intptr_t src_offset,
                    intptr_t length);
 
   static void Copy(const ByteArray& dst,
@@ skipping 458 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_