WeakValueMap: entries for recently garbage-collected values temporarily remain visible with undefined value

[mvduin]

After a value gets garbage collected but before the FinalizationRegistry callback has fired the table entry continues to exist according to has(), size, and iteration, but with undefined value. This is unlikely to be what any user wants, I would expect map entries to simply get deleted when values get garbage-collected.

It's easy enough to make the has() method and iteration methods deref the WeakRef to verify the entry is still valid and pretend it doesn't exist otherwise. It's a bit annoying though that a correct implementation for size would require iterating the entire map, although it would also be a rather ugly wart if it sometimes returns an erroneously high value. Perhaps if there's a use-case for a fast size estimate (upper bound) a separate accessor could be added for it.

Test case using node --expose-gc:

import { WeakValueMap } from 'weakref';
import assert from 'node:assert';

function next_job() {
    return new Promise( resolve => setImmediate( resolve ) );
}

let map = new WeakValueMap;

map.set( 42, {} );

await next_job();  // release strong ref on new/dereferenced weakrefs
gc();  // garbage-collect the now-unreferenced value

assert.strictEqual( map.get( 42 ), undefined );  // passes
assert( ! map.has( 42 ) );  // FAILS
assert.strictEqual( map.size, 0 );  // FAILS

[mvduin]

It occurred to me a compromise is possible that retains sensible semantics while avoiding significant slowdowns: declare that table entries may get spontaneously deleted at any time (including in between calls to WeakValueMap methods) but with the constraints that:

• If the value is strongly retained (outside the table) then the table entry will not get deleted.
• As long as a table entry continues to exist, its value is always whatever it was last set to.
• Once an entry is observed to have been deleted it will not reappear (unless you set a new value).

These constraints can be met without any change to methods that do not retrieve a value (size, has(), delete(), and keys()), but requires that methods that do retrieve a value (get(), values(), entries()) will automatically unregister and delete the entry (and omit them from iteration) if dereferencing the WeakRef returns undefined.

Effectively this causes WeakValueMap to pretend that "coincidentically" the table entry got deleted right before you try to access the entry's value (if it turns out to have been garbage collected but the FinalizerRegistry callback hasn't fired yet).