openscad-cpp-evaluator 0.55.3__tar.gz → 0.55.4__tar.gz

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -68,6 +68,9 @@ struct PendingCsgWrap {
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
     std::vector<Value> groupSizes;
+    // Parallel to groupSizes: whether a group that came out EMPTY is still
+    // an operand. See Op::CsgGroupEnd's `a`.
+    std::vector<Value> emptyIsAGroup;
     size_t groupStartSize = 0;
 };
 

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/pyproject.toml

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

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/python/openscad_cpp_evaluator/__init__.py

@@ -213,7 +213,8 @@ def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:
 # Params keys never shown in format_csg_tree's per-node summary, regardless
 # of kind -- pure internal bookkeeping or already represented structurally
 # elsewhere in the tree. Mirrors the reference's _DUMP_HIDDEN_PARAM_KEYS.
-_DUMP_HIDDEN_PARAM_KEYS = frozenset({"color", "op", "name", "group_sizes"})
+_DUMP_HIDDEN_PARAM_KEYS = frozenset(
+    {"color", "op", "name", "group_sizes", "empty_is_a_group"})
 
 # Auto-generated tessellation data (not user-authored) for every kind except
 # polyhedron, where the equivalent data *is* the user's own points/faces.

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/src/builtins/booleans.cpp

@@ -108,16 +108,43 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     if (!assignNodes.empty()) ev.evalChildren(assignNodes, blockCtx);
 
     std::vector<Value> groupSizes;
+    std::vector<Value> emptyIsAGroup;
     groupSizes.reserve(geoNodes.size());
+    emptyIsAGroup.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
         ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, blockCtx);
         groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+        // Whether a statement that produced NOTHING still counts as an
+        // operand.
+        //
+        // The reference builds a node for a module instantiation and for a
+        // loop whatever they contain, so an empty one is an empty operand
+        // and annihilates an intersection. An `if` that takes no branch, a
+        // bare block, and a `*`-disabled statement build no node at all, so
+        // they are not operands and must be skipped.
+        //
+        // Every line of this was checked against OpenSCAD rather than
+        // reasoned about -- `intersection(){ cube(10); X; }` keeps the cube
+        // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
+        // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
+        // a call to an empty user module.
+        const oscad::NodeKind k = geoNode->kind();
+        emptyIsAGroup.push_back(Value{
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground});
     }
 
     CSGParams params;
     params["op"] = Value{op};
     params["group_sizes"] = Value{std::make_shared<const ValueList>(ValueList{std::move(groupSizes)})};
+    params["empty_is_a_group"] =
+        Value{std::make_shared<const ValueList>(ValueList{std::move(emptyIsAGroup)})};
     return params;
 }
 
@@ -180,16 +207,36 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
                                       const oscad::ASTNode&) {
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
+    const auto emptyIsAGroupIt = params.find("empty_is_a_group");
+    const std::vector<Value>* emptyIsAGroup =
+        emptyIsAGroupIt == params.end()
+            ? nullptr
+            : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
     std::optional<ColoredBody> csgResult;
     size_t idx = 0;
 
+    size_t stmtIndex = 0;
     for (const Value& sizeVal : groupSizes) {
         const size_t size = static_cast<size_t>(std::get<double>(sizeVal));
+        const size_t thisStmt = stmtIndex++;
         std::vector<ColoredBody> stmtBodies = flattenCsgTree(children, idx, size);
         idx += size;
 
+        // A statement that built no CSG node at all is not an operand --
+        // an `if` whose branch was not taken, or an empty block. Only a
+        // for-loop still counts as one when it produced nothing, matching
+        // the group node the reference builds for it regardless. Without
+        // this, `intersection(){ X; if (crop) Y; }` -- BOSL2's hirth()
+        // among others -- came out empty whenever the condition was false.
+        if (size == 0) {
+            const bool isGroup = emptyIsAGroup && thisStmt < emptyIsAGroup->size() &&
+                                  std::holds_alternative<bool>((*emptyIsAGroup)[thisStmt]) &&
+                                  std::get<bool>((*emptyIsAGroup)[thisStmt]);
+            if (!isGroup) continue;
+        }
+
         RoleSplit split = splitByRole(stmtBodies);
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/src/bytecode_compiler.cpp

@@ -1348,7 +1348,21 @@ public:
             }
             out.push_back({Op::CsgGroupStart, 0, 0, nullptr});
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
-            out.push_back({Op::CsgGroupEnd, 0, 0, nullptr});
+            // `a` = whether a group that turns out EMPTY is still an
+            // operand: a module instantiation or a loop builds a node
+            // whatever it contains, an `if`/block/`*` does not. Mirrors
+            // resolveCsg's own "empty_is_a_group" (booleans.cpp), where the
+            // full reasoning and the OpenSCAD checks live.
+            const oscad::NodeKind k = geoNode->kind();
+            const int emptyIsAGroup = (
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground) ? 1 : 0;
+            out.push_back({Op::CsgGroupEnd, emptyIsAGroup, 0, nullptr});
         }
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
         out.push_back({Op::PopCsgWrap, idx, 0, &call.position()});

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/src/bytecode_vm.cpp

