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

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

@@ -577,6 +577,17 @@ grep for `ponytail:`.
   profiled is BOSL2's **argument type-checking**: 25–45%, millions of
   `is_finite`/`is_num`/`is_nan` calls.
 
+- **Degree trigonometry is a direct port of OpenSCAD's `src/utils/degree_trig.cc`**
+  (`sinDegrees`/`cosDegrees`/`tanDegrees` and the inverses, `builtins/function_builtins.cpp`), not
+  `std::sin(x * pi / 180)`. The structure is load-bearing: exact values at 30/45/60, the >45 range
+  computed through the COMPLEMENT function, and OpenSCAD's own literal `M_DEG2RAD` constant rather
+  than `pi / 180.0` (which rounds differently). That is what makes `sin(45) == cos(45)` and
+  `cos(30) == sqrt(3)/2` hold EXACTLY, and the exactness matters to real libraries: BOSL2's
+  `rect(rounding=...)` filters corner intersections with an exact `isect != seg[0]`, so one ULP of
+  drift made a shared vertex compare unequal, kept two corner points instead of one, and killed
+  `rect()` on its own `assert(len(cornerpt)==1, "Cannot find corner point to anchor")`. The
+  inverses also snap to a whole number of degrees when the forward function reproduces the input
+  exactly, so `asin(sin(30))` is `30`. Pinned by `DegreeTrig.*` in `tests/test_function_builtins.cpp`.
 - `include/openscad_cpp_evaluator/value.hpp`, `src/value.cpp` — the `Value` variant (OpenSCAD's
   dynamic value type) and its free-function arithmetic/comparison helpers. See the plan's §1 for
   the type-mapping table and why there's no numpy-equivalent library.
@@ -584,7 +595,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
@@ -618,6 +655,16 @@ grep for `ponytail:`.
   accordingly; read its doc comment before touching it, it's the second-trickiest mechanism in this
   codebase after the CSG tree stack), `evalUserModule`/`evalUserFunction`/`evalFunctionLiteral`,
   and `builtinChildren` (children()/children(N), deferred evaluation).
