Refactor how elements are redefined by the runtime.

src/elements.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 // ElementsKinds.
 class ElementsAccessor {
  public:
   ElementsAccessor() { }
   virtual ~ElementsAccessor() { }
   virtual MaybeObject* Get(FixedArrayBase* backing_store,
                            uint32_t key,
                            JSObject* holder,
                            Object* receiver) = 0;
 
+  virtual MaybeObject* Set(JSObject* holder,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes = ABSENT) = 0;
+
   virtual MaybeObject* Delete(JSObject* holder,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) = 0;
 
   virtual MaybeObject* AddElementsToFixedArray(FixedArrayBase* from,
                                                FixedArray* to,
                                                JSObject* holder,
                                                Object* receiver) = 0;
 
   // Returns a shared ElementsAccessor for the specified ElementsKind.
@@ skipping 20 matching lines @@
   // elements.  Indexes refer to elements in terms of their location in the
   // underlying storage's backing store representation, and are between 0
   // GetCapacity.  Keys refer to elements in terms of the value that would be
   // specific in JavaScript to access the element. In most implementations, keys
   // are equivalent to indexes, and GetKeyForIndex returns the same value it is
   // passed. In the NumberDictionary ElementsAccessor, GetKeyForIndex maps the
   // index to a key using the KeyAt method on the NumberDictionary.
   virtual uint32_t GetKeyForIndex(FixedArrayBase* backing_store,
                                   uint32_t index) = 0;
 
+  // Internal element setter which does not update the objects backing store
+  // containing the elements, but returns the new backing store.  The caller
+  // is responsible for updating the object reference to the backing store.

[danno, 2011/10/24 21:09:02]

The separation of responsibility seems clear in the comment, but it would
suggest to me that Set is exactly that caller that updates the object reference
to the backing store and not much more. It would be great if each template
subclass only had to implement a single specialized CRTP method.

+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) = 0;
+
  private:
   static ElementsAccessor** elements_accessors_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementsAccessor);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ELEMENTS_H_