openscad-cpp-evaluator 0.55.0__tar.gz → 0.55.1__tar.gz

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/CLAUDE.md

@@ -699,6 +699,17 @@ grep for `ponytail:`.
   permanent cache miss for any subtree that called `rands()` while resolving, since such a
   subtree's resolved params aren't a pure function of its own content anymore (the actual `rands()`
   output also depends on every earlier `rands()` call's position in the whole evaluation's order).
+  A second, separate taint — `CSGNode::keyHasClosure`, set by `cacheKey()` itself rather than at
+  resolve time — does the same for any subtree holding a **function literal** in its params (the
+  `levelset(function (x,y,z) ..., ...)` shape). `canonValue()` can only key a closure by its AST
+  node's raw address, which is meaningful for exactly one parse: the next render frees that AST and
+  a fresh closure over *different* captured values can be allocated at the very same address, so
+  the key silently hits the previous render's geometry — the GUI symptom was an edited script
+  rendering its **old** shape until saved a second time. (The address also ignores the captured
+  values themselves, so two closures over one literal collide within a single render, which is what
+  `tests/test_manifold_cache.cpp` pins down deterministically.) Keying a closure honestly means
+  canonicalizing its captured `let_` trail, which is type-erased (`Closure::capturedLet` is a
+  `shared_ptr<void>`); until that exists such a subtree simply does not participate in the cache.
   Builtins are registered in `src/builtins/registry.cpp` as `(name string) -> (ResolveFn,
   GenerateFn)` pairs — `dispatch.hpp` has the exact reasoning for `GenerateFn`'s `Evaluator&`
   parameter (provenance-table writes only, no `EvalContext`/dynamic-scope access, so the

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -72,6 +72,21 @@ struct CSGNode {
     // on first cacheKey() call; every node here is always reached through a
     // non-const CSGNode&, so no `mutable` is needed to write it.
     std::optional<std::string> cachedKey;
+
+    // Set by the same cacheKey() pass that fills cachedKey: true if this
+    // node's own params, or any descendant's, hold a function literal.
+    //
+    // canonValue() can only key a closure by its AST node's raw address,
+    // and that address is meaningful for exactly one parse: the next
+    // render frees that AST, and a fresh closure over different captured
+    // values can be allocated at the very same address -- so the key
+    // silently hits the PREVIOUS render's geometry. (It also ignores the
+    // captured values themselves, so two closures over one literal share a
+    // key within a single render.) Keying a closure honestly would mean
+    // canonicalising its captured `let_` trail, which is type-erased; until
+    // that exists, such a subtree just does not participate in the cache.
+    // See csg_generate.cpp's lookup.
+    bool keyHasClosure = false;
 };
 
 

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/pyproject.toml

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

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/src/csg_generate.cpp

@@ -44,7 +44,15 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         // re-deriving results that would just be discarded. Mirrors
         // generate_tree()'s own cache check exactly.
         std::optional<std::string> key;
-        if (manifoldCache_ && !node.uncacheable) key = cacheKey(node);
+        if (manifoldCache_ && !node.uncacheable) {
+            key = cacheKey(node);
+            // A key that serialized a function literal is not a pure
+            // function of content -- it embeds a raw AST address that the
+            // next parse can hand out again. Dropping the key here forces
+            // both the get() below and the put() further down to be
+            // skipped. See CSGNode::keyHasClosure.
+            if (node.keyHasClosure) key.reset();
+        }
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/src/manifold_cache.cpp

@@ -93,6 +93,32 @@ std::string canonValue(const Value& v) {
         v);
 }
 
