Remove calls to JSObject::SetLocalPropertyIgnoreAttributesTrampoline within objects.cc

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index f7c89175da75c2fb7916015a34adf9954b565eef..9c0d43b1eb54949bff3e6d1de40d26d1f35acb6f 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -1028,6 +1028,14 @@ Object* Object::GetPrototype(Isolate* isolate) {
 }
 
 
+Handle<Object> Object::GetHash(Handle<Object> object, Isolate* isolate,
+                               CreationFlag flag) {
+  CALL_HEAP_FUNCTION(isolate,
+                     object->GetHash(flag),
+                     Object);
+}
+
+
 MaybeObject* Object::GetHash(CreationFlag flag) {
   // The object is either a number, a name, an odd-ball,
   // a real JS object, or a Harmony proxy.
@@ -15704,61 +15712,79 @@ MaybeObject* NameDictionary::TransformPropertiesToFastFor(
 }
 
 
-bool ObjectHashSet::Contains(Object* key) {
-  ASSERT(IsKey(key));
+Handle<ObjectHashSet> ObjectHashSet::EnsureSetCapacity(
+    Handle<ObjectHashSet> table,
+    int n,
+    Handle<Object> key,
+    PretenureFlag pretenure) {
+  CALL_HEAP_FUNCTION(table->GetIsolate(),
+                     table->EnsureCapacity(n, *key, pretenure),
+                     ObjectHashSet);
+}
 
-  // If the object does not have an identity hash, it was never used as a key.
-  { MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
-    if (maybe_hash->ToObjectUnchecked()->IsUndefined()) return false;
-  }
-  return (FindEntry(key) != kNotFound);
+
+Handle<ObjectHashSet> ObjectHashSet::ShrinkSet(Handle<ObjectHashSet> table,
+                                               Handle<Object> key) {
+  CALL_HEAP_FUNCTION(table->GetIsolate(),
+                     table->Shrink(*key),
+                     ObjectHashSet);
 }
 
 
-MaybeObject* ObjectHashSet::Add(Object* key) {
-  ASSERT(IsKey(key));
+bool ObjectHashSet::Contains(Handle<ObjectHashSet> table, Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
+
+  if (Object::GetHash(key, table->GetIsolate(), OMIT_CREATION)->IsUndefined())
+    return false;
+
+  return (table->FindEntry(*key) != kNotFound);
+}
+
+
+Handle<ObjectHashSet> ObjectHashSet::Add(Handle<ObjectHashSet> table,
+                                         Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
+
+  Isolate* isolate = table->GetIsolate();
 
   // Make sure the key object has an identity hash code.
-  int hash;
-  { MaybeObject* maybe_hash = key->GetHash(ALLOW_CREATION);
-    if (maybe_hash->IsFailure()) return maybe_hash;
-    ASSERT(key->GetHash(OMIT_CREATION) == maybe_hash);
-    hash = Smi::cast(maybe_hash->ToObjectUnchecked())->value();
-  }
-  int entry = FindEntry(key);
+  Handle<Object> object_hash = Object::GetHash(key, isolate, ALLOW_CREATION);
+  ASSERT(*Object::GetHash(key, isolate, OMIT_CREATION) == *object_hash);
+
+  int hash = Smi::cast(*object_hash)->value();
+  int entry = table->FindEntry(*key);
 
   // Check whether key is already present.
-  if (entry != kNotFound) return this;
+  if (entry != kNotFound) return table;
 
   // Check whether the hash set should be extended and add entry.
-  Object* obj;
-  { MaybeObject* maybe_obj = EnsureCapacity(1, key);
-    if (!maybe_obj->ToObject(&obj)) return maybe_obj;
-  }
-  ObjectHashSet* table = ObjectHashSet::cast(obj);
-  entry = table->FindInsertionEntry(hash);
-  table->set(EntryToIndex(entry), key);
-  table->ElementAdded();
-  return table;
+  Handle<ObjectHashSet> new_table =
+      ObjectHashSet::EnsureSetCapacity(table, 1, key);
+  entry = new_table->FindInsertionEntry(hash);
+  new_table->set(table->EntryToIndex(entry), *key);

[rafaelw, 2013/11/04 10:58:06]

One question, this probably doesn't matter, but it seemed strange to me that the
original code was:

table->set(EntryToIndex(entry), key);

seems like it should be

table->set(table->EntryToIndex(entry), key);

or here,

new_table->set(new_table->EntryToIndex(entry), *key);

[Michael Starzinger, 2013/11/04 13:46:42]

Hmm, HashTable::EntryToIndex() should be a static function. It shouldn't need a
receiver object.

[rafaelw, 2013/11/04 15:12:01]

That makes sense. The enclosing methods are now static as well, so these calls
are now explicitly namespaced with the classname (e.g.
ObjectHashSet::EntryToIndex, in this case).

On 2013/11/04 13:46:42, Michael Starzinger wrote:

+  new_table->ElementAdded();
+  return new_table;
 }
 
 
-MaybeObject* ObjectHashSet::Remove(Object* key) {
-  ASSERT(IsKey(key));
+Handle<ObjectHashSet> ObjectHashSet::Remove(Handle<ObjectHashSet> table,
+                                            Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
 
-  // If the object does not have an identity hash, it was never used as a key.
-  { MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
-    if (maybe_hash->ToObjectUnchecked()->IsUndefined()) return this;
-  }
-  int entry = FindEntry(key);
+  Isolate* isolate = table->GetIsolate();
+
+  // Make sure the key object has an identity hash code.
+  if (Object::GetHash(key, isolate, OMIT_CREATION)->IsUndefined()) return table;
+
+  int entry = table->FindEntry(*key);
 
   // Check whether key is actually present.
-  if (entry == kNotFound) return this;
+  if (entry == kNotFound) return table;
 
   // Remove entry and try to shrink this hash set.
-  set_the_hole(EntryToIndex(entry));
-  ElementRemoved();
-  return Shrink(key);
+  table->set_the_hole(table->EntryToIndex(entry));
+  table->ElementRemoved();
+  return ObjectHashSet::ShrinkSet(table, key);
 }