children(separate=true): forward children as separate CSG operands

[revarbat]

difference() children() returns the union, not a difference — the children arrive as one operand, so there is nothing to subtract from. Upstream OpenSCAD behaves the same and offers no per-call way out.

module frame() { difference() children(separate=true); }
frame() {
    cube(50, center=true);   // child 0 -- the positive operand
    sphere(30);              // subtracted
    cylinder(h=99, r=8);     // subtracted
}

intersection() is the case with no workaround at all. For difference() you could already write difference() { children(0); children([1:$children-1]); }, since A-(B∪C) == A-B-C. That identity does not hold for intersection: A∩(B∪C) ≠ A∩B∩C.

The obvious implementation does not work

The wrapper children() builds is already display-only — isBuiltin=false, so generateTreeImpl falls through to plain concatenation. Removing it changes nothing, because difference() groups its operands by AST child statement, not by node. children() is one statement however many nodes it splices, so one group of N stays one group of N.

That per-statement grouping is deliberate and load-bearing: BOSL2's attachable() returns parent + attachments as several bodies and must count as one operand. So the feature is not "stop wrapping" but let one statement contribute several groups.

Mechanism

A CSGNode::separateOperand flag, set on the forwarded nodes. Putting it on the nodes rather than on the Evaluator buys three things for free:

• several splices in one statement work (difference() { for (i=[0:1]) children(separate=true); });
• nesting degrades correctly — under translate() the nodes land in translate's frame, so difference() still sees one operand, with no code to make that happen;
• nothing to restore on the throw path.

group_sizes was being built twice, once per engine. Both now route through one shared Evaluator::appendGroupSizes, landed first as a behaviour-neutral step with the suite green. It preserves the size-zero group that a statement producing no geometry contributes — generateCsg uses that to reset intersection() and bail difference(), and Intersection.DisabledStatementIsTrulyEmptyAndDiscardsResult guards it.

Also closes a gap this made testable: Op::CallChildren never called warnUnexpectedBuiltinArgs, so a children() typo warned under the interpreter and was silent under the VM.

Scope

Narrower than it looks. Only union/difference/intersection/intersection_for group operands at all. hull/minkowski/minkowski_difference read bodies via the unsliced flattenCsgTree, and the old wrapper was plain concatenation — so they already saw the children separately. Verified, not assumed, and pinned by a test.

Verification

• 1005 tests pass under both engines, 16 of them new.
• Mutation-tested: breaking the two VM marking sites fails 7 of the 16 new tests, so the VM coverage is genuine rather than a silent fallback to the interpreter.
• Oracle: the hand-written difference(){...} of the same shape. Both give 123000; plain children() gives 125000; intersection gives 500 separated vs 1500 grouped — identical under OSCAD_BYTECODE_VM=0 and =1.

One judgement call, pinned by a test so it cannot drift: the mark rides on the nodes, so module pass() { children(separate=true); } passes separateness outward through its own splice. Retreating to "stop at the module boundary" is any_of → all_of in spliceModuleChildren.

🤖 Generated with Claude Code