render() in expression position: measure your own geometry

[revarbat]

obj = render() difference() { cube(100); sphere(20); };
echo(obj.volume, obj.genus, obj.boundingbox);
polyhedron(obj);

OpenSCAD could not previously measure its own geometry — the numbers only exist after the geometry is built, and the language had no way to reach them. Requires BelfrySCAD/openscad_cpp_parser#5 (submodule bumped here).

It measures and discards — nothing is drawn

That is what makes the semantics uniform. No side effects, so top level, module bodies, function bodies, list comprehensions and ternaries all behave identically, and function purity survives:

function fits(w) = render() { cube(w); }.volume < 500;   // works, draws nothing

A draw-and-measure design would have had to forbid this.

The two-pass problem needed no new pipeline

generatePartialTree() already generates mid-resolve for the debugger's live render, and its doc comment already reasons about why that is safe (the resolve pass never reads CSGNode::bodies). measureCsgSubtree does the same for one subtree, on its own treeStack_ frame, popped and discarded so it can never reach the drawn tree.

Discarding costs one guard

measuring_ suppresses the four writes that exist solely to describe drawn geometry — idToNode/idToColor in tagGenerated and tagDisplayOnly, the restampCachedIds call on a cache hit, and cacheProducer_. Those tables are cleared once per pass, so a leak is permanent and surfaces much later as wrong click-to-source. The same flag suppresses checkDebug, which would otherwise inject stops at the paused statement's own callStack_ depth.

The geometry cache deliberately stays on: cacheKey is content-addressed, so an entry a measurement stores is genuinely reusable by the real render.

Real bytecode, not an interpreter bail

A new BuiltinWrapSite::Kind::Measure reuses the existing Op::PushBuiltinWrap/PopBuiltinWrap pair, inheriting the whole bracket lifecycle — push/pop counting, ctxChain discipline, exception teardown — for free. No new opcode, and no change to the treeStack_ unwind.

The teardown's "respects LIFO order" comments turned out to be misleading and are corrected here: those three loops are counts, not targeted pops. Popping N off the back removes the top N whichever group counted them, so the grouping is bookkeeping, not sequencing.

One real bug this surfaced — and why the interpreter landed first: statement opcodes now run inside function chunks for the first time, and a compiled function keeps parameters in frame slots that no EvalContext can see. function f(w) = render() { cube(w); }.volume; found no w and silently measured an undef-sized cube, returning 0 rather than erroring. Kind::Measure now captures (name, slot) at compile time and republishes into the children's context.

Mesh output is VNF-shaped

[x,y,z] vertices, 0-based N-gon faces, clockwise seen from outside — feeds polyhedron() and BOSL2 unchanged. polyhedron() and polygon() also take the object directly, and accept any object with the right keys.

Two details are load-bearing and silent when wrong: winding is reversed on the way out (Manifold's triVerts is CCW), and vertices are welded by exact position (Manifold splits property-vertices; without the weld the round-trip is an open mesh). Verified empirically that a reversed mesh comes back as negative volume with Status() == NoError, so tests assert a positive volume and never use abs().

Things that will bite

• render is now a reserved keyword — see the parser PR for why LALR(1) leaves no alternative.
• obj = render() cube(1); does not parse. The child_statement swallows the ;. Use the braced form. Asserted in tests.
• genus is Manifold's, for the whole result. A cube with a sealed cavity reports -1, not 0 — its boundary has two components.

Testing

953 tests pass under both OSCAD_BYTECODE_VM=0 and =1, and clean under ASan. New coverage includes 12 scripts asserted identical across both engines, a positive check that the chunks actually compile (the regression guard against reintroducing the bail), provenance-cleanliness under the VM specifically, and five throw paths including one originating deep inside a nested module frame.

Verified end to end through BelfrySCAD's CLI: the round-trip reproduces 908 facets / 458 vertices and the identical surface area and bounding box.

(An unrelated pre-existing ASan heap-buffer-overflow in Manifold's own sort.cpp:55, hit by MinkowskiDifference.ShrinksANonConvexBodyOnEverySide, reproduces identically on a clean checkout of 4f20db3 — confirmed by building that worktree separately. Not touched here.)

🤖 Generated with Claude Code