Build small object literals in O(1) with cached keys, no extra allocation

[lahma]

Summary

Object literals are built by JintObjectExpression.BuildObjectFast, which inserted each property through the PropertyDictionary indexer. For the list backing (literals with fewer than 9 properties) that re-walked the chain from the head to find the tail on every insert, making the build O(n²), and it re-derived (and re-hashed) a Key from each property-name string on every execution.

Two changes:

1. Cache the pre-hashed Key[] on the node (computed once when the literal is fast-buildable), so every execution skips re-hashing the property names.
2. Build distinct small literals in O(1) with no extra allocation. For the common case — a literal evaluated outside any generator/async frame (so no property value can suspend the build) with statically distinct keys and fewer than 9 properties — link the property nodes directly with a local tail cursor instead of going through the indexer. Each append is O(1), suspension bookkeeping is skipped, and the finished chain is adopted by a list-backed PropertyDictionary. Because the tail is a local (no retained _tail field on ListDictionary), per-object allocation is exactly what it was before.

Literals with duplicate keys, 9+ properties, or evaluated inside a generator fall through to the existing checked path (which already builds a dictionary in O(1) for the 9+ case). The adopted list keeps checkExistingKeys: true so any post-construction property add still de-duplicates, matching the previous behaviour; it costs nothing because the build never uses the add path.

Benchmark

Jint.Benchmark/PropertyAllocBenchmark and ObjectAccessBenchmark, default BDN job, .NET 10, Ryzen 9 5950X, same-runtime worktree A/B (baseline = upstream/main, run back-to-back, two A/B pairs):

Benchmark	Baseline	This PR	Δ time	Allocated
Literal8 (8 props)	64.8–65.5 ms	57.0–60.5 ms	−6% … −13%	159.92 MB (flat)
Literal3 (3 props)	47.3–50.3 ms	~48 ms	within noise	95.21 MB (flat)
UpdateObjectProperty	90.50 ms	88.35 ms	−2.4%	60.43 MB (flat)
WriteObjectProperty	67.35 ms	67.30 ms	flat	30.22 MB (flat)
Constructor3 / Constructor1	—	—	within noise	flat

The benefit of the O(1) build grows with property count: the 8-property literal shows a clear, repeatable improvement, while the 3-property build is already so cheap that the change sits within run-to-run variance (baseline Literal3 itself ranged ~47–50 ms across runs). Allocation is deterministically unchanged everywhere — the build allocates exactly what it did before.

Correctness

• dotnet test Jint.Tests: 3137 passed, 0 failed.
• dotnet test Jint.Tests.PublicInterface: 79 passed, 0 failed.
• Test262 (strict + sloppy): 0 new failures.
• Covered by ad-hoc checks: distinct/duplicate/colliding keys ({1:..,'1':..}), integer-key enumeration order, the 8-property list edge and 9+ dictionary cutover, deletion (head/middle/tail), generators that build object literals, and ordered value side effects.

🤖 Generated with Claude Code