Dictionary<NameDictionary, NameDictionaryShape, Name*>::
New(Isolate* isolate, int n, PretenureFlag pretenure);
-template MaybeObject*
+template Handle<SeededNumberDictionary>
Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
- AtPut(uint32_t, Object*);
+ AtPut(Handle<SeededNumberDictionary>, uint32_t, Handle<Object>);
-template MaybeObject*
+template Handle<UnseededNumberDictionary>
Dictionary<UnseededNumberDictionary, UnseededNumberDictionaryShape, uint32_t>::
- AtPut(uint32_t, Object*);
+ AtPut(Handle<UnseededNumberDictionary>, uint32_t, Handle<Object>);
template Object*
Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
template<typename Derived, typename Shape, typename Key>
-MaybeObject* Dictionary<Derived, Shape, Key>::AtPut(Key key, Object* value) {
- int entry = this->FindEntry(key);
+Handle<Derived> Dictionary<Derived, Shape, Key>::AtPut(
+ Handle<Derived> dictionary, Key key, Handle<Object> value) {
+ int entry = dictionary->FindEntry(key);
// If the entry is present set the value;
if (entry != Dictionary::kNotFound) {
- ValueAtPut(entry, value);
- return this;
+ dictionary->ValueAtPut(entry, *value);
+ return dictionary;
}
// Check whether the dictionary should be extended.
- Object* obj;
- { MaybeObject* maybe_obj = EnsureCapacity(1, key);
- if (!maybe_obj->ToObject(&obj)) return maybe_obj;
- }
+ dictionary = EnsureCapacity(dictionary, 1, key);
- Object* k;
- { MaybeObject* maybe_k = Shape::AsObject(this->GetHeap(), key);
- if (!maybe_k->ToObject(&k)) return maybe_k;
- }
+ Handle<Object> k = Shape::AsHandle(dictionary->GetIsolate(), key);
+ // TODO(ishell): Figure out if it is necessary to call AsHandle() here.
+ USE(k);
PropertyDetails details = PropertyDetails(NONE, NORMAL, 0);
- return Dictionary::cast(obj)->AddEntry(
- key, value, details, Dictionary::Hash(key));
+ return AddEntry(dictionary, key, value, details, dictionary->Hash(key));
}
// Add a key, value pair to the dictionary.
template<typename Derived, typename Shape, typename Key>
+Handle<Derived> Dictionary<Derived, Shape, Key>::AddEntry(
+ Handle<Derived> dictionary,
+ Key key,
+ Handle<Object> value,
+ PropertyDetails details,
+ uint32_t hash) {
+ CALL_HEAP_FUNCTION(
+ dictionary->GetIsolate(),
+ dictionary->AddEntry(key, *value, details, hash),
+ Derived);
+}
+
+template<typename Derived, typename Shape, typename Key>
MaybeObject* Dictionary<Derived, Shape, Key>::AddEntry(
Key key,
Object* value,
uint32_t key,
Handle<Object> value) {
dictionary->UpdateMaxNumberKey(key);
- CALL_HEAP_FUNCTION(
- dictionary->GetIsolate(),
- dictionary->AtPut(key, *value),
- SeededNumberDictionary);
+ return AtPut(dictionary, key, value);
}
Handle<UnseededNumberDictionary> dictionary,
uint32_t key,
Handle<Object> value) {
- CALL_HEAP_FUNCTION(
- dictionary->GetIsolate(),
- dictionary->AtPut(key, *value),
- UnseededNumberDictionary);
+ return AtPut(dictionary, key, value);
}
protected:
// Generic at put operation.
- MUST_USE_RESULT MaybeObject* AtPut(Key key, Object* value);
+ MUST_USE_RESULT static Handle<Derived> AtPut(
+ Handle<Derived> dictionary,
+ Key key,
+ Handle<Object> value);
// Add entry to dictionary.
MUST_USE_RESULT MaybeObject* AddEntry(Key key,
Object* value,
PropertyDetails details,
uint32_t hash);
+ MUST_USE_RESULT static Handle<Derived> AddEntry(
+ Handle<Derived> dictionary,
+ Key key,
+ Handle<Object> value,
+ PropertyDetails details,
+ uint32_t hash);
// Generate new enumeration indices to avoid enumeration index overflow.
MUST_USE_RESULT MaybeObject* GenerateNewEnumerationIndices();
static inline uint32_t HashForObject(Name* key, Object* object);
MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
Name* key);
+ static inline Handle<Object> AsHandle(Isolate* isolate, Name* key);
static const int kPrefixSize = 2;
static const int kEntrySize = 3;
static const bool kIsEnumerable = true;
Handle<Object> value,
PropertyDetails details);
- MUST_USE_RESULT MaybeObject* Set(uint32_t key,
- Object* value,
- PropertyDetails details);
-
void UpdateMaxNumberKey(uint32_t key);
// If slow elements are required we will never go back to fast-case