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

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.54.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.
@@ -644,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.52.0 → openscad_cpp_evaluator-0.54.0}/PKG-INFO

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

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

@@ -845,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.52.0 → openscad_cpp_evaluator-0.54.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.54.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.52.0 → openscad_cpp_evaluator-0.54.0}/src/builtins/primitives_3d.cpp

@@ -781,6 +781,14 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
+    // No faces at all is empty geometry, not a failure. BOSL2's debug_vnf()
+    // passes [verts, []] to draw vertex labels with no surface, and real
+    // OpenSCAD accepts `polyhedron(points=..., faces=[])` silently. Checked
+    // before the status branches below, which would otherwise report the
+    // empty mesh as NotManifold and discard it with a warning.
+    if (mesh.triVerts.empty()) {
+        return {ev.tagGenerated(manifold::Manifold(), node, params.at("color"))};
+    }
     manifold::Manifold body(mesh);
     if (isDrawableFailure(body, mesh)) {
         // An open surface -- faces that don't close the solid. Manifold

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.54.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;
             }
@@ -1561,35 +1564,31 @@ public:
                 return;
             }
             case NodeKind::ModularLet: {
-                // Mirrors Evaluator::evalLetBlock exactly (stmt_eval.cpp):
-                // every assignment's RHS is evaluated against the
-                // ORIGINAL (parent) ctx, never an earlier sibling's own
-                // write in THIS SAME let-block (a documented, deliberate
-                // divergence from the let-EXPRESSION form's sequential
-                // visibility) -- so every RHS is compiled+evaluated FIRST,
-                // all left on f.stack, and only written into the freshly-
-                // opened child scope (Op::OpenLetScope) AFTER every one of
-                // them has already run against the still-current PARENT
-                // ctx. No outer statement-level check for the let-block
-                // node itself (matches evalChildren's own ModularLet
-                // exclusion) -- each assignment gets its own instead,
-                // exactly like evalLetBlock's own per-assignment
-                // checkDebug. The body (n.children) compiles inline,
-                // recursively, against the now-current child ctx -- same
-                // Compiler instance, so nested statements get every bit of
-                // this same real-bytecode treatment too.
+                // Mirrors Evaluator::evalLetBlock (stmt_eval.cpp): the
+                // child scope opens FIRST, then each assignment's RHS is
+                // compiled and stored in source order, so a later binding
+                // sees an earlier one -- `let(a=1, b=a+1) ...` binds b to
+                // 2, exactly as the let-EXPRESSION form does.
+                //
+                // This used to compile every RHS before Op::OpenLetScope
+                // and then store them back-to-front, deliberately denying
+                // that visibility. Real OpenSCAD grants it, and BOSL2
+                // depends on it (isosurface.scad chains five bindings where
+                // each uses the previous).
+                //
+                // No outer statement-level check for the let-block node
+                // itself (matches evalChildren's own ModularLet exclusion)
+                // -- each assignment gets its own, exactly like
+                // evalLetBlock's own per-assignment checkDebug. The body
+                // (n.children) compiles inline, recursively, against the
+                // now-current child ctx.
                 auto& n = static_cast<const oscad::ModularLet&>(stmt);
                 CompileScope exprScope;
+                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 for (const auto& assign : n.assignments) {
                     out.push_back({Op::CheckDebugStatement, internNativeStatement(assign.get()), 0, nullptr});
                     compileIsolatedExpr(*assign->expr, out, exprScope);
-                }
-                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
-                // Values pop in REVERSE push order (LIFO) -- iterate the
-                // assignment list backwards so each Op::StoreLetVar is
-                // paired with the value that was actually pushed for IT.
-                for (auto it = n.assignments.rbegin(); it != n.assignments.rend(); ++it) {
-                    out.push_back({Op::StoreLetVar, internName((*it)->name->name), 0, &(*it)->position()});
+                    out.push_back({Op::StoreLetVar, internName(assign->name->name), 0, &assign->position()});
                 }
                 compileStatementList(n.children, out);
                 out.push_back({Op::CloseExprScope, 0, 0, nullptr});

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.54.0}/src/bytecode_vm.cpp

