openscad-cpp-evaluator 0.4.8__tar.gz → 0.4.9__tar.gz

{openscad_cpp_evaluator-0.4.8 → openscad_cpp_evaluator-0.4.9}/PKG-INFO

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

{openscad_cpp_evaluator-0.4.8 → openscad_cpp_evaluator-0.4.9}/include/openscad_cpp_evaluator/scope_trail.hpp

@@ -79,18 +79,46 @@ public:
 
     // Pops every entry pushed at `level`, across every name that was
     // touched at that level (dirty_[level], recorded by set() above) --
-    // O(bindings made at this level), not O(total names). Left-in-place,
-    // possibly-now-empty per-name vectors are NOT erased from `stacks_`:
-    // ponytail: real scripts rebind the same small name set repeatedly
-    // (loop vars, $fn, ...), so paying one erase+reinsert per pop is pure
-    // waste; revisit only if memory footprint (not speed) ever measurably
-    // matters for a script with a huge, non-repeating variable vocabulary.
+    // O(bindings made at this level) in the common case, not O(total
+    // names). Left-in-place, possibly-now-empty per-name vectors are NOT
+    // erased from `stacks_`: ponytail: real scripts rebind the same small
+    // name set repeatedly (loop vars, $fn, ...), so paying one
+    // erase+reinsert per pop is pure waste; revisit only if memory
+    // footprint (not speed) ever measurably matters for a script with a
+    // huge, non-repeating variable vocabulary.
+    //
+    // Removes the entry matching THIS level specifically, not just
+    // whatever's currently last -- these can differ once an escaping
+    // closure is in play (TrailView::parentView_, see its own doc
+    // comment): a closure can keep one ancestor level alive well past its
+    // own natural (LIFO, call/return-order) lifetime, while an EARLIER,
+    // otherwise-unrelated level that happens to touch the same NAME pops
+    // normally in the meantime. If that earlier level's own entry is no
+    // longer physically last in `vec` (the kept-alive later one is still
+    // sitting on top), a blind pop_back() would silently remove the WRONG
+    // entry -- the still-live, captured one, not the one actually being
+    // popped. Caught by a real repro: `function make(x,table)=
+    // let(table=...) x!=undef? make(table=table)(v=x) : function(v)
+    // v!=undef? let(nt=concat(table,[v])) make(table=nt) : table;` --
+    // invoking the returned closure read undef for a `table` that was
+    // bound directly at the closure's OWN captured level (not even an
+    // ancestor hop away), because an unrelated, earlier `table` push from
+    // a sibling recursive call got popped out of order and silently ate
+    // it. Scans from the back (the common case -- this level's own push
+    // usually IS at or near the top) rather than assuming position 0.
     void popLevel(int level) {
         auto it = dirty_.find(level);
         if (it != dirty_.end()) {
             for (const std::string& name : it->second) {
                 auto sit = stacks_.find(name);
-                if (sit != stacks_.end() && !sit->second.empty()) sit->second.pop_back();
+                if (sit == stacks_.end()) continue;
+                std::vector<Entry>& vec = sit->second;
+                for (auto rit = vec.rbegin(); rit != vec.rend(); ++rit) {
+                    if (rit->level == level) {
+                        vec.erase(std::next(rit).base());
+                        break;
+                    }
+                }
             }
             dirty_.erase(it);
         }
@@ -191,7 +219,7 @@ private:
 // allocations each down to 4 trails * 1) with no change to the
 // ancestry-walk/isolation logic itself.
 template <typename T>
-class TrailView {
+class TrailView : public std::enable_shared_from_this<TrailView<T>> {
 public:
     static std::shared_ptr<TrailView<T>> makeRoot() {
         auto storage = std::make_shared<ScopeTrailStorage<T>>();
@@ -206,9 +234,36 @@ public:
     // chain through this view's own level (childCtx()/letChildCtx() --
     // reads see through to the caller's own bindings, while only this
     // scope's own writes get popped away on exit).
+    //
+    // The child also holds a shared_ptr back to THIS view (parentView_,
+    // isolate=false only) -- not just the ancestor level NUMBER already
+    // tracked in ScopeTrailStorage::parent_. Ancestry-chain VISIBILITY
+    // (lookup()'s walk) only needs the number; but an escaping closure
+    // (Closure::capturedLet, value.hpp) keeps exactly one TrailView alive
+    // past its own scope's normal exit by holding an extra shared_ptr
+    // reference to it -- and that view is very often an intermediate
+    // level (e.g. a let()'s own child level, one hop below the call level
+    // that actually bound the captured variable, see EvalContext::
+    // letChildCtx()), not the outermost one. Without parentView_, nothing
+    // keeps that OUTER level's own TrailView alive once its own creating
+    // call returns; ~TrailView() pops ITS bindings from ScopeTrailStorage
+    // (erasing the very data the still-alive child's ancestry walk needs)
+    // even though the walk can still numerically reach that ancestor level
+    // via ScopeTrailStorage::parent_ (that map entry is untouched -- only
+    // the DATA is gone). Caught by a closure created inside a let()
+    // nested one level inside its own enclosing call reading undef for a
+    // variable bound at the call's own (now-popped) level, not the let()'s
+    // (kept alive) one. Holding parentView_ makes keeping a leaf level
+    // alive transitively keep its whole ancestor chain's data alive too,
+    // cascading in the same reverse-of-creation order an ordinary nested
+    // call/return already unwinds in (member destruction order below), so
+    // normal (non-escaping) scopes pop exactly as before -- this only
+    // changes what happens when something holds an EXTRA reference.
     std::shared_ptr<TrailView<T>> openChild(bool isolate) const {
         int level = storage_->openLevel(isolate ? 0 : level_);
-        return std::make_shared<TrailView<T>>(storage_, level);
+        auto child = std::make_shared<TrailView<T>>(storage_, level);
+        if (!isolate) child->parentView_ = this->shared_from_this();
+        return child;
     }
 
     TrailView(std::shared_ptr<ScopeTrailStorage<T>> storage, int level)
@@ -233,6 +288,15 @@ public:
 private:
     std::shared_ptr<ScopeTrailStorage<T>> storage_;
     int level_;
+    // Declared LAST so it's destroyed FIRST (reverse declaration order),
+    // i.e. immediately after ~TrailView()'s own body (which pops THIS
+    // view's own level) -- releasing (and, if this was the last
+    // reference, cascading into) the parent's own pop right away, in the
+    // same order a normal nested call/return already unwinds in. `const`:
+    // openChild() is itself const, so shared_from_this() resolves to the
+    // const overload -- only lifetime-extension is needed here, never
+    // mutation through this pointer.
+    std::shared_ptr<const TrailView<T>> parentView_;
 };
 
 // Shared bidirectional name<->small-int interning table for $-prefixed

{openscad_cpp_evaluator-0.4.8 → openscad_cpp_evaluator-0.4.9}/pyproject.toml

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

openscad_cpp_evaluator-0.4.9/tests/test_scope_trail.cpp

@@ -0,0 +1,151 @@
+#include "openscad_cpp_evaluator/scope_trail.hpp"
+
+#include <gtest/gtest.h>
+
+namespace oscadeval {
+namespace {
+
+TEST(ScopeTrailStorage, SetAtSameLevelOverwritesLatestValue) {
+    ScopeTrailStorage<int> storage;
+    const int level = storage.openLevel(0);
+    storage.set("i", 1, level);
+    storage.set("i", 2, level);
+    storage.set("i", 3, level);
+    ASSERT_NE(storage.lookup("i", level), nullptr);
+    EXPECT_EQ(*storage.lookup("i", level), 3);
+}
+
+TEST(ScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
+    // The actual optimization this session added: repeated set() calls at
+    // the SAME level (a for-loop variable rebound every iteration without
+    // opening a new level, or sibling same-block statements reassigning
+    // the same name) must overwrite in place, not grow the underlying
+    // stack -- verified via the test-only accessor, since correctness
+    // alone (SetAtSameLevelOverwritesLatestValue above) can't distinguish
+    // "overwrote in place" from "pushed and lookup() happens to find the
+    // newest one anyway."
+    ScopeTrailStorage<int> storage;
+    const int level = storage.openLevel(0);
+    for (int i = 0; i < 1000; ++i) storage.set("i", i, level);
+    EXPECT_EQ(storage.debugEntryCountForTesting("i"), 1u);
+}
+
+TEST(ScopeTrailStorage, SetAtANewLevelStillPushes) {
+    // The optimization must not collapse GENUINE nested bindings -- a
+    // child level's own set() for the same name is a real new binding
+    // (must be poppable back to the parent's value), not a same-level
+    // rebind.
+    ScopeTrailStorage<int> storage;
+    const int parentLevel = storage.openLevel(0);
+    storage.set("x", 1, parentLevel);
+    const int childLevel = storage.openLevel(parentLevel);
+    storage.set("x", 2, childLevel);
+    EXPECT_EQ(storage.debugEntryCountForTesting("x"), 2u);
+    ASSERT_NE(storage.lookup("x", childLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("x", childLevel), 2);
+    storage.popLevel(childLevel);
+    ASSERT_NE(storage.lookup("x", parentLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("x", parentLevel), 1);
+}
+
+TEST(ScopeTrailStorage, PopLevelAfterManySameLevelSetsRestoresParentValue) {
+    // The end-to-end correctness case a for-loop actually exercises: many
+    // same-level rebinds of the loop variable, then the level closes
+    // (loop exits) -- the parent's own binding for that name (if any) must
+    // resurface untouched, and the now-closed level's value must not leak.
+    ScopeTrailStorage<int> storage;
+    const int parentLevel = storage.openLevel(0);
+    storage.set("i", -1, parentLevel);
+    const int loopLevel = storage.openLevel(parentLevel);
+    for (int i = 0; i < 999; ++i) storage.set("i", i, loopLevel);
+    ASSERT_NE(storage.lookup("i", loopLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("i", loopLevel), 998);
+    storage.popLevel(loopLevel);
+    ASSERT_NE(storage.lookup("i", parentLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("i", parentLevel), -1);
+}
+
+TEST(IndexedScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
+    auto intern = std::make_shared<DynNameIntern>();
+    IndexedScopeTrailStorage<int> storage(intern);
+    const int level = storage.openLevel(0);
+    for (int i = 0; i < 1000; ++i) storage.set("$fn", i, level);
+    EXPECT_EQ(storage.debugEntryCountForTesting("$fn"), 1u);
+    ASSERT_NE(storage.lookup("$fn", level), nullptr);
+    EXPECT_EQ(*storage.lookup("$fn", level), 999);
+}
+
+// A captured (closure) level's own ancestor must stay alive even after
+// EVERY other TrailView referencing that ancestor has gone out of scope --
+// see TrailView::openChild's own doc comment (parentView_) for why. This
+// reproduces the exact level shape a real escaping-closure scenario builds
+// (traced from `function make(x,table)=let(table=...) x!=undef?
+// make(table=table)(v=x) : function(v) v!=undef?
+// let(nt=concat(table,[v])) make(table=nt) : table;`), with each C++ scope
+// block standing in for one step of Evaluator::evalFunctionBodyTrampoline's
+// own `chain` vector going out of scope once its owning call returns:
+//   1) M1_CALL (isolated call level for the outer make(10))
+//   2) M1_LET  (its own let(table=...) child level)
+//   3) M2_CALL (a NESTED, non-tail recursive make(table=table) call --
+//      isolated, since callCtxFor's sameSpan check correctly refuses to
+//      treat same-function recursion as "still nested")
+//   4) M2_LET  (that call's own let(table=...))
+//   5) C1_CALL (capturedLet-rooted: invoking the closure captured at
+//      M2_LET, continuing ITS ancestry rather than the caller's)
+//   6) C1_LET  (that invocation's own let(newtable=...))
+//   7) M3_CALL (a SECOND tail-hop into the NAMED function make(table=
+//      newtable) -- also isolated, not capturedLet-based)
+//   8) M3_LET  (that hop's own let(table=...) -- this is the level the
+//      SECOND closure, C2, actually captures)
+// After every one of 1-8 goes out of scope except the shared_ptr a
+// "Closure" would hold (mirroring M3_LET, i.e. what capturedLet points
+// to), invoking that closure must still resolve `table` -- bound all the
+// way back at M3_LET itself, so this specific case doesn't even need to
+// walk past one level, but the SURROUNDING chain (steps 1-7) must not have
+// corrupted or blocked that walk on its own way out.
+TEST(TrailView, EscapingClosureThroughDoubleTailHopStillSeesAncestorAfterChainUnwinds) {
+    std::shared_ptr<TrailView<int>> capturedLet;
+    {
+        auto root = TrailView<int>::makeRoot();
+        auto m1Call = root->openChild(/*isolate=*/true);
+        m1Call->set("x", 10);
+        auto m1Let = m1Call->openChild(/*isolate=*/false);
+        m1Let->set("table", 123);
+        auto m2Call = m1Let->openChild(/*isolate=*/true);
+        m2Call->set("table", 123);
+        auto m2Let = m2Call->openChild(/*isolate=*/false);
+        m2Let->set("table", 123);
+        auto c1Call = m2Let->openChild(/*isolate=*/false);
+        c1Call->set("v", 10);
+        auto c1Let = c1Call->openChild(/*isolate=*/false);
+        c1Let->set("newtable", 1230);
+        auto m3Call = c1Let->openChild(/*isolate=*/true);
+        m3Call->set("table", 1230);
+        auto m3Let = m3Call->openChild(/*isolate=*/false);
+        m3Let->set("table", 1230);
+        capturedLet = m3Let;
+    } // every level above except capturedLet's own (m3Let) goes out of scope here
+
+    auto c2Call = capturedLet->openChild(/*isolate=*/false);
+    ASSERT_NE(c2Call->find("table"), nullptr);
+    EXPECT_EQ(*c2Call->find("table"), 1230);
+}
+
+TEST(TrailView, MinimalTwoLevelKeepAlive) {
+    std::shared_ptr<TrailView<int>> captured;
+    {
+        auto root = TrailView<int>::makeRoot();
+        auto parent = root->openChild(/*isolate=*/true);
+        parent->set("x", 42);
+        auto child = parent->openChild(/*isolate=*/false);
+        captured = child;
+    }
+    auto grandchild = captured->openChild(/*isolate=*/false);
+    ASSERT_NE(grandchild->find("x"), nullptr);
+    EXPECT_EQ(*grandchild->find("x"), 42);
+}
+
+} // namespace
+} // namespace oscadeval
+
+

openscad_cpp_evaluator-0.4.8/tests/test_scope_trail.cpp

@@ -1,79 +0,0 @@
-#include "openscad_cpp_evaluator/scope_trail.hpp"
-
-#include <gtest/gtest.h>
-
-namespace oscadeval {
-namespace {
-
-TEST(ScopeTrailStorage, SetAtSameLevelOverwritesLatestValue) {
-    ScopeTrailStorage<int> storage;
-    const int level = storage.openLevel(0);
-    storage.set("i", 1, level);
-    storage.set("i", 2, level);
-    storage.set("i", 3, level);
-    ASSERT_NE(storage.lookup("i", level), nullptr);
-    EXPECT_EQ(*storage.lookup("i", level), 3);
-}
-
-TEST(ScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
-    // The actual optimization this session added: repeated set() calls at
-    // the SAME level (a for-loop variable rebound every iteration without
-    // opening a new level, or sibling same-block statements reassigning
-    // the same name) must overwrite in place, not grow the underlying
-    // stack -- verified via the test-only accessor, since correctness
-    // alone (SetAtSameLevelOverwritesLatestValue above) can't distinguish
-    // "overwrote in place" from "pushed and lookup() happens to find the
-    // newest one anyway."
-    ScopeTrailStorage<int> storage;
-    const int level = storage.openLevel(0);
-    for (int i = 0; i < 1000; ++i) storage.set("i", i, level);
-    EXPECT_EQ(storage.debugEntryCountForTesting("i"), 1u);
-}
-
-TEST(ScopeTrailStorage, SetAtANewLevelStillPushes) {
-    // The optimization must not collapse GENUINE nested bindings -- a
-    // child level's own set() for the same name is a real new binding
-    // (must be poppable back to the parent's value), not a same-level
-    // rebind.
-    ScopeTrailStorage<int> storage;
-    const int parentLevel = storage.openLevel(0);
-    storage.set("x", 1, parentLevel);
-    const int childLevel = storage.openLevel(parentLevel);
-    storage.set("x", 2, childLevel);
-    EXPECT_EQ(storage.debugEntryCountForTesting("x"), 2u);
-    ASSERT_NE(storage.lookup("x", childLevel), nullptr);
-    EXPECT_EQ(*storage.lookup("x", childLevel), 2);
-    storage.popLevel(childLevel);
-    ASSERT_NE(storage.lookup("x", parentLevel), nullptr);
-    EXPECT_EQ(*storage.lookup("x", parentLevel), 1);
-}
-
-TEST(ScopeTrailStorage, PopLevelAfterManySameLevelSetsRestoresParentValue) {
-    // The end-to-end correctness case a for-loop actually exercises: many
-    // same-level rebinds of the loop variable, then the level closes
-    // (loop exits) -- the parent's own binding for that name (if any) must
-    // resurface untouched, and the now-closed level's value must not leak.
-    ScopeTrailStorage<int> storage;
-    const int parentLevel = storage.openLevel(0);
-    storage.set("i", -1, parentLevel);
-    const int loopLevel = storage.openLevel(parentLevel);
-    for (int i = 0; i < 999; ++i) storage.set("i", i, loopLevel);
-    ASSERT_NE(storage.lookup("i", loopLevel), nullptr);
-    EXPECT_EQ(*storage.lookup("i", loopLevel), 998);
-    storage.popLevel(loopLevel);
-    ASSERT_NE(storage.lookup("i", parentLevel), nullptr);
-    EXPECT_EQ(*storage.lookup("i", parentLevel), -1);
-}
-
-TEST(IndexedScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
-    auto intern = std::make_shared<DynNameIntern>();
-    IndexedScopeTrailStorage<int> storage(intern);
-    const int level = storage.openLevel(0);
-    for (int i = 0; i < 1000; ++i) storage.set("$fn", i, level);
-    EXPECT_EQ(storage.debugEntryCountForTesting("$fn"), 1u);
-    ASSERT_NE(storage.lookup("$fn", level), nullptr);
-    EXPECT_EQ(*storage.lookup("$fn", level), 999);
-}
-
-} // namespace
-} // namespace oscadeval