Skip to content
Closed
Show file tree
Hide file tree
Changes from 3 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
298 changes: 159 additions & 139 deletions src/jsc/modules/NodeUtilTypesModule.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -393,170 +393,198 @@ static bool arraySubsequence(JSC::JSGlobalObject* globalObject, JSC::MarkedArgum
return nonIndexObjectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
}

// Expected's entries as a subset of actual's: identity keys fast-path with
// index reservation so no actual entry is consumed twice; object keys match
// by partial deep equality.
static bool mapSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
// Node's `typeof x !== "object" || x === null`: such a value matches only an identical counterpart.
static bool isSpecialValue(JSValue value)
{
auto& vm = globalObject->vm();
JSC::JSMap* actualMap = uncheckedDowncast<JSC::JSMap>(actual.asCell());
JSC::JSMap* expectedMap = uncheckedDowncast<JSC::JSMap>(expected.asCell());
return !value.isObject() || value.isCallable();
}

// Materialized lazily, rooted in gcBuffer (keys then values, pairwise).
bool materialized = false;
size_t entriesStart = 0;
size_t entryCount = 0;
WTF::Vector<bool, 8> usedIndices;
JSC::MarkedArgumentBuffer usedIdentityKeys;

auto materialize = [&]() -> bool {
if (materialized)
return true;
materialized = true;
entriesStart = gcBuffer.size();
auto iter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), actualMap, JSC::IterationKind::Entries);
if (scope.exception()) [[unlikely]]
return false;
JSValue key, value;
while (iter->nextKeyValue(globalObject, key, value)) {
gcBuffer.append(key);
gcBuffer.append(value);
entryCount++;
}
usedIndices.fill(false, entryCount);
return true;
};
enum class Pairing { Open,
Complete };

