JSPropertyNameEnumerator.h [plain text]
#pragma once
#include "JSCast.h"
#include "Operations.h"
#include "PropertyNameArray.h"
#include "Structure.h"
namespace JSC {
class JSPropertyNameEnumerator final : public JSCell {
public:
using Base = JSCell;
static constexpr unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
return &vm.propertyNameEnumeratorSpace;
}
static JSPropertyNameEnumerator* create(VM&, Structure*, uint32_t, uint32_t, PropertyNameArray&&);
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(vm, globalObject, prototype, TypeInfo(CellType, StructureFlags), info());
}
DECLARE_EXPORT_INFO;
JSString* propertyNameAtIndex(uint32_t index)
{
if (index >= sizeOfPropertyNames())
return nullptr;
return m_propertyNames.get()[index].get();
}
StructureChain* cachedPrototypeChain() const { return m_prototypeChain.get(); }
void setCachedPrototypeChain(VM& vm, StructureChain* prototypeChain) { return m_prototypeChain.set(vm, this, prototypeChain); }
Structure* cachedStructure(VM& vm) const
{
if (!m_cachedStructureID)
return nullptr;
return vm.heap.structureIDTable().get(m_cachedStructureID);
}
StructureID cachedStructureID() const { return m_cachedStructureID; }
uint32_t indexedLength() const { return m_indexedLength; }
uint32_t endStructurePropertyIndex() const { return m_endStructurePropertyIndex; }
uint32_t endGenericPropertyIndex() const { return m_endGenericPropertyIndex; }
uint32_t cachedInlineCapacity() const { return m_cachedInlineCapacity; }
uint32_t sizeOfPropertyNames() const { return endGenericPropertyIndex(); }
static ptrdiff_t cachedStructureIDOffset() { return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_cachedStructureID); }
static ptrdiff_t indexedLengthOffset() { return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_indexedLength); }
static ptrdiff_t endStructurePropertyIndexOffset() { return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_endStructurePropertyIndex); }
static ptrdiff_t endGenericPropertyIndexOffset() { return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_endGenericPropertyIndex); }
static ptrdiff_t cachedInlineCapacityOffset() { return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_cachedInlineCapacity); }
static ptrdiff_t cachedPropertyNamesVectorOffset()
{
return OBJECT_OFFSETOF(JSPropertyNameEnumerator, m_propertyNames);
}
static void visitChildren(JSCell*, SlotVisitor&);
private:
friend class LLIntOffsetsExtractor;
JSPropertyNameEnumerator(VM&, Structure*, uint32_t, uint32_t, WriteBarrier<JSString>*, unsigned);
void finishCreation(VM&, RefPtr<PropertyNameArrayData>&&);
AuxiliaryBarrier<WriteBarrier<JSString>*> m_propertyNames;
WriteBarrier<StructureChain> m_prototypeChain;
StructureID m_cachedStructureID;
uint32_t m_indexedLength;
uint32_t m_endStructurePropertyIndex;
uint32_t m_endGenericPropertyIndex;
uint32_t m_cachedInlineCapacity;
};
void getEnumerablePropertyNames(JSGlobalObject*, JSObject*, PropertyNameArray&, uint32_t& indexedLength, uint32_t& structurePropertyCount);
inline JSPropertyNameEnumerator* propertyNameEnumerator(JSGlobalObject* globalObject, JSObject* base)
{
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
uint32_t indexedLength = base->methodTable(vm)->getEnumerableLength(globalObject, base);
JSPropertyNameEnumerator* enumerator = nullptr;
Structure* structure = base->structure(vm);
if (!indexedLength
&& (enumerator = structure->cachedPropertyNameEnumerator())
&& enumerator->cachedPrototypeChain() == structure->prototypeChain(globalObject, base))
return enumerator;
uint32_t numberStructureProperties = 0;
PropertyNameArray propertyNames(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude);
getEnumerablePropertyNames(globalObject, base, propertyNames, indexedLength, numberStructureProperties);
RETURN_IF_EXCEPTION(scope, nullptr);
ASSERT(propertyNames.size() < UINT32_MAX);
bool sawPolyProto;
bool successfullyNormalizedChain = normalizePrototypeChain(globalObject, base, sawPolyProto) != InvalidPrototypeChain;
Structure* structureAfterGettingPropertyNames = base->structure(vm);
if (!structureAfterGettingPropertyNames->canAccessPropertiesQuicklyForEnumeration()) {
indexedLength = 0;
numberStructureProperties = 0;
}
enumerator = JSPropertyNameEnumerator::create(vm, structureAfterGettingPropertyNames, indexedLength, numberStructureProperties, WTFMove(propertyNames));
if (!indexedLength && successfullyNormalizedChain && structureAfterGettingPropertyNames == structure) {
enumerator->setCachedPrototypeChain(vm, structure->prototypeChain(globalObject, base));
if (structure->canCachePropertyNameEnumerator(vm))
structure->setCachedPropertyNameEnumerator(vm, enumerator);
}
return enumerator;
}
}