Use OrderedHashTables as the backing store of JSSet and JSMap

src/objects.h

Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index ff9f45721f1498a181015755bb9759b670f53aa1..d95b00cc996417a3f31c9e1df36501704d6b763a 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -1076,7 +1076,10 @@ class MaybeObject BASE_EMBEDDED {
   V(Cell)                                      \
   V(PropertyCell)                              \
   V(ObjectHashTable)                           \
-  V(WeakHashTable)
+  V(WeakHashTable)                             \
+  V(OrderedHashTable)                          \

[Michael Starzinger, 2014/04/07 12:37:31]

Since the OrderedHashTable is just the abstract super-class of the
OrderedHashSet and OrderedHashMap, we really shouldn't have three instance types
here.

I am fine with sharing one map for both OrderedHashSet and OrderedHashMap as the
CL does right now. But then we should only add one new instance type for now and
drop the unused ones.

[adamk, 2014/04/07 23:50:02]

Okay, I switched back (only downside was that I have to keep my own custom
cast() methods).

+  V(OrderedHashSet)                            \
+  V(OrderedHashMap)
 
 
 #define ERROR_MESSAGES_LIST(V) \
@@ -3751,7 +3754,6 @@ class HashTable: public FixedArray {
   void Rehash(Key key);
 
  protected:
-  friend class ObjectHashSet;
   friend class ObjectHashTable;
 
   // Find the entry at which to insert element with the given key that
@@ -4182,7 +4184,6 @@ class UnseededNumberDictionary
 };
 
 
-template <int entrysize>
 class ObjectHashTableShape : public BaseShape<Object*> {
  public:
   static inline bool IsMatch(Object* key, Object* other);
@@ -4191,45 +4192,13 @@ class ObjectHashTableShape : public BaseShape<Object*> {
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       Object* key);
   static const int kPrefixSize = 0;
-  static const int kEntrySize = entrysize;
-};
-
-
-// ObjectHashSet holds keys that are arbitrary objects by using the identity
-// hash of the key for hashing purposes.
-class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> {
- public:
-  static inline ObjectHashSet* cast(Object* obj) {
-    ASSERT(obj->IsHashTable());
-    return reinterpret_cast<ObjectHashSet*>(obj);
-  }
-
-  // Looks up whether the given key is part of this hash set.
-  bool Contains(Object* key);
-
-  static Handle<ObjectHashSet> EnsureCapacity(
-      Handle<ObjectHashSet> table,
-      int n,
-      Handle<Object> key,
-      PretenureFlag pretenure = NOT_TENURED);
-
-  // Attempt to shrink hash table after removal of key.
-  static Handle<ObjectHashSet> Shrink(Handle<ObjectHashSet> table,
-                                      Handle<Object> key);
-
-  // Adds the given key to this hash set.
-  static Handle<ObjectHashSet> Add(Handle<ObjectHashSet> table,
-                                   Handle<Object> key);
-
-  // Removes the given key from this hash set.
-  static Handle<ObjectHashSet> Remove(Handle<ObjectHashSet> table,
-                                      Handle<Object> key);
+  static const int kEntrySize = 2;
 };
 
 
 // ObjectHashTable maps keys that are arbitrary objects to object values by
 // using the identity hash of the key for hashing purposes.
-class ObjectHashTable: public HashTable<ObjectHashTableShape<2>, Object*> {
+class ObjectHashTable: public HashTable<ObjectHashTableShape, Object*> {
  public:
   static inline ObjectHashTable* cast(Object* obj) {
     ASSERT(obj->IsHashTable());
@@ -4301,7 +4270,7 @@ class OrderedHashTable: public FixedArray {
       Isolate* isolate, int capacity, PretenureFlag pretenure = NOT_TENURED);
 
   // Returns an OrderedHashTable (possibly |table|) with enough space
-  // to add at least one new element, or returns a Failure if a GC occurs.
+  // to add at least one new element.
   static Handle<Derived> EnsureGrowable(Handle<Derived> table);
 
   // Returns an OrderedHashTable (possibly |table|) that's shrunken
@@ -4391,10 +4360,7 @@ class OrderedHashTable: public FixedArray {
 
 class OrderedHashSet: public OrderedHashTable<OrderedHashSet, 1> {
  public:
-  static OrderedHashSet* cast(Object* obj) {
-    ASSERT(obj->IsFixedArray());  // TODO(adamk): Make a map for this
-    return reinterpret_cast<OrderedHashSet*>(obj);
-  }
+  static inline OrderedHashSet* cast(Object* obj);
 
   bool Contains(Object* key);
   static Handle<OrderedHashSet> Add(
@@ -4406,10 +4372,7 @@ class OrderedHashSet: public OrderedHashTable<OrderedHashSet, 1> {
 
 class OrderedHashMap: public OrderedHashTable<OrderedHashMap, 2> {
  public:
-  static OrderedHashMap* cast(Object* obj) {
-    ASSERT(obj->IsFixedArray());  // TODO(adamk): Make a map for this
-    return reinterpret_cast<OrderedHashMap*>(obj);
-  }
+  static inline OrderedHashMap* cast(Object* obj);
 
   Object* Lookup(Object* key);
   static Handle<OrderedHashMap> Put(