@@ -599,7 +599,15 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 }
                 case Op::MakeClosure: {
                     const CompiledChunk::ClosureSite& site = f.chunk->closureSites[static_cast<size_t>(ins.a)];
-                    auto capturedTrail = TrailView<Value>::makeRoot();
+                    // A child of the DEFINING ctx.let_ when the body still
+                    // has unresolved names (see ClosureSite::
+                    // captureDefiningLet), so they resolve where the closure
+                    // was written rather than wherever it is later called.
+                    // openChild, not ctx.let_ itself: the explicit captures
+                    // below are layered on top and must not leak back into
+                    // the defining scope.
+                    auto capturedTrail = site.captureDefiningLet ? ctx.let_->openChild(/*isolate=*/false)
+                                                                  : TrailView<Value>::makeRoot();
                     std::vector<const std::string*> selfNames;
                     for (const auto& cap : site.captures) {
                         if (cap.isSelfReference) {

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

@@ -155,20 +155,20 @@ void Evaluator::evalFor(const oscad::ModularFor& node, EvalContext& ctx) {
 
 void Evaluator::evalLetBlock(const oscad::ModularLet& node, EvalContext& ctx) {
     EvalContext childCtx = ctx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);
-    // ponytail/port-fidelity note: each assignment's RHS is evaluated
-    // against the ORIGINAL `ctx`, not the growing `childCtx` -- unlike the
-    // let() *expression* form's documented sequential visibility
-    // (`let(a=1, b=a+1) expr` sees `a` while evaluating `b`), the
-    // *statement* form `let(a=1, b=a+1) { ... }` does NOT: `b`'s `a+1`
-    // looks `a` up in `ctx`, which doesn't have this let's own `a` binding
-    // yet. This is a direct, deliberate port of the reference's
-    // _eval_let_block, not an oversight -- it evaluates every RHS against
-    // `ctx` in the loop, only ever writing into `child_ctx`.
+    // Each RHS is evaluated against the GROWING childCtx, so a later
+    // binding sees an earlier one -- `let(a=1, b=a+1) ...` binds b to 2.
+    // The statement form behaves exactly like the expression form here.
+    //
+    // This used to evaluate every RHS against the original `ctx` instead,
+    // described in a comment as a deliberate port of the reference's
+    // _eval_let_block. That reference was this project's own earlier
+    // implementation, which had the same bug; real OpenSCAD 2026.02.01
+    // echoes 2, and BOSL2 depends on it heavily -- isosurface.scad chains
+    // five bindings where each uses the previous, and rounding.scad's
+    // join_prism examples do the same.
     for (const auto& assign : node.assignments) {
-        // Checked against the ORIGINAL ctx (like the RHS eval below), not
-        // childCtx -- mirrors _eval_let_block's `_check_debug(assign, ctx)`.
-        checkDebug(*assign, ctx);
-        Value v = evalExprMaybeCompiled(*assign->expr, ctx);
+        checkDebug(*assign, childCtx);
+        Value v = evalExprMaybeCompiled(*assign->expr, childCtx);
         const std::string& name = assign->name->name;
         if (!name.empty() && name[0] == '$') {
             childCtx.dyn->set(name, v);

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.54.0}/tests/test_bytecode_compiler.cpp

@@ -1889,15 +1889,21 @@ TEST(ModuleBodyCompiles, AssertStatementCompiledFormFailsWithNamedMessage) {
     }
 }
 
-TEST(ModuleBodyCompiles, LetBlockStatementDoesNotSeeItsOwnEarlierSiblingAssignment) {
+TEST(ModuleBodyCompiles, LetBlockStatementSeesItsOwnEarlierSiblingAssignment) {
     ScopedVm vm(true);
-    // The statement form's own documented divergence from let-EXPRESSION
-    // sequential visibility: b's RHS must see the OUTER a (1), not this
-    // same let-block's own a=2 -- b should be 2, not 3.
+    // b's RHS sees THIS let-block's own a=2, not the outer a=1, so b is 3.
+    // The statement form has the same sequential visibility the expression
+    // form does, and the binding still does not escape the block.
+    //
+    // This test previously asserted "ECHO: 2, 2" -- b seeing the outer a --
+    // and called that a documented divergence. It was not: real OpenSCAD
+    // 2026.02.01 echoes "2, 3" then "1", which is what both engines now
+    // produce. BOSL2 depends on the sequential form (isosurface.scad chains
+    // five bindings where each uses the previous).
     EXPECT_EQ(runCapturingEcho("a = 1;\n"
                                "let (a = 2, b = a + 1) { echo(a, b); }\n"
                                "echo(a);\n"),
-              "ECHO: 2, 2\nECHO: 1");
+              "ECHO: 2, 3\nECHO: 1");
 }
 
 TEST(ModuleBodyCompiles, LetBlockStatementIsolatesDollarVarOverrideFromLaterStatements) {

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

@@ -348,8 +348,139 @@ TEST(OperatorBlockScope, BlockAssignmentCannotFeedBackIntoArgumentsInterpreted)
 TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeCompiled) { checkUserModuleChildBlockIsItsOwnScope(true); }
 TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeInterpreted) { checkUserModuleChildBlockIsItsOwnScope(false); }
 
+// A function literal declared in a MODULE body captures that body's
+// bindings, including the module's own parameters, and keeps them when it
+// escapes -- passed to another module and called there.
+//
+// The interpreter always did this (it captures ctx.let_ wholesale). The VM
+// tries to snapshot 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 the literal was frozen as a captureless constant and its free
+// names resolved against whatever ctx CALLED it -- silently undef.
+//
+// Verified against real OpenSCAD 2026.02.01: every case below echoes 20.
+
+namespace {
+
+void checkEscapingClosureKeepsItsDefiningScope(bool useVm, const std::string& body) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript(body, [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: r = 20"})) << "in: " << body;
+}
+
+} // namespace
+
+TEST(EscapingClosure, CapturesModuleParameterCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(fn) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, CapturesModuleParameterInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(fn) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+
+// BOSL2's attachable(override=...) shape: the closure travels inside a list.
+TEST(EscapingClosure, SurvivesInsideAListCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(spec) { echo(r = spec[0](2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee([f]); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, SurvivesInsideAListInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(spec) { echo(r = spec[0](2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee([f]); }\n"
+        "caller(80);\n");
+}
+
+// The callee has its OWN `s`. The closure must still see the one it was
+// written next to -- this is what proves it captures rather than merely
+// resolving late.
+TEST(EscapingClosure, IsNotCapturedByTheCallersOwnBindingCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(fn, s=999) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, IsNotCapturedByTheCallersOwnBindingInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(fn, s=999) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+
+// A literal closing over nothing keeps the cheap frozen-constant path.
+TEST(EscapingClosure, CapturelessLiteralStillWorksCompiled) {
+    ScopedVm vm(true);
+    std::vector<std::string> echoed;
+    runScript("module callee(fn) { echo(r = fn(4)); }\n"
+              "module caller() { callee(function (x) x * 5); }\n"
+              "caller();\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: r = 20"}));
+}
+
 // -- let (statement + expression forms) --------------------------------
 
+// The let STATEMENT form has the same sequential visibility as the
+// expression form: a later binding sees an earlier one. Verified against
+// real OpenSCAD 2026.02.01, which echoes 2 for both forms below.
+//
+// This was wrong for a long time, described in-source as a deliberate port
+// of "the reference's _eval_let_block" -- that reference being this
+// project's own earlier implementation, which had the same bug. BOSL2 leans
+// on it: isosurface.scad chains five bindings where each uses the previous,
+// and rounding.scad's join_prism examples do too.
+
+namespace {
+
+void checkLetStatementIsSequential(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("let (a = 1, b = a + 1) echo(b = b);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: b = 2"}));
+}
+
+void checkLetStatementShadowsWithoutEscaping(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // The inner a=2 is what b sees, and it does not survive the block.
+    runScript("a = 1;\n"
+              "let (a = 2, b = a + 1) echo(inside_a = a, inside_b = b);\n"
+              "echo(after_a = a);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: inside_a = 2, inside_b = 3",
+                                                 "ECHO: after_a = 1"}));
+}
+
+void checkLetStatementChainsSeveralBindings(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // The isosurface.scad shape: each binding built from the previous.
+    runScript("let (a = 2, b = a * 3, c = b + a, d = c * b) echo(d = d);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: d = 48"}));
+}
+
+} // namespace
+
+TEST(LetStatementScope, IsSequentialCompiled) { checkLetStatementIsSequential(true); }
+TEST(LetStatementScope, IsSequentialInterpreted) { checkLetStatementIsSequential(false); }
+
+TEST(LetStatementScope, ShadowsWithoutEscapingCompiled) { checkLetStatementShadowsWithoutEscaping(true); }
+TEST(LetStatementScope, ShadowsWithoutEscapingInterpreted) { checkLetStatementShadowsWithoutEscaping(false); }
+
+TEST(LetStatementScope, ChainsSeveralBindingsCompiled) { checkLetStatementChainsSeveralBindings(true); }
+TEST(LetStatementScope, ChainsSeveralBindingsInterpreted) { checkLetStatementChainsSeveralBindings(false); }
+
+
 TEST(LetStatement, BindsVisibleInsideBlockOnly) {
     Evaluated e = evalSrc("let(s=3) cube(s);");
     manifold::Box bbox = e.bodies[0].body->BoundingBox();