+// True if `v` is a function literal, or a list/object holding one at any
+// depth. Drives CSGNode::keyHasClosure -- see its doc comment for why a
+// closure cannot be keyed.
+bool valueHasClosure(const Value& v) {
+    return std::visit(
+        [](const auto& val) -> bool {
+            using T = std::decay_t<decltype(val)>;
+            if constexpr (std::is_same_v<T, ClosurePtr>) {
+                return true;
+            } else if constexpr (std::is_same_v<T, ListPtr>) {
+                if (!val) return false;
+                for (const Value& item : val->items)
+                    if (valueHasClosure(item)) return true;
+                return false;
+            } else if constexpr (std::is_same_v<T, ObjectPtr>) {
+                if (!val) return false;
+                for (const auto& [k, vv] : val->items)
+                    if (valueHasClosure(vv)) return true;
+                return false;
+            } else {
+                return false;
+            }
+        },
+        v);
+}
+
 std::string canonParams(const CSGParams& params) {
     std::vector<std::pair<std::string, std::string>> entries;
     entries.reserve(params.size());
@@ -120,13 +146,24 @@ std::string canonParams(const CSGParams& params) {
 std::string cacheKey(CSGNode& node) {
     if (node.cachedKey) return *node.cachedKey;
 
+    bool hasClosure = false;
+    for (const auto& [k, v] : node.params) {
+        if (valueHasClosure(v)) { hasClosure = true; break; }
+    }
+
     std::string out = "N(";
     appendLenPrefixed(out, node.kind);
     out += node.isBuiltin ? "1" : "0";
     appendLenPrefixed(out, canonParams(node.params));
     out += std::to_string(node.children.size()) + "[";
-    for (const auto& c : node.children) appendLenPrefixed(out, cacheKey(*c));
+    for (const auto& c : node.children) {
+        appendLenPrefixed(out, cacheKey(*c));
+        // A closure anywhere below poisons this key too: it is built from
+        // the children's keys.
+        hasClosure = hasClosure || c->keyHasClosure;
+    }
     out += "])";
+    node.keyHasClosure = hasClosure;
     node.cachedKey = out;
     return *node.cachedKey;
 }

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.1}/tests/test_manifold_cache.cpp

@@ -121,6 +121,65 @@ TEST(ManifoldCacheUncacheable, RandsBeforeGeometryInModuleBodyTaintsSplicedSibli
     EXPECT_TRUE(e.tree[0]->uncacheable);
 }
 
+// -- closure taint ---------------------------------------------------------
+
+TEST(ManifoldCacheClosure, PlainNodeHasNoClosureTaint) {
+    Evaluated e = evalSrc("cube(5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_FALSE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, FunctionLiteralParamTaintsTheNode) {
+    Evaluated e = evalSrc(
+        "levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, TaintPropagatesUpThroughATransform) {
+    // The parent's key is built from the child's, so a closure below is
+    // just as unusable there.
+    Evaluated e = evalSrc(
+        "translate([1,0,0]) levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    EXPECT_EQ(e.tree[0]->kind, "translate");
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+// The bug this taint exists for, at full size: both closures come from the
+// SAME function literal (so canonValue's "F<pointer>" is byte-identical)
+// but capture different `r`. Every other cache-key input matches too, so
+// before the taint the second levelset() was served the first one's
+// geometry and both spheres came out radius 10.
+//
+// Deterministic on purpose: one evaluation, one AST, so the two closures
+// genuinely share a node address rather than relying on the allocator
+// handing back a freed one.
+TEST(ManifoldCacheClosure, TwoClosuresOverOneLiteralAreNotServedEachOthersGeometry) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "function mk(r) = function (x,y,z) x*x+y*y+z*z-r*r;\n"
+        "levelset(mk(10), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n"
+        "translate([40,0,0])\n"
+        "  levelset(mk(5), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n",
+        cache);
+
+    ASSERT_EQ(e.bodies.size(), 2u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    ASSERT_TRUE(e.bodies[1].body.has_value());
+    const double volBig = e.bodies[0].body->Volume();
+    const double volSmall = e.bodies[1].body->Volume();
+    // Coarse sampling, so compare the two against each other rather than
+    // against 4/3*pi*r^3: r=10 vs r=5 is an 8x volume ratio.
+    EXPECT_GT(volBig, 2.0 * volSmall)
+        << "the second closure was served the first one's cached geometry";
+}
+
 // -- cache reuse -----------------------------------------------------------
 
 TEST(ManifoldCache, CacheHitSkipsRegeneratingTheSubtree) {