+  **A function literal declared in a MODULE body captures that body's bindings**, its own
+  parameters included, and keeps them when it escapes (passed to another module and called there).
+  The interpreter gets this for free — it captures `ctx.let_` wholesale. The VM snapshots only the
+  names it can resolve, and inside a module body it can resolve NONE: module parameters are bound
+  natively into `ctx.let_` rather than slot-addressed, and a module chunk compiles with no
+  enclosing level. So such a literal used to be frozen as a captureless constant whose free names
+  resolved against whatever ctx CALLED it — silently `undef`, which is how BOSL2's
+  `attachable(override=function(anchor) ...)` broke. `ClosureSite::captureDefiningLet` (set
+  whenever the literal's body still contains `Op::LoadFree`) makes `Op::MakeClosure` root the
+  captured trail at the DEFINING `ctx.let_`. Pinned by `EscapingClosure.*` under both engines.
   **`children(..., separate=true)`** is a BelfrySCAD extension handled *before* any of that, by
   `expandChildStatements`: a block is read with each separating forward replaced by one synthetic
   `children(k)` statement per child it selects (`makeChildrenIndexCall`, owned by

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

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

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.53.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
@@ -842,6 +845,21 @@ struct CompiledChunk {
     struct ClosureSite {
         const oscad::FunctionLiteral* node = nullptr;
         std::vector<UpvalueRef> captures;
+        // True when the literal's body still contains Op::LoadFree -- a name
+        // the compiler could not resolve to a slot or an upvalue. Such a
+        // closure is NOT self-contained: LoadFree resolves against whatever
+        // ctx is current when the closure is CALLED, so if it escapes the
+        // scope that defined it, those names silently resolve to the
+        // caller's bindings (or to undef).
+        //
+        // That is exactly what happens to a function literal declared in a
+        // MODULE body: module parameters are bound natively into ctx.let_
+        // rather than slot-addressed, and a module chunk is compiled with no
+        // enclosing level, so the compiler can resolve none of them. With
+        // this set, Op::MakeClosure roots the captured trail at the DEFINING
+        // ctx.let_ -- which is what the interpreter has always done
+        // unconditionally (see the FunctionLiteral case in expr_eval.cpp).
+        bool captureDefiningLet = false;
     };
 
     // One echo() expression form's own argument names, in source order --

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.53.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.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.51.3"
+version = "0.53.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.53.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.53.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.53.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.53.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.53.0}/src/builtins/function_builtins.cpp

@@ -55,28 +55,141 @@ Value numList(const std::vector<double>& xs) {
     return listOf(std::move(items));
 }
 
-double degrees(double rad) { return rad * 180.0 / std::numbers::pi; }
-double radians(double deg) { return deg * std::numbers::pi / 180.0; }
-
-// At exact multiples of 90 degrees, sin/cos/tan use exact table values
-// instead of sin/cos/tan(radians(x)), which accumulate floating-point
-// noise (cos(90) -> 6.12e-17 etc) -- matches real OpenSCAD's degree-based
-// trig. Mirrors _deg_trig.
-constexpr std::array<double, 4> kSin90 = {0.0, 1.0, 0.0, -1.0};
-constexpr std::array<double, 4> kCos90 = {1.0, 0.0, -1.0, 0.0};
-const std::array<double, 4> kTan90 = {0.0, std::numeric_limits<double>::infinity(), 0.0,
-                                       -std::numeric_limits<double>::infinity()};
-
-double degTrig(double x, const std::array<double, 4>& table, double (*fallback)(double)) {
-    if (std::isnan(x) || std::isinf(x)) return std::numeric_limits<double>::quiet_NaN();
-    const double n = x / 90.0;
-    const double rn = std::round(n);
-    if (rn == n) {
-        int idx = static_cast<int>(rn) % 4;
-        if (idx < 0) idx += 4;
-        return table[static_cast<size_t>(idx)];
+// Degree trigonometry, a direct port of real OpenSCAD's
+// src/utils/degree_trig.cc. Not `std::sin(x * pi / 180)`: that is off by an
+// ULP from OpenSCAD for most angles, and OpenSCAD's own extra structure --
+// exact values at 30/45/60, and computing the >45 range through the
+// COMPLEMENT function -- is what makes identities like sin(45) == cos(45)
+// and cos(30) == sqrt(3)/2 hold EXACTLY there.
+//
+// That exactness is load-bearing for real libraries, not cosmetic. BOSL2's
+// rect(rounding=...) builds a corner arc and then filters intersections
+// with `isect != seg[0]`, an exact float comparison. One ULP of drift makes
+// the shared vertex of two adjacent segments compare unequal, the filter
+// keeps two corner points instead of one, and rect() dies on its own
+// `assert(len(cornerpt)==1, "Cannot find corner point to anchor")`.
+//
+// The constants are OpenSCAD's own literals, deliberately -- M_DEG2RAD as a
+// single pre-rounded double is not bitwise identical to `pi / 180.0`.
+constexpr double kSqrt3 = 1.73205080756887719318;    // sqrt(3)
+constexpr double kSqrt3_4 = 0.86602540378443859659;  // sqrt(3/4) == sqrt(3)/2
+constexpr double kSqrt1_3 = 0.57735026918962573106;  // sqrt(1/3) == sqrt(3)/3
+constexpr double kSqrt1_2 = 0.70710678118654752440;  // sqrt(1/2)
+constexpr double kRad2Deg = 57.2957795130823208767;  // 180/PI
+constexpr double kDeg2Rad = 0.017453292519943295769; // PI/180
+
+// Assumes a 26+26=52-bit mantissa; beyond it, reduction loses all accuracy
+// and OpenSCAD returns NaN rather than a meaningless answer.
+constexpr double kTrigHugeVal = (1L << 26) * 360.0 * (1L << 26);
+
+double degrees(double rad) { return rad * kRad2Deg; }
+double radians(double deg) { return deg * kDeg2Rad; }
+
+double sinDegrees(double x) {
+    // Positive tests, so Inf/NaN fall through to the domain check.
+    if (x < 360.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 360.0 * std::floor(x / 360.0);
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    bool oppose = x >= 180.0;
+    if (oppose) x -= 180.0;
+    if (x > 90.0) x = 180.0 - x;
+    if (x < 45.0) {
+        x = (x == 30.0) ? 0.5 : std::sin(radians(x));
+    } else if (x == 45.0) {
+        x = kSqrt1_2;
+    } else if (x == 60.0) {
+        x = kSqrt3_4;
+    } else { // Inf/NaN would fall here
+        x = std::cos(radians(90.0 - x));
+    }
+    return oppose ? -x : x;
+}
+
+double cosDegrees(double x) {
+    if (x < 360.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 360.0 * std::floor(x / 360.0);
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    bool oppose = x >= 180.0;
+    if (oppose) x -= 180.0;
+    if (x > 90.0) {
+        x = 180.0 - x;
+        oppose = !oppose;
+    }
+    if (x > 45.0) {
+        x = (x == 60.0) ? 0.5 : std::sin(radians(90.0 - x));
+    } else if (x == 45.0) {
+        x = kSqrt1_2;
+    } else if (x == 30.0) {
+        x = kSqrt3_4;
+    } else { // Inf/NaN would fall here
+        x = std::cos(radians(x));
+    }
+    return oppose ? -x : x;
+}
+
+double tanDegrees(double x) {
+    const double cycles = std::floor(x / 180.0);
+    if (x < 180.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 180.0 * cycles;
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    const bool evenCycle = std::fmod(cycles, 2.0) == 0.0;
+    bool oppose = x > 90.0;
+    if (oppose) x = 180.0 - x;
+    if (x == 0.0) {
+        x = evenCycle ? 0.0 : -0.0;
+    } else if (x == 30.0) {
+        x = kSqrt1_3;
+    } else if (x == 45.0) {
+        x = 1.0;
+    } else if (x == 60.0) {
+        x = kSqrt3;
+    } else if (x == 90.0) {
+        x = evenCycle ? std::numeric_limits<double>::infinity()
+                      : -std::numeric_limits<double>::infinity();
+    } else {
+        x = std::tan(radians(x));
     }
-    return fallback(radians(x));
+    return oppose ? -x : x;
+}
+
+// The inverses snap to a whole number of degrees whenever the forward
+// function reproduces the input exactly, so asin(sin(30)) is 30 and not
+// 29.999999999999996.
+double asinDegrees(double x) {
+    const double degs = degrees(std::asin(x));
+    const double whole = std::round(degs);
+    return sinDegrees(whole) == x ? whole : degs;
+}
+
+double acosDegrees(double x) {
+    const double degs = degrees(std::acos(x));
+    const double whole = std::round(degs);
+    return cosDegrees(whole) == x ? whole : degs;
+}
+
+double atanDegrees(double x) {
+    const double degs = degrees(std::atan(x));
+    const double whole = std::round(degs);
+    return tanDegrees(whole) == x ? whole : degs;
+}
+
+// atan2 snaps on a tolerance rather than a round-trip: OpenSCAD's own rule.
+double atan2Degrees(double y, double x) {
+    const double degs = degrees(std::atan2(y, x));
+    const double whole = std::round(degs);
+    return std::fabs(degs - whole) < 3.0E-14 ? whole : degs;
 }
 
 // UTF-8 encode/decode for chr()/ord() -- OpenSCAD strings are unicode text,
@@ -1183,20 +1296,21 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
             return Value{x < 0 ? std::numeric_limits<double>::quiet_NaN() : std::log10(x)};
         }
         case BuiltinFnId::Exp: return Value{std::exp(toDoubleLenient(getArg(args, 0, "x", Value{})))};
-        case BuiltinFnId::Sin: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kSin90, &std::sin)};
-        case BuiltinFnId::Cos: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kCos90, &std::cos)};
-        case BuiltinFnId::Tan: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kTan90, &std::tan)};
+        case BuiltinFnId::Sin: return Value{sinDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
+        case BuiltinFnId::Cos: return Value{cosDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
+        case BuiltinFnId::Tan: return Value{tanDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Asin: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : degrees(std::asin(x))};
+            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : asinDegrees(x)};
         }
         case BuiltinFnId::Acos: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : degrees(std::acos(x))};
