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

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

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

{openscad_cpp_evaluator-0.53.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.53.0"
+version = "0.54.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -1564,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.53.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.53.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.53.0 → openscad_cpp_evaluator-0.54.0}/tests/test_control_flow.cpp

@@ -428,6 +428,59 @@ TEST(EscapingClosure, CapturelessLiteralStillWorksCompiled) {
 
 // -- 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();

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.54.0}/tests/test_primitives.cpp

@@ -211,6 +211,32 @@ TEST(Polyhedron, OpenMeshIsKeptForDisplayAndWarns) {
 // The originalID is what maps a picked triangle back to its source line, so
 // a display-only body has to carry one or clicking it would select nothing
 // -- precisely when a user most wants to be shown the offending code.
+// A polyhedron with points but NO faces is empty geometry, not a failure.
+// BOSL2's debug_vnf() passes [verts, []] to draw vertex labels with no
+// surface at all, and real OpenSCAD 2026.02.01 accepts
+// `polyhedron(points=..., faces=[])` silently. This used to report the
+// empty mesh as NotManifold and discard it with a warning, which failed
+// four BOSL2 geometry.scad examples.
+TEST(Polyhedron, NoFacesIsEmptyGeometryAndSilent) {
+    std::string warning;
+    Evaluated e = evalSrc("polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[]);",
+                          [&](const std::string& m) { warning = m; });
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].body->IsEmpty());
+    EXPECT_FALSE(e.bodies[0].isDisplayOnly());   // nothing to display, not an open surface
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(Polyhedron, NoPointsAndNoFacesIsAlsoSilent) {
+    std::string warning;
+    Evaluated e = evalSrc("polyhedron(points=[], faces=[]);",
+                          [&](const std::string& m) { warning = m; });
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].body->IsEmpty());
+    EXPECT_EQ(warning, "") << warning;
+}
+
 TEST(Polyhedron, OpenMeshCarriesAnOriginalIdForPicking) {
     Evaluated e = evalSrc(kOpenCube);
     ASSERT_EQ(e.bodies.size(), 1u);