openscad-cpp-evaluator 0.51.3__tar.gz → 0.52.0__tar.gz

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/CLAUDE.md

@@ -584,7 +584,33 @@ grep for `ponytail:`.
   mutable state threaded through recursive evaluation. `dyn`/`let_`/`dynPositions`/`dynExplicit`
   are `shared_ptr`-wrapped, not plain value members — `withScope()` relies on that aliasing to
   give sibling statements in the same block correct assignment visibility (see the header comment
-  before reworking this; it's not an arbitrary choice).
+  before reworking this; it's not an arbitrary choice). **An `if`/`else` branch body is its own
+  scope**: assignments (including `$`-var assignments) inside it are visible for the rest of the
+  branch but must not survive the closing brace, so both engines evaluate a taken branch against
+  `childCtx()` — `branchScope()` in `stmt_eval.cpp`, `Op::OpenLetScope`/`Op::CloseExprScope`
+  around each branch on the compiled path. `let_`/`dyn` open a non-isolated child (the branch
+  reads everything outside, writes only inside) while `dynPositions` opens an **isolated** one, so
+  shadowing an outer name is not mistaken for reassigning it — two assignments to the same name
+  *within* one branch still warn, because they share that fresh level. Getting this wrong is not
+  just a spurious warning: before the fix a branch's writes escaped and silently changed later
+  geometry (BOSL2's `half_of()` reassigns `v` inside an `else if`, clobbering the outer `v`).
+  **A builtin operator's braced child block (`translate() { a = 1; }`) is its own scope by the
+  same rule.** Each builtin resolve function derives one `Evaluator::blockScope()` context for its
+  children (`booleans.cpp` derives ONE spanning both of `resolveCsg`'s passes, since the assignment
+  pass writes what the geometry pass reads); `emitBuiltinWrap`/`emitCsgWrap` bracket their inline
+  children with `Op::OpenLetScope`/`Op::CloseExprScope`. The bracket goes *inside* Push/Pop, because
+  `Op::PopBuiltinWrap` re-resolves the call's arguments and those must still see the OUTER ctx — an
+  assignment in the block must never feed back into the operator's own arguments.
+  **Do not "simplify" this into `resolveCallArgs`** by having it always return a child ctx, however
+  tempting — every builtin's child context does come from there, but so does every *user*-module
+  call's and every pure argument resolution, and the extra dyn level breaks BOSL2's `$`-var
+  propagation outright (`$tags_shown`/`$attach_to`/`$transform`/`$anchor_override` stop resolving).
+  That was tried: the whole unit suite passed and 130 of ~390 BOSL2 doc examples failed. Scope the
+  CHILDREN, not the call. `for`/`let`/`intersection_for` bodies, and a *user* module's child block (evaluated
+  through `childrenCallerCtx`), were already correct. `tests/test_control_flow.cpp`'s
+  `IfBranchScope.*` and `OperatorBlockScope.*` pin every case under both engines. One older test
+  (`RenderExpr.MeasuredSubtreeUsesItsOwnCoordinates`) had encoded the leak by reading a block's
+  variable from outside it, and was corrected.
 - `include/openscad_cpp_evaluator/eval_error.hpp`, `src/eval_error.cpp` — `EvalError` and the
   exact ERROR/TRACE string formatting real OpenSCAD produces. Also the **unexpected-argument
   warnings** (`warnUnexpectedNamedArg`/`warnTooManyPositionalArgs`/`warnUnexpectedArgs`), the port

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 0.51.3
+Version: 0.52.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -687,7 +687,10 @@ enum class Op {
     // just "pop the current ctx level", identical either way.
     CloseExprScope,
 
-    // ModularLet's own (statement-form) child scope -- mirrors
+    // ModularLet's own (statement-form) child scope, ALSO used to bracket
+    // an if/else branch body (see ModularIf/ModularIfElse in
+    // bytecode_compiler.cpp) -- a branch is its own scope in OpenSCAD and
+    // needs exactly this same child ctx, so one opcode covers both -- mirrors
     // Evaluator::evalLetBlock's own `ctx.childCtx(nullptr, std::nullopt,
     // ctx.childrenNodes, ctx.childrenCallerCtx)` call exactly, pushed onto
     // f.ctxChain (Op::CloseExprScope, above, pops it back off once the

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -144,6 +144,22 @@ public:
     // sub-groups of an existing children list without needing ownership.
     void evalChildren(const std::vector<const oscad::ASTNode*>& children, EvalContext& ctx);
 
+    // The child context a BRACED BLOCK's statements run in. A `{ ... }`
+    // block is a scope in OpenSCAD: assignments (and `$`-var assignments)
+    // inside it are visible for the rest of the block but must not survive
+    // the closing brace. Every builtin operator's resolve function derives
+    // one of these for its children; the compiled path does the same with
+    // an Op::OpenLetScope/Op::CloseExprScope bracket.
+    //
+    // Deliberately NOT folded into resolveCallArgs, though that is the one
+    // place every builtin's child context comes from: resolveCallArgs also
+    // serves user-module calls and pure argument resolution, and giving
+    // those an extra dyn level breaks BOSL2's `$`-var propagation
+    // ($tags_shown/$attach_to/$transform all stop resolving). Measured, not
+    // reasoned: 130 of ~390 BOSL2 doc examples failed that way. Scope the
+    // CHILDREN, not the call.
+    EvalContext blockScope(const EvalContext& ctx) const;
+
     // Top-level entry point: resolveTree() + generateTree(), then the
     // top-level `!` (show_only) filter -- if any returned body has
     // BodyRole::ShowOnly, the result is filtered down to just

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.51.3"
+version = "0.52.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/booleans.cpp

@@ -91,22 +91,27 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
 
+    // ONE scope around both passes -- see Evaluator::blockScope. The
+    // assignment pass writes into the same block scope the geometry pass
+    // then reads from, so it cannot be scoped per-pass.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+
     std::vector<const oscad::ASTNode*> assignNodes;
     std::vector<const oscad::ASTNode*> geoNodes;
-    for (const oscad::ASTNode* c : ev.expandChildStatements(node.children, effCtx)) {
+    for (const oscad::ASTNode* c : ev.expandChildStatements(node.children, blockCtx)) {
         if (c->kind() == oscad::NodeKind::Assignment) {
             assignNodes.push_back(c);
         } else if (c->kind() != oscad::NodeKind::ModuleDeclaration && c->kind() != oscad::NodeKind::FunctionDeclaration) {
             geoNodes.push_back(c);
         }
     }
-    if (!assignNodes.empty()) ev.evalChildren(assignNodes, effCtx);
+    if (!assignNodes.empty()) ev.evalChildren(assignNodes, blockCtx);
 
     std::vector<Value> groupSizes;
     groupSizes.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
-        ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, effCtx);
+        ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, blockCtx);
         groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
     }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/color.cpp