+            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : acosDegrees(x)};
         }
-        case BuiltinFnId::Atan: return Value{degrees(std::atan(toDoubleLenient(getArg(args, 0, "x", Value{}))))};
+        case BuiltinFnId::Atan: return Value{atanDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Atan2:
-            return Value{degrees(std::atan2(toDoubleLenient(getArg(args, 0, "y", Value{})), toDoubleLenient(getArg(args, 1, "x", Value{}))))};
+            return Value{atan2Degrees(toDoubleLenient(getArg(args, 0, "y", Value{})),
+                                       toDoubleLenient(getArg(args, 1, "x", Value{})))};
         case BuiltinFnId::Max: return builtinMinMax(args, true);
         case BuiltinFnId::Min: return builtinMinMax(args, false);
         case BuiltinFnId::Pow: return builtinPow(toDoubleLenient(getArg(args, 0, "x", Value{})), toDoubleLenient(getArg(args, 1, "y", Value{})));

{openscad_cpp_evaluator-0.51.3 → openscad_cpp_evaluator-0.53.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.53.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.53.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.53.0}/src/bytecode_compiler.cpp

@@ -447,10 +447,12 @@ public:
                 // `ctx.let_`, which callCtxFor roots at this exact closure's
                 // own capturedLet snapshot whenever it's invoked -- the same
                 // snapshot `effectiveCaptures` describes below.
-                if (effectiveCaptures.empty() || !containsLoadFree(literalChunk)) {
+                // Must be read BEFORE literalChunk is moved from below.
+                const bool needsDefiningLet = containsLoadFree(literalChunk);
+                if (effectiveCaptures.empty() || !needsDefiningLet) {
                     chunk_.nestedLiterals.emplace_back(&n, std::move(literalChunk));
                 }
-                if (effectiveCaptures.empty()) {
+                if (effectiveCaptures.empty() && !needsDefiningLet) {
                     // Closes over nothing at all, even transitively -- a
                     // single frozen constant works for every invocation, no
                     // per-call snapshot needed.
@@ -461,7 +463,8 @@ public:
                 }
                 // Escaping-closure support (Op::MakeClosure, bytecode.hpp).
                 int siteIdx = static_cast<int>(chunk_.closureSites.size());
-                chunk_.closureSites.push_back(CompiledChunk::ClosureSite{&n, std::move(effectiveCaptures)});
+                chunk_.closureSites.push_back(
+                    CompiledChunk::ClosureSite{&n, std::move(effectiveCaptures), needsDefiningLet});
                 out.push_back({Op::MakeClosure, siteIdx, 0, nullptr});
                 return;
             }
@@ -1289,7 +1292,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 +1323,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 +1350,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 +1704,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 +1732,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;
             }