Share parsed files instead of re-parsing every include

[revarbat]

Parsing include <BOSL2/std.scad> costs ~55 ms and is ~82% of evaluating a small script against it. The library does not change between renders, so an editor re-rendering — and a docs build rendering a thousand examples — pay that 55 ms over and over.

	before	after (warm)
Resolve a script including BOSL2	55.4 ms	0.12 ms

Sharing forced the second half of this change

ASTNode no longer carries its own Scope*. It could not: include puts the included nodes in the includer's scope, so the same BOSL2 node is in a different scope in every script that includes it, and whichever evaluation wrote the field last would corrupt the rest.

The pointer moves into a ScopeTable that the root Scope owns, addressed by a (treeId, slot) pair stamped on each node at parse time. A lookup stays two loads and no hashing — which matters, because the VM reads it on its call path. Nodes are numbered in the constructor from a parse-scoped counter, since there is no generic child walker to number a finished tree with.

Only per-file parses are cached

Never a resolved program. A file is spliced in at most once per resolution (visited), so caching std.scad already-resolved would double its statements in a script that also includes something else depending on it. Re-running the resolution is only pointer pushes. There's a test for exactly this.

Churn kept low

buildScopes() keeps its signature — it creates the table and hands it to the root Scope — so the ~170 existing call sites are untouched. Reads go through a new scopeOf(scope, node).

The cache holds one entry per file, replaced when size or mtime moves, so an editor saving repeatedly doesn't accumulate a copy of every version.

Verified

• 648 parser tests pass
• Downstream: 1153 evaluator tests, 31 binding tests, and BOSL2's 909 regression tests

🤖 Generated with Claude Code