SpeculatedType StructureSet::speculationFromStructures() const
{
if (isThin()) {
if (!singleStructure())
return SpecNone;
return speculationFromStructure(singleStructure());
}
SpeculatedType result = SpecNone;
OutOfLineList* list = structureList();
for (unsigned i = 0; i < list->m_length; ++i)
mergeSpeculation(result, speculationFromStructure(list->list()[i]));
return result;
}
void RegisteredStructureSet::filter(SpeculatedType type)
{
genericFilter(
[&] (RegisteredStructure structure) -> bool {
return type & speculationFromStructure(structure.get());
});
}
void StructureSet::filter(SpeculatedType type)
{
genericFilter(
[&] (Structure* structure) -> bool {
return type & speculationFromStructure(structure);
});
}
SpeculatedType RegisteredStructureSet::speculationFromStructures() const
{
SpeculatedType result = SpecNone;
forEach(
[&] (RegisteredStructure structure) {
mergeSpeculation(result, speculationFromStructure(structure.get()));
});
return result;
}
SpeculatedType StructureSet::speculationFromStructures() const
{
SpeculatedType result = SpecNone;
forEach(
[&] (Structure* structure) {
mergeSpeculation(result, speculationFromStructure(structure));
});
return result;
}
void AbstractValue::set(Graph& graph, Structure* structure)
{
m_currentKnownStructure = structure;
setFuturePossibleStructure(graph, structure);
m_arrayModes = asArrayModes(structure->indexingType());
m_type = speculationFromStructure(structure);
m_value = JSValue();
checkConsistency();
}
void AbstractValue::set(Graph& graph, Structure* structure)
{
m_structure = structure;
m_arrayModes = asArrayModes(structure->indexingType());
m_type = speculationFromStructure(structure);
m_value = JSValue();
checkConsistency();
assertIsRegistered(graph);
}
SpeculatedType speculationFromCell(JSCell* cell)
{
if (JSString* string = jsDynamicCast<JSString*>(cell)) {
if (const StringImpl* impl = string->tryGetValueImpl()) {
if (impl->isIdentifier())
return SpecStringIdent;
}
return SpecStringVar;
}
return speculationFromStructure(cell->structure());
}
void StructureAbstractValue::filterSlow(SpeculatedType type)
{
SAMPLE("StructureAbstractValue filter type slow");
if (!(type & SpecCell)) {
clear();
return;
}
ASSERT(!isTop());
m_set.genericFilter(
[&] (Structure* structure) {
return !!(speculationFromStructure(structure) & type);
});
}
bool AbstractValue::contains(Structure* structure) const
{
return couldBeType(speculationFromStructure(structure))
&& (m_arrayModes & arrayModeFromStructure(structure))
&& m_structure.contains(structure);
}