@@ -44,7 +44,9 @@ CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContex
     // under the color-tagged context -- the returned bodies themselves are
     // unused here; generate reads them back via each child's own .bodies
     // and stamps `rgba` onto all of them. Mirrors _resolve_color.
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/control.cpp

@@ -31,7 +31,9 @@ std::vector<ColoredBody> generateChildren(Evaluator&, const CSGParams&, const st
 CSGParams resolveRender(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return CSGParams{};
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/extrude.cpp

@@ -56,7 +56,9 @@ BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::Modular
 
 CSGParams resolveLinearExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     BuiltinWrapParams result = computeLinearExtrudeParams(ev, node, ctx);
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 
@@ -107,7 +109,9 @@ BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::Modular
 
 CSGParams resolveRotateExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     BuiltinWrapParams result = computeRotateExtrudeParams(ev, node, ctx);
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 
@@ -143,7 +147,9 @@ BuiltinWrapParams computeProjectionParams(Evaluator& ev, const oscad::ModularCal
 
 CSGParams resolveProjection(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     BuiltinWrapParams result = computeProjectionParams(ev, node, ctx);
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 
@@ -209,7 +215,9 @@ BuiltinWrapParams computeOffsetParams(Evaluator& ev, const oscad::ModularCall& n
 
 CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     BuiltinWrapParams result = computeOffsetParams(ev, node, ctx);
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/roof.cpp

@@ -464,7 +464,9 @@ CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& ef
 
 CSGParams resolveRoof(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return computeRoofParams(ev, args, effCtx);
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/topology.cpp

@@ -23,7 +23,9 @@ static constexpr double kDefaultSimplifyFraction = 0.001;
 CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return CSGParams{};
 }
 
@@ -85,7 +87,9 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
 CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return CSGParams{};
 }
 
@@ -146,7 +150,9 @@ std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams&,
 CSGParams resolveMinkowski(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return CSGParams{};
 }
 
@@ -334,7 +340,9 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, cons
 CSGParams resolveMinkowskiDifference(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return CSGParams{};
 }
 
@@ -394,7 +402,9 @@ CSGParams resolveSimplify(Evaluator& ev, const oscad::ModularCall& node, EvalCon
     CSGParams params;
     // Position 0 so simplify(0.1) reads naturally.
     params["tolerance"] = getArg(args, 0, "tolerance", Value{});
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return params;
 }
 
@@ -715,7 +725,9 @@ CSGParams resolveLevelSet(Evaluator& ev, const oscad::ModularCall& node, EvalCon
     params["isovalue"] = getArg(args, 2, "isovalue", Value{0.0});
     params["invert"] = getArg(args, 3, "invert", Value{false});
     params["edge"] = getArg(args, 4, "edge", Value{});
-    ev.evalChildren(node.children, effCtx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
     return params;
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/builtins/transforms.cpp

@@ -219,7 +219,9 @@ BuiltinWrapParams computeTransformParams(Evaluator& ev, const oscad::ModularCall
 
 CSGParams resolveTransform(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     BuiltinWrapParams result = computeTransformParams(ev, node, ctx);
-    ev.evalChildren(node.children, result.ctx);
+    // The child block is its own scope -- see Evaluator::blockScope.
+    EvalContext blockCtx = ev.blockScope(result.ctx);
+    ev.evalChildren(node.children, blockCtx);
     return std::move(result.params);
 }
 

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/bytecode_compiler.cpp

@@ -1289,7 +1289,15 @@ public:
         chunk_.builtinWrapSites.push_back(std::move(site));
         const int idx = static_cast<int>(chunk_.builtinWrapSites.size()) - 1;
         out.push_back({Op::PushBuiltinWrap, idx, 0, &wrapperNode.position()});
+        // The child block is its own scope -- same rule as an if-branch, and
+        // the interpreter gets it from resolveCallArgs' child ctx (see
+        // call_args.cpp). Opened INSIDE the Push/Pop bracket so that
+        // Op::PopBuiltinWrap's own resolveCallArgs call still sees the
+        // OUTER ctx: an assignment in the block must not feed back into the
+        // operator's own arguments.
+        out.push_back({Op::OpenLetScope, 0, 0, nullptr});
         compileStatementList(children, out);
+        out.push_back({Op::CloseExprScope, 0, 0, nullptr});
         out.push_back({Op::PopBuiltinWrap, idx, 0, &wrapperNode.position()});
     }
 
@@ -1312,6 +1320,10 @@ public:
         chunk_.csgWrapSites.push_back(std::move(site));
         const int idx = static_cast<int>(chunk_.csgWrapSites.size()) - 1;
         out.push_back({Op::PushCsgWrap, idx, 0, &call.position()});
+        // One scope around BOTH passes -- see emitBuiltinWrap's own note.
+        // The assignment pass must write into the same block scope the
+        // geometry pass then reads from, so it cannot be bracketed per-pass.
+        out.push_back({Op::OpenLetScope, 0, 0, nullptr});
 
         std::vector<const oscad::ASTNode*> assignNodes;
         std::vector<const oscad::ASTNode*> geoNodes;
@@ -1335,6 +1347,7 @@ public:
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
             out.push_back({Op::CsgGroupEnd, 0, 0, nullptr});
         }
+        out.push_back({Op::CloseExprScope, 0, 0, nullptr});
         out.push_back({Op::PopCsgWrap, idx, 0, &call.position()});
     }
 
@@ -1688,13 +1701,25 @@ public:
                 emitBuiltinWrap(CompiledChunk::BuiltinWrapSite::Kind::Modifier, "show_only", n, {n.child.get()}, out);
                 return;
             }
+            // Both if-forms bracket the taken branch in Op::OpenLetScope /
+            // Op::CloseExprScope. An if-branch body is its own scope in
+            // OpenSCAD -- assignments inside must not survive the closing
+            // brace -- and the child ctx a let-BLOCK gets is exactly the
+            // one a branch needs, so the same opcode serves both (see
+            // branchScope, stmt_eval.cpp, for the interpreter's identical
+            // rule and the full reasoning). The scope is opened INSIDE the
+            // conditional jump's target range, so a branch that is not
+            // taken never opens one, and each branch's own Close is the
+            // last thing before the jump past its sibling.
             case NodeKind::ModularIf: {
                 auto& n = static_cast<const oscad::ModularIf&>(stmt);
                 const int jumpFalseIdx = static_cast<int>(out.size());
                 out.push_back({Op::NativeCondJumpIfFalse, internNativeExpr(n.condition.get()), 0, &n.condition->position()});
                 const oscad::ASTNode* marker = n.trueBranch.empty() ? &stmt : n.trueBranch.front().get();
                 out.push_back({Op::NativeCheckDebugExprLevel, internNativeStatement(marker), 0, nullptr});
+                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 compileStatementList(n.trueBranch, out);
+                out.push_back({Op::CloseExprScope, 0, 0, nullptr});
                 out[static_cast<size_t>(jumpFalseIdx)].b = static_cast<int>(out.size());
                 return;
             }
@@ -1704,13 +1729,17 @@ public:
                 out.push_back({Op::NativeCondJumpIfFalse, internNativeExpr(n.condition.get()), 0, &n.condition->position()});
                 const oscad::ASTNode* trueMarker = n.trueBranch.empty() ? &stmt : n.trueBranch.front().get();
                 out.push_back({Op::NativeCheckDebugExprLevel, internNativeStatement(trueMarker), 0, nullptr});
+                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 compileStatementList(n.trueBranch, out);
+                out.push_back({Op::CloseExprScope, 0, 0, nullptr});
                 const int jumpEndIdx = static_cast<int>(out.size());
                 out.push_back({Op::Jump, 0, 0, nullptr});
                 out[static_cast<size_t>(jumpFalseIdx)].b = static_cast<int>(out.size());
                 const oscad::ASTNode* falseMarker = n.falseBranch.empty() ? &stmt : n.falseBranch.front().get();
                 out.push_back({Op::NativeCheckDebugExprLevel, internNativeStatement(falseMarker), 0, nullptr});
+                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 compileStatementList(n.falseBranch, out);
+                out.push_back({Op::CloseExprScope, 0, 0, nullptr});
                 out[static_cast<size_t>(jumpEndIdx)].a = static_cast<int>(out.size());
                 return;
             }

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/measure_geometry.cpp

@@ -228,7 +228,9 @@ Value Evaluator::evalRenderExpr(const oscad::RenderExpression& node, EvalContext
     treeStack_.emplace_back();
     std::vector<std::unique_ptr<CSGNode>> sub;
     try {
-        evalChildren(node.children, effCtx);
+        // The child block is its own scope -- see blockScope.
+        EvalContext blockCtx = blockScope(effCtx);
+        evalChildren(node.children, blockCtx);
         sub = std::move(treeStack_.back());
         treeStack_.pop_back();
     } catch (...) {

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/src/stmt_eval.cpp

@@ -6,6 +6,32 @@
 
 namespace oscadeval {
 
+// A braced block is its own scope in OpenSCAD: assignments (and `$`-var
+// assignments) inside it are visible to the rest of the block and to
+// anything it calls, but must NOT survive the closing brace.
+//
+//     a = 1;
+//     if (true) { a = 2; }
+//     echo(a);            // 1 in OpenSCAD -- was 2 here
+//
+// Evaluating a block against the enclosing ctx let those writes escape,
+// which silently changed geometry (BOSL2's half_of() reassigns `v` inside
+// an `else if`, clobbering the outer `v` for everything after it) and also
+// produced a bogus "assigned on line N but was overwritten" warning for
+// what is really a shadow, not an overwrite. Verified against OpenSCAD
+// 2026.02.01 for values, `$`-vars, nesting, and the same-scope warning
+// that must still fire.
+//
+// This is exactly the child context a let-BLOCK gets (evalLetBlock, and
+// Op::OpenLetScope on the compiled path): let_/dyn open a non-isolated
+// child so the block reads everything outside and writes only inside,
+// while dynPositions opens an ISOLATED one so shadowing an outer name is
+// not mistaken for reassigning it -- two assignments to the same name
+// within the one block still warn, because they share this fresh level.
+EvalContext Evaluator::blockScope(const EvalContext& ctx) const {
+    return ctx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);
+}
+
 void Evaluator::evalAssignment(const oscad::Assignment& node, EvalContext& ctx) {
     const std::string& name = node.name->name;
     if (!name.empty() && name[0] == '$') {
@@ -196,7 +222,8 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
             if (truthy(evalExprMaybeCompiled(*n.condition, ctx))) {
                 checkDebug(n.trueBranch.empty() ? node : *n.trueBranch.front(), ctx, /*forced=*/false,
                             /*exprLevel=*/true);
-                evalChildren(n.trueBranch, ctx);
+                EvalContext branchCtx = blockScope(ctx);
+                evalChildren(n.trueBranch, branchCtx);
             }
             return;
         }
@@ -204,7 +231,8 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
             auto& n = static_cast<const oscad::ModularIfElse&>(node);
             const auto& branch = truthy(evalExprMaybeCompiled(*n.condition, ctx)) ? n.trueBranch : n.falseBranch;
             checkDebug(branch.empty() ? node : *branch.front(), ctx, /*forced=*/false, /*exprLevel=*/true);
-            evalChildren(branch, ctx);
+            EvalContext branchCtx = blockScope(ctx);
+            evalChildren(branch, branchCtx);
             return;
         }
         case oscad::NodeKind::ModularFor:

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.52.0}/tests/test_control_flow.cpp

@@ -144,6 +144,210 @@ TEST(IfElseStatement, PicksCorrectBranch) {
     EXPECT_EQ(e.tree[0]->kind, "sphere");
 }
 
+// An if/else branch body is its own scope in OpenSCAD: assignments inside
+// it are visible for the rest of the branch, but must NOT survive the
+// closing brace. Regression tests for a real bug -- the branch used to be
+// evaluated against the ENCLOSING context, so its writes escaped and
+// silently changed later geometry. BOSL2's half_of() hit exactly this:
+// it reassigns `v` inside an `else if`, which clobbered the outer `v` for
+// everything after it, and also produced a bogus "assigned on line N but
+// was overwritten" warning for what is really a shadow.
+//
+// Every case below was verified against real OpenSCAD 2026.02.01 first.
+// Pinned under both VM states explicitly: evalStatement's ModularIf/
+// ModularIfElse and compileOneStatement's own copies are independent.
+
+namespace {
+
+void checkBranchIsItsOwnScope(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("a = 1;\n"
+              "if (true) { a = 2; if (true) { a = 3; echo(deep=a); } echo(mid=a); }\n"
+              "echo(outer=a);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    // Each nesting level shadows independently: the inner writes are gone
+    // by the time control leaves each brace.
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: deep = 3", "ECHO: mid = 2", "ECHO: outer = 1"}));
+}
+
+void checkBranchDollarVarDoesNotEscape(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("$fn = 8;\n"
+              "if (true) { $fn = 64; echo(inside=$fn); }\n"
+              "echo(after=$fn);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    // `$`-vars are scoped by the branch too, not just plain names.
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: inside = 64", "ECHO: after = 8"}));
+}
+
+void checkDoubleAssignmentWithinOneBranchStillWarns(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> messages;
+    runScript("if (true) { z = 1; z = 2; echo(z=z); }\n",
+              [&](const std::string& msg) { messages.push_back(msg); });
+    // The branch gets a FRESH dynPositions level, so shadowing an outer
+    // name is not reported -- but two assignments to the same name inside
+    // the one branch share that level and must still warn, exactly as
+    // OpenSCAD does. Guards against "fixing" the leak by disabling the
+    // check outright.
+    const bool warned = std::any_of(messages.begin(), messages.end(), [](const std::string& m) {
+        return m.find("z was assigned on line 1 but was overwritten") != std::string::npos;
+    });
+    EXPECT_TRUE(warned) << "expected the same-scope reassignment warning";
+    EXPECT_NE(std::find(messages.begin(), messages.end(), "ECHO: z = 2"), messages.end());
+}
+
+void checkShadowingAnOuterNameDoesNotWarn(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> messages;
+    runScript("y = 1;\n"
+              "if (true) { y = 99; }\n",
+              [&](const std::string& msg) { messages.push_back(msg); });
+    const bool warned = std::any_of(messages.begin(), messages.end(), [](const std::string& m) {
+        return m.find("was overwritten") != std::string::npos;
+    });
+    EXPECT_FALSE(warned) << "shadowing an outer name in a branch is not an overwrite";
+}
+
+void checkElseIfBranchIsItsOwnScope(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // The shape BOSL2's half_of() has: a module-body assignment, then a
+    // reassignment of the same name inside an `else if` branch.
+    runScript("module m(v=1) {\n"
+              "    v = v + 1;\n"
+              "    if (false) { echo(unused=v); } else if (true) { v = v * 10; echo(inner=v); }\n"
+              "    echo(outer=v);\n"
+              "}\n"
+              "m(2);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: inner = 30", "ECHO: outer = 3"}));
+}
+
+} // namespace
+
+TEST(IfBranchScope, BranchIsItsOwnScopeCompiled) { checkBranchIsItsOwnScope(true); }
+TEST(IfBranchScope, BranchIsItsOwnScopeInterpreted) { checkBranchIsItsOwnScope(false); }
+
+TEST(IfBranchScope, DollarVarDoesNotEscapeCompiled) { checkBranchDollarVarDoesNotEscape(true); }
+TEST(IfBranchScope, DollarVarDoesNotEscapeInterpreted) { checkBranchDollarVarDoesNotEscape(false); }
+
+TEST(IfBranchScope, DoubleAssignmentWithinOneBranchStillWarnsCompiled) {
+    checkDoubleAssignmentWithinOneBranchStillWarns(true);
+}
+TEST(IfBranchScope, DoubleAssignmentWithinOneBranchStillWarnsInterpreted) {
+    checkDoubleAssignmentWithinOneBranchStillWarns(false);
+}
+
+TEST(IfBranchScope, ShadowingAnOuterNameDoesNotWarnCompiled) { checkShadowingAnOuterNameDoesNotWarn(true); }
+TEST(IfBranchScope, ShadowingAnOuterNameDoesNotWarnInterpreted) { checkShadowingAnOuterNameDoesNotWarn(false); }
+
+TEST(IfBranchScope, ElseIfBranchIsItsOwnScopeCompiled) { checkElseIfBranchIsItsOwnScope(true); }
+TEST(IfBranchScope, ElseIfBranchIsItsOwnScopeInterpreted) { checkElseIfBranchIsItsOwnScope(false); }
+
+// A builtin operator's braced child block is its own scope too -- the same
+// OpenSCAD rule as an if-branch, on a different code path (the interpreter
+// gets it from resolveCallArgs' child ctx, the compiled path from an
+// Op::OpenLetScope/Op::CloseExprScope bracket inside emitBuiltinWrap /
+// emitCsgWrap). Regression tests for the same class of bug: these writes
+// used to escape into the enclosing scope.
+//
+// User-module child blocks were always correct (their children are
+// evaluated through childrenCallerCtx), and are pinned here so that stays
+// true.
+
+namespace {
+
+void checkOperatorBlockIsItsOwnScope(bool useVm, const std::string& opCall) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("a = 1;\n" + opCall + " { a = 99; cube(1); }\n" + "echo(after=a);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: after = 1"})) << "in: " << opCall;
+}
+
+void checkOperatorBlockDollarVarDoesNotEscape(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("$fn = 8;\n"
+              "translate([0,0,0]) { $fn = 64; echo(inside=$fn); cube(1); }\n"
+              "echo(after=$fn);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: inside = 64", "ECHO: after = 8"}));
+}
+
+void checkOperatorBlockAssignmentIsVisibleWithinTheBlock(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // Scoping the block must not break the ordinary case: a name assigned
+    // in the block is still visible to the rest of it (and, for a CSG
+    // operator, across resolveCsg's assignment/geometry two-pass split).
+    runScript("union() { s = 3; echo(seen=s); cube(s); }\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: seen = 3"}));
+}
+
+void checkBlockAssignmentCannotFeedBackIntoOperatorArguments(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> messages;
+    // The operator's own arguments are resolved against the OUTER ctx,
+    // before the block scope opens -- so this translates by 1, not by 99.
+    // (That is why the compiled bracket sits INSIDE Push/PopBuiltinWrap.)
+    RunResult r = runScript("d = 1;\n"
+                            "translate([d,0,0]) { d = 99; cube(1); }\n",
+                            [&](const std::string& msg) { messages.push_back(msg); });
+    (void)messages;
+    EXPECT_DOUBLE_EQ(asNum(varValue(r, "d")), 1.0);
+}
+
+void checkUserModuleChildBlockIsItsOwnScope(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("c = 1;\n"
+              "module wrap() { children(); }\n"
+              "wrap() { c = 99; cube(1); }\n"
+              "echo(after=c);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: after = 1"}));
+}
+
+} // namespace
+
+TEST(OperatorBlockScope, TransformBlockIsItsOwnScopeCompiled) {
+    checkOperatorBlockIsItsOwnScope(true, "translate([0,0,0])");
+}
+TEST(OperatorBlockScope, TransformBlockIsItsOwnScopeInterpreted) {
+    checkOperatorBlockIsItsOwnScope(false, "translate([0,0,0])");
+}
+
+TEST(OperatorBlockScope, CsgBlockIsItsOwnScopeCompiled) { checkOperatorBlockIsItsOwnScope(true, "union()"); }
+TEST(OperatorBlockScope, CsgBlockIsItsOwnScopeInterpreted) { checkOperatorBlockIsItsOwnScope(false, "union()"); }
+
+TEST(OperatorBlockScope, ColorBlockIsItsOwnScopeCompiled) { checkOperatorBlockIsItsOwnScope(true, "color(\"red\")"); }
+TEST(OperatorBlockScope, ColorBlockIsItsOwnScopeInterpreted) { checkOperatorBlockIsItsOwnScope(false, "color(\"red\")"); }
+
+TEST(OperatorBlockScope, DollarVarDoesNotEscapeCompiled) { checkOperatorBlockDollarVarDoesNotEscape(true); }
+TEST(OperatorBlockScope, DollarVarDoesNotEscapeInterpreted) { checkOperatorBlockDollarVarDoesNotEscape(false); }
+
+TEST(OperatorBlockScope, AssignmentVisibleWithinTheBlockCompiled) {
+    checkOperatorBlockAssignmentIsVisibleWithinTheBlock(true);
+}
+TEST(OperatorBlockScope, AssignmentVisibleWithinTheBlockInterpreted) {
+    checkOperatorBlockAssignmentIsVisibleWithinTheBlock(false);
+}
+
+TEST(OperatorBlockScope, BlockAssignmentCannotFeedBackIntoArgumentsCompiled) {
+    checkBlockAssignmentCannotFeedBackIntoOperatorArguments(true);
+}
+TEST(OperatorBlockScope, BlockAssignmentCannotFeedBackIntoArgumentsInterpreted) {
+    checkBlockAssignmentCannotFeedBackIntoOperatorArguments(false);
+}
+
+TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeCompiled) { checkUserModuleChildBlockIsItsOwnScope(true); }
+TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeInterpreted) { checkUserModuleChildBlockIsItsOwnScope(false); }
+
 // -- let (statement + expression forms) --------------------------------
 
 TEST(LetStatement, BindsVisibleInsideBlockOnly) {