@@ -1311,7 +1311,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     // ITERATION child ctxs are pushed separately, by the
                     // compiled loop's own Op::ForIterNext.
                     ev.treeStack_.emplace_back();
-                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, 0});
+                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, {}, 0});
                     ++f.pc;
                     break;
                 }
@@ -1336,6 +1336,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, ctx);
                         pending.groupSizes.push_back(
                             Value{static_cast<double>(ev.treeStack_.back().size() - before)});
+                        // A spliced child is a plain statement, never a loop.
+                        pending.emptyIsAGroup.push_back(Value{false});
                     }
                     ++f.pc;
                     break;
@@ -1344,6 +1346,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
                     const size_t after = ev.treeStack_.back().size();
                     pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
+                    pending.emptyIsAGroup.push_back(Value{ins.a != 0});
                     ++f.pc;
                     break;
                 }
@@ -1367,6 +1370,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     if (site.includeOpParam) params["op"] = Value{pending.op};
                     params["group_sizes"] =
                         Value{std::make_shared<const ValueList>(ValueList{std::move(pending.groupSizes)})};
+                    params["empty_is_a_group"] = Value{std::make_shared<const ValueList>(
+                        ValueList{std::move(pending.emptyIsAGroup)})};
                     // Mirrors Evaluator::buildTreeNode's own post-
                     // resolveBody() half exactly (csg_resolve.cpp).
                     const bool uncacheable =

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/tests/test_booleans.cpp

@@ -40,11 +40,76 @@ TEST(Intersection, KeepsOnlyOverlappingVolume) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-6);
 }
 