auto identityKeyUsed = [&](JSValue key) -> bool {
for (size_t i = 0; i < usedIdentityKeys.size(); i++) {
bool same = JSC::sameValue(globalObject, usedIdentityKeys.at(i), key);
// sameValue can resolve ropes and throw; plain check because the macro can't live
// inside a lambda — callers RETURN_IF_EXCEPTION right after this returns.
if (scope.exception()) [[unlikely]]
return false;
if (same)
return true;
}
return false;
};
// Expected entries no lookup could settle; copies, kept alive by the caller's gcBuffer appends.
template<typename Entry>
struct PendingExpected {
using Queue = WTF::Vector<Entry, 8>;

auto expectedIter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), expectedMap, JSC::IterationKind::Entries);
RETURN_IF_EXCEPTION(scope, false);
JSValue expectedKey, expectedValue;
while (expectedIter->nextKeyValue(globalObject, expectedKey, expectedValue)) {
bool consumed = false;
bool identityPresent = actualMap->has(globalObject, expectedKey);
RETURN_IF_EXCEPTION(scope, false);
bool expectedKeyAlreadyUsed = identityKeyUsed(expectedKey);
// sameValue can resolve rope strings and throw; the lambda cannot
// hold the check macro, so check at every call site.
RETURN_IF_EXCEPTION(scope, false);
if (identityPresent && !expectedKeyAlreadyUsed) {
// Reserve the identity entry's index so the deep-matching loop
// below cannot consume it twice.
size_t identityIndex = SIZE_MAX;
if (materialized) {
for (size_t i = 0; i < entryCount; i++) {
bool same = JSC::sameValueZero(globalObject, gcBuffer.at(entriesStart + i * 2), expectedKey);
// Same rope-resolution hazard as identityKeyUsed: bail
// before the next VM-entering call, not after the loop.
RETURN_IF_EXCEPTION(scope, false);
if (same) {
identityIndex = i;
break;
}
}
Queue entries;
size_t first { 0 };
size_t last;
// Node's guess: keep probing the end that hit last, so same-order and reversed inputs stay linear.
bool probeFront { true };

explicit PendingExpected(Queue&& queued)
: entries(std::move(queued))
, last(entries.size() - 1)
{
ASSERT(!entries.isEmpty());
}

size_t openCount() const { return last - first + 1; }

// Node's partialObject{Set,Map}Equiv probe order: front guess, back guess, then the rest back to front.
template<typename Matches>
Pairing claimWith(JSC::ThrowScope& scope, const Matches& matches)
{
size_t scanFrom = first;
if (probeFront) {
bool hit = matches(entries[first]);
RETURN_IF_EXCEPTION(scope, Pairing::Open);
if (hit) {
if (first == last)
return Pairing::Complete;
first++;
return Pairing::Open;
}
if (identityIndex == SIZE_MAX || !usedIndices[identityIndex]) {
JSValue actualValue = actualMap->get(globalObject, expectedKey);
RETURN_IF_EXCEPTION(scope, false);
bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, expectedValue);
RETURN_IF_EXCEPTION(scope, false);
if (equal) {
usedIdentityKeys.append(expectedKey);
if (identityIndex != SIZE_MAX)
usedIndices[identityIndex] = true;
consumed = true;
}
if (first == last)
return Pairing::Open;
probeFront = false;
scanFrom++;
}
bool hit = matches(entries[last]);
RETURN_IF_EXCEPTION(scope, Pairing::Open);
if (!hit) {
probeFront = true;
size_t i = last;
while (!hit && i > scanFrom) {
i--;
hit = matches(entries[i]);
RETURN_IF_EXCEPTION(scope, Pairing::Open);
}
if (!hit)
return Pairing::Open;
entries[i] = entries[last];
}
if (consumed)
continue;
if (!expectedKey.isObject())
return false;
if (!materialize())
return false;
if (first == last)
return Pairing::Complete;
last--;
return Pairing::Open;
}
};

struct PendingMapEntry {
JSValue key;
JSValue value;
};

// Node's mapEquiv: special keys are settled by lookup; object keys, identical ones included, are paired off.
static bool mapSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
{
auto& vm = globalObject->vm();
JSC::JSMap* actualMap = uncheckedDowncast<JSC::JSMap>(actual.asCell());
JSC::JSMap* expectedMap = uncheckedDowncast<JSC::JSMap>(expected.asCell());

PendingExpected<PendingMapEntry>::Queue queued;
{
auto iter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), expectedMap, JSC::IterationKind::Entries);
RETURN_IF_EXCEPTION(scope, false);
bool matched = false;
for (size_t i = 0; i < entryCount; i++) {
if (usedIndices[i])
JSValue expectedKey, expectedValue;
while (iter->nextKeyValue(globalObject, expectedKey, expectedValue)) {
if (!isSpecialValue(expectedKey)) {
gcBuffer.append(expectedKey);
gcBuffer.append(expectedValue);
queued.append({ expectedKey, expectedValue });
continue;
JSValue candidateKey = gcBuffer.at(entriesStart + i * 2);
bool candidateIsUsedIdentity = identityKeyUsed(candidateKey);
}
JSValue actualValue = actualMap->get(globalObject, expectedKey);
RETURN_IF_EXCEPTION(scope, false);
if (candidateIsUsedIdentity)
continue;
bool keyEqual = compareBranch(globalObject, gcBuffer, cycles, scope, candidateKey, expectedKey);
if (actualValue.isUndefined()) {
// get() answers undefined both for a missing key and for a key holding undefined.
bool held = actualMap->has(globalObject, expectedKey);
RETURN_IF_EXCEPTION(scope, false);
if (!held)
return false;
}
bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, expectedValue);
RETURN_IF_EXCEPTION(scope, false);
if (!keyEqual)
continue;
bool valueEqual = compareBranch(globalObject, gcBuffer, cycles, scope, gcBuffer.at(entriesStart + i * 2 + 1), expectedValue);
if (!equal)
return false;
}
}
if (queued.isEmpty())
return true;

PendingExpected<PendingMapEntry> pending(std::move(queued));
auto iter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), actualMap, JSC::IterationKind::Entries);
RETURN_IF_EXCEPTION(scope, false);
size_t visited = 0;
JSValue actualKey, actualValue;
while (iter->nextKeyValue(globalObject, actualKey, actualValue)) {
visited++;
if (!isSpecialValue(actualKey)) {
Pairing pairing = pending.claimWith(scope, [&](const PendingMapEntry& entry) -> bool {
bool keyEqual = compareBranch(globalObject, gcBuffer, cycles, scope, actualKey, entry.key);
RETURN_IF_EXCEPTION(scope, false);
if (!keyEqual)
return false;
return compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, entry.value);
});
RETURN_IF_EXCEPTION(scope, false);
if (valueEqual) {
usedIndices[i] = true;
matched = true;
break;
}
if (pairing == Pairing::Complete)
return true;
}
if (!matched)
const size_t size = actualMap->size();
const size_t unvisited = size > visited ? size - visited : 0;
if (unvisited < pending.openCount())
return false;
}
return true;
return false;
}

