openscad-cpp-evaluator 0.26.0__tar.gz → 0.27.0__tar.gz

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -223,6 +223,10 @@ public:
     // evaluate()/resolveTree()+generateTree() complete. Mirrors the
     // reference's Evaluator.id_to_node/id_to_color (also plain public
     // attributes there).
+    // Give cached bodies fresh originalIDs so a second call site reusing
+    // them is not confused with the first. See its definition.
+    void restampCachedIds(std::vector<ColoredBody>& bodies);
+
     std::unordered_map<uint32_t, const oscad::ASTNode*> idToNode;
     std::unordered_map<uint32_t, std::optional<std::array<float, 4>>> idToColor;
 

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/src/csg_generate.cpp

@@ -48,6 +48,7 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);
+            restampCachedIds(node.bodies);
         } else {
             // Recurse into children first (bottom-up) -- populates each
             // child's own .bodies in place so flattenCsgTree/a GenerateFn
@@ -104,6 +105,37 @@ std::vector<ColoredBody> Evaluator::generatePartialTree() {
     return generateTreeImpl(flat);
 }
 
+void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
+    // A cache hit hands back the geometry AND the originalIDs of whichever
+    // call site first produced it. Those IDs are provenance -- "which node
+    // made this" -- not content, so two identical shapes at two call sites
+    // came back sharing one identity and selecting either picked both.
+    //
+    // Each distinct run gets a fresh ID, one per run rather than one per
+    // body, so a cached subtree made of several parts stays selectable
+    // part by part. Each new ID inherits the old one's node and color, so
+    // the parts keep pointing at the AST nodes that really produced them.
+    for (ColoredBody& cb : bodies) {
+        if (!cb.body || cb.body->IsEmpty()) continue;
+        manifold::MeshGL mesh = cb.body->GetMeshGL();
+        if (mesh.runOriginalID.empty()) continue;
+        std::unordered_map<uint32_t, uint32_t> remap;
+        for (uint32_t& id : mesh.runOriginalID) {
+            auto found = remap.find(id);
+            if (found == remap.end()) {
+                const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
+                auto node = idToNode.find(id);
+                if (node != idToNode.end()) idToNode[fresh] = node->second;
+                auto color = idToColor.find(id);
+                if (color != idToColor.end()) idToColor[fresh] = color->second;
+                found = remap.emplace(id, fresh).first;
+            }
+            id = found->second;
+        }
+        cb.body = manifold::Manifold(mesh);
+    }
+}
+
 ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue) {
     manifold::MeshGL mesh = body.GetMeshGL();
     std::optional<std::array<float, 4>> color = valueToColor(colorValue);

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/src/debug_profile.cpp

@@ -9,9 +9,31 @@ namespace {
 // call), if any. See Evaluator::lastChildrenPositions()'s own doc comment
 // for what this feeds. Mirrors the reference's own
 // Evaluator._child_statement_positions.
-std::optional<std::vector<std::pair<std::string, int>>> childStatementPositions(const oscad::ASTNode& node) {
+// Where a debugger's "step into child" should aim from `node`.
+//
+// Normally the node's own children -- `framed(20) leaf(3);` aims at
+// `leaf(3)`. But a `children()` call has no children of its own: it
+// forwards the enclosing invocation's, which live on the context. Without
+// that case, stepping to a child from the one statement whose entire job
+// is to run the children found nothing to aim at, and the step silently
+// degraded into a continue -- running to the next breakpoint or off the
+// end of the script.
+std::optional<std::vector<std::pair<std::string, int>>> childStatementPositions(const oscad::ASTNode& node,
+                                                                                 const EvalContext& ctx) {
     if (node.kind() != oscad::NodeKind::ModularCall) return std::nullopt;
     const auto& call = static_cast<const oscad::ModularCall&>(node);
+    if (call.name && call.name->name == "children") {
+        if (!ctx.childrenNodes || ctx.childrenNodes->empty()) return std::nullopt;
+        std::vector<std::pair<std::string, int>> forwarded;
+        for (const oscad::ASTNode* c : *ctx.childrenNodes) {
+            if (c) forwarded.emplace_back(c->position().origin, c->position().line);
+        }
+        if (forwarded.empty()) return std::nullopt;
+        // Every forwarded child, even when an index argument (children(0),
+        // children([1:2])) will run only some: a position that is never
+        // reached can never be stopped at, so the extra targets are inert.
+        return forwarded;
+    }
     std::vector<std::pair<std::string, int>> positions;
     for (const auto& c : call.children) {
         if (c->kind() == oscad::NodeKind::Assignment || c->kind() == oscad::NodeKind::ModuleDeclaration ||
@@ -121,7 +143,7 @@ void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool fo
     }
     const int depth = static_cast<int>(callStack_.size());
     const DebugFramesFn getFrame = [this, &ctx]() { return buildDebugFrames(&ctx); };
-    lastChildrenPositions_ = childStatementPositions(node);
+    lastChildrenPositions_ = childStatementPositions(node, ctx);
 
     DebugAction action = debugHooks_.debugHook(pos.line, depth, forced, exprLevel, pos.origin, callStack_, getFrame);
     for (auto& [k, v] : action.mods) ctx.let_->set(k, v);

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/tests/test_debug_hooks.cpp

@@ -641,6 +641,46 @@ TEST(DebugHooksParity, CallSiteOnItsOwnLineStillStops) {
     EXPECT_EQ(line4, 2);
 }
 
+// Step-into-child aims at the children a `children()` call forwards, not
+// at its own (it has none). Without this, the one statement whose entire
+// job is to run the children offered a debugger nothing to aim at, and the
+// step degraded into a continue -- running off the end of the script.
+TEST(DebugHooksChildren, ChildrenCallForwardsItsCallersChildrenAsStepTargets) {
+    // Line 5 is the child; line 2 is the `children();` that forwards it.
+    const char* src = "module framed(gap) {\n"
+                      "    children();\n"
+                      "}\n"
+                      "framed(20)\n"
+                      "    leaf();\n"
+                      "module leaf() { cube(1); }\n";
+    std::vector<std::pair<int, std::vector<std::pair<std::string, int>>>> seen;
+    DebugHooks hooks;
+    Evaluator* evp = nullptr;
+    hooks.debugHook = [&](int line, int, bool, bool exprLevel, const std::string&,
+                           const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        if (!exprLevel && evp && evp->lastChildrenPositions())
+            seen.emplace_back(line, *evp->lastChildrenPositions());
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    evp = &ev;
+    auto ast = parseSrc(src);
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+
+    // At `children();` on line 2, the target is the forwarded child on
+    // line 5 -- not nothing, and not the children() call's own position.
+    bool found = false;
+    for (const auto& [line, positions] : seen) {
+        if (line != 2) continue;
+        found = true;
+        ASSERT_EQ(positions.size(), 1u);
+        EXPECT_EQ(positions.front().second, 5);
+    }
+    EXPECT_TRUE(found) << "no statement-level stop at the children() call";
+}
+
 TEST(DebugHooksParity, BuiltinFunctionCallGetsNoCallSiteStop) {
     // Only the assignment is statement-level; the 3 expr-level stops are
     // the argument list literal's own elements, not a call-site stop.

{openscad_cpp_evaluator-0.26.0 → openscad_cpp_evaluator-0.27.0}/tests/test_manifold_cache.cpp

@@ -5,7 +5,10 @@
 #include "test_helpers.hpp"
 
 #include <gtest/gtest.h>
+#include <algorithm>
+#include <iterator>
 #include <numbers>
+#include <set>
 
 using namespace oscadeval;
 using namespace oscadeval::test;
@@ -156,6 +159,54 @@ TEST(ManifoldCache, UncacheableNodeAlwaysRegeneratesNeverHitsOrPopulatesCache) {
     EXPECT_FALSE(second.ev.idToNode.empty());
 }
 
+// A cache hit must not hand back the originalIDs of whichever call site
+// first produced the geometry. Those IDs are provenance, and sharing them
+// made two identical shapes one thing to a UI: selecting either picked
+// both. Common in CAD, where arrays of identical parts are the norm.
+TEST(ManifoldCache, IdenticalShapesAtDifferentCallSitesGetDistinctOriginalIds) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "translate([0,0,0]) cylinder(h=20,r=4,$fn=32);\n"
+        "translate([25,0,0]) cylinder(h=20,r=4,$fn=32);\n", cache);
+    ASSERT_EQ(e.bodies.size(), 2u);
+
+    // Held in locals: GetMeshGL() returns by value, so taking begin() and
+    // end() from two separate calls walks between unrelated buffers.
+    const manifold::MeshGL meshA = e.bodies[0].body->GetMeshGL();
+    const manifold::MeshGL meshB = e.bodies[1].body->GetMeshGL();
+    const std::set<uint32_t> first(meshA.runOriginalID.begin(), meshA.runOriginalID.end());
+    const std::set<uint32_t> second(meshB.runOriginalID.begin(), meshB.runOriginalID.end());
+    ASSERT_FALSE(first.empty());
+    ASSERT_FALSE(second.empty());
+    std::vector<uint32_t> shared;
+    std::set_intersection(first.begin(), first.end(), second.begin(), second.end(),
+                           std::back_inserter(shared));
+    EXPECT_TRUE(shared.empty()) << "the two cylinders share an originalID";
+
+    // Both still resolve to a node, so re-stamping does not lose the
+    // mapping selection needs.
+    for (uint32_t id : first) EXPECT_EQ(e.ev.idToNode.count(id), 1u);
+    for (uint32_t id : second) EXPECT_EQ(e.ev.idToNode.count(id), 1u);
+}
+
+// Re-stamping is per run, not per body, so a cached subtree made of
+// several parts stays selectable part by part rather than collapsing into
+// one -- which is what Manifold's own AsOriginal() would have done.
+TEST(ManifoldCache, ACachedMultiPartSubtreeKeepsOneIdPerPart) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "module pair() { cube(2); translate([5,0,0]) sphere(1,$fn=8); }\n"
+        "pair();\n"
+        "translate([0,20,0]) pair();\n", cache);
+    ASSERT_EQ(e.bodies.size(), 4u);
+    std::set<uint32_t> all;
+    for (const ColoredBody& b : e.bodies) {
+        const manifold::MeshGL mesh = b.body->GetMeshGL();
+        for (uint32_t id : mesh.runOriginalID) all.insert(id);
+    }
+    EXPECT_EQ(all.size(), 4u) << "parts of the reused subtree share IDs";
+}
+
 TEST(ManifoldCache, OutputIsIdenticalCacheOnVsCacheOffAcrossBuiltinCategories) {
     const std::vector<std::string> scripts = {
         "cube(3);",