-TEST(Intersection, DisabledStatementIsTrulyEmptyAndDiscardsResult) {
+TEST(Intersection, ADisabledStatementIsNotAnOperandAtAll) {
+    // `*cube(1)` produces no CSGNode, so it is not an operand -- the
+    // intersection has one child and returns it. This used to assert an
+    // EMPTY result on the reasoning that a statement contributing no bodies
+    // is "intersection with nothing"; checking against OpenSCAD showed that
+    // is wrong (it gives volume 8, the cube(2)), and the same mistake is
+    // what made BOSL2's hirth() render nothing at all: its geometry is
+    // `intersection(){ ...; if (crop) tube(...); }` and crop defaults false.
     Evaluated e = evalSrc("intersection() { cube(2); *cube(1); }");
-    // *cube(1) produces no CSGNode at all -> its "statement" contributes a
-    // group of size 0 -- flattening an empty group yields no bodies, which
-    // intersection() treats as "intersection with nothing" -> empty result.
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
+}
+
+TEST(Intersection, AnUntakenIfIsNotAnOperandEither) {
+    // The reported case, reduced. Verified against OpenSCAD: volume 1000.
+    Evaluated e = evalSrc("intersection() { cube(10); if (false) sphere(6); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
+    // Every row checked against OpenSCAD, not reasoned about. The rule that
+    // falls out: a module instantiation or a loop builds a node whatever it
+    // contains, so an empty one is an empty operand and annihilates; an
+    // `if` with no branch taken, a bare block and a `*`-disabled statement
+    // build no node at all and are not operands.
+    struct Case { const char* stmt; bool keepsTheCube; };
+    const Case cases[] = {
+        {"if (false) sphere(6);",            true},
+        {"{ }",                              true},
+        {"*cube(1);",                        true},
+        {"for (i = [1:0]) sphere(6);",       false},
+        {"union() { }",                      false},
+        {"group() { }",                      false},
+        {"let(x = 1) { }",                   false},
+        {"#union() { }",                     false},
+    };
+    for (const Case& c : cases) {
+        const std::string src =
+            std::string("intersection() { cube(10, center=true); ") + c.stmt + " }";
+        Evaluated e = evalSrc(src);
+        if (c.keepsTheCube) {
+            ASSERT_EQ(e.bodies.size(), 1u) << src;
+            EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6) << src;
+        } else {
+            const bool anyVolume = std::any_of(
+                e.bodies.begin(), e.bodies.end(),
+                [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+            EXPECT_FALSE(anyVolume) << src;
+        }
+    }
+}
+
+TEST(Intersection, AnEmptyUserModuleIsStillAnOperand) {
+    // The reference builds a node for a module instantiation whatever the
+    // module's body does, so calling one that draws nothing empties the
+    // intersection. Verified against OpenSCAD (writes no STL).
+    Evaluated e = evalSrc("module m() { } intersection() { cube(10); m(); }");
+    const bool anyVolume = std::any_of(
+        e.bodies.begin(), e.bodies.end(),
+        [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+    EXPECT_FALSE(anyVolume);
+}
+
+TEST(Intersection, AnEmptyForLoopIsStillAnOperand) {
+    // The one empty statement that DOES annihilate: the reference builds a
+    // group node for a for-loop however many times it iterates, so an empty
+    // one is an empty operand. Verified against OpenSCAD, which writes no
+    // STL at all for this.
+    Evaluated e = evalSrc("intersection() { cube(10); for (i = [1:0]) sphere(6); }");
     EXPECT_TRUE(e.bodies.empty());
 }
 
@@ -73,14 +138,19 @@ TEST(Union, MultipleBodiesInFirstStatementAllSurvive) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 20.0, 1e-6);
 }
 
-TEST(Intersection, EmptyFirstOperandGivesEmpty) {
+TEST(Intersection, ADisabledFirstStatementLetsTheNextOneLead) {
+    // Verified against OpenSCAD: volume 8, not empty.
     Evaluated e = evalSrc("intersection() { *cube(10); cube(2); }");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
-TEST(Difference, EmptyFirstOperandGivesEmpty) {
+TEST(Difference, ADisabledFirstStatementLetsTheNextOneBecomeTheBase) {
+    // Verified against OpenSCAD: volume 8 -- cube(2) becomes the base
+    // rather than the difference collapsing to nothing.
     Evaluated e = evalSrc("difference() { *cube(10); cube(2); }");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
 TEST(Difference, EmptySubtractorLeavesBaseUnchanged) {

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.4}/tests/test_control_flow.cpp

@@ -845,15 +845,15 @@ TEST(ExprEvalFunctionCall, CallingANonFunctionVariableWarnsAndIsUndef) {
     EXPECT_NE(warnings.back().find("Ignoring unknown function 'x'"), std::string::npos);
 }
 
-TEST(Intersection, EchoInDisabledFirstStatementStillFiresDespiteEmptyResult) {
-    // A deliberate resolve/generate-split consequence: resolve can't yet
-    // know the whole intersection() will end up geometrically empty (that
-    // isn't known until generate time), so echo()'s side effect during
-    // resolve still fires even though the final result has zero bodies.
+TEST(Intersection, EchoInADisabledStatementStillFires) {
+    // echo() runs during resolve, so its side effect happens whatever the
+    // geometry does. The result is the cube(2): neither the disabled
+    // statement nor the echo statement is an operand.
     std::string captured;
     Evaluated e = evalSrc("intersection() { *cube(10); echo(\"fired\"); cube(2); }", [&](const std::string& msg) { captured = msg; });
     EXPECT_EQ(captured, "ECHO: \"fired\"");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
 TEST(ListComprehension, IfClauseWithNestedListLiteralBody) {