// Expected's items as a subset of actual's; item equality is the partial
// comparison itself — node matches object items with subset semantics
// (Set([{a:1,b:2}]) partially contains Set([{a:1}])).
// Node's setEquiv: members actual holds are settled by lookup; the other objects are paired off partially.
static bool setSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
{
auto& vm = globalObject->vm();
JSC::JSSet* actualSet = uncheckedDowncast<JSC::JSSet>(actual.asCell());
JSC::JSSet* expectedSet = uncheckedDowncast<JSC::JSSet>(expected.asCell());

const size_t itemsStart = gcBuffer.size();
size_t itemCount = 0;
PendingExpected<JSValue>::Queue queued;
{
auto iter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), actualSet, JSC::IterationKind::Keys);
auto iter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), expectedSet, JSC::IterationKind::Keys);
RETURN_IF_EXCEPTION(scope, false);
JSValue item;
while (iter->next(globalObject, item)) {
gcBuffer.append(item);
itemCount++;
JSValue expectedMember;
while (iter->next(globalObject, expectedMember)) {
bool held = actualSet->has(globalObject, expectedMember);
RETURN_IF_EXCEPTION(scope, false);
if (held)
continue;
if (isSpecialValue(expectedMember))
return false;
gcBuffer.append(expectedMember);
queued.append(expectedMember);
}
}
WTF::Vector<bool, 8> usedIndices;
usedIndices.fill(false, itemCount);
if (queued.isEmpty())
return true;

auto expectedIter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), expectedSet, JSC::IterationKind::Keys);
PendingExpected<JSValue> pending(std::move(queued));
auto iter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), actualSet, JSC::IterationKind::Keys);
RETURN_IF_EXCEPTION(scope, false);
JSValue expectedItem;
while (expectedIter->next(globalObject, expectedItem)) {
bool matched = false;
for (size_t i = 0; i < itemCount; i++) {
if (usedIndices[i])
continue;
bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, gcBuffer.at(itemsStart + i), expectedItem);
RETURN_IF_EXCEPTION(scope, false);
if (equal) {
usedIndices[i] = true;
matched = true;
break;
size_t visited = 0;
JSValue actualMember;
while (iter->next(globalObject, actualMember)) {
visited++;
bool reserved = expectedSet->has(globalObject, actualMember);
RETURN_IF_EXCEPTION(scope, false);
if (!reserved) {
if (isSpecialValue(actualMember)) {
// Node probes a stray member too (unlike a stray Map key); all its misses leave behind is this.
pending.probeFront = true;
} else {
Pairing pairing = pending.claimWith(scope, [&](JSValue expectedMember) -> bool {
return compareBranch(globalObject, gcBuffer, cycles, scope, actualMember, expectedMember);
});
RETURN_IF_EXCEPTION(scope, false);
if (pairing == Pairing::Complete)
return true;
}
}
Comment thread
claude[bot] marked this conversation as resolved.
Resolved
if (!matched)
const size_t size = actualSet->size();
const size_t unvisited = size > visited ? size - visited : 0;
if (unvisited < pending.openCount())
return false;
}
return true;
return false;
}

// Errors compare name/message/errors leniently: `undefined` (or an empty
Expand Down Expand Up @@ -646,14 +674,6 @@ static bool setSubsetAndProps(JSC::JSGlobalObject* globalObject, JSC::MarkedArgu
return objectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
}

static bool isSpecialValue(JSValue value)
{
// `typeof x !== "object"`: primitives, null, and callables are decided
// by full strict deep equality. Every specific type (Error, Date, RegExp,
// boxed primitives, ...) has already been handled by its own arm above.
return !value.isObject() || value.isCallable();
}

static bool compareBranch(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
{
auto& vm = globalObject->vm();
Expand Down
Loading
Loading