openscad-cpp-evaluator 0.4.4__tar.gz → 0.4.5__tar.gz

{openscad_cpp_evaluator-0.4.4 → openscad_cpp_evaluator-0.4.5}/PKG-INFO

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

{openscad_cpp_evaluator-0.4.4 → openscad_cpp_evaluator-0.4.5}/include/openscad_cpp_evaluator/scope_trail.hpp

@@ -55,7 +55,25 @@ public:
     }
 
     void set(const std::string& name, T value, int level) {
-        stacks_[name].push_back(Entry{std::move(value), level});
+        std::vector<Entry>& vec = stacks_[name];
+        // A rebind of the SAME name at the level that's already current
+        // (a for-loop variable set every iteration without opening a new
+        // level each time, e.g. C-style for's init/incr -- see
+        // expr_eval.cpp's ListCompCFor case) overwrites the existing
+        // top-of-stack entry in place instead of pushing another one: a
+        // 999,999-iteration loop used to accumulate 999,999 Entry objects
+        // (and 999,999 duplicate name copies in dirty_[level]) that were
+        // never read again, all held until the level closed and popLevel()
+        // walked and popped every one of them in a single O(N) sweep.
+        // Nothing ever reads a stale same-level entry once a newer one at
+        // that same level exists (a level is one scope instantiation,
+        // never reopened), so this is a pure win, not just a memory
+        // optimization: it also collapses that O(N) unwind to O(1).
+        if (!vec.empty() && vec.back().level == level) {
+            vec.back().value = std::move(value);
+            return;
+        }
+        vec.push_back(Entry{std::move(value), level});
         dirty_[level].push_back(name);
     }
 
@@ -117,6 +135,17 @@ public:
 
     bool has(const std::string& name, int myLevel) const { return lookup(name, myLevel) != nullptr; }
 
+    // Test-only introspection: how many physical Entry objects exist for
+    // `name` (across every level, not just the current one) -- lets
+    // ScopeTrailStorageTest assert the same-level-overwrite optimization
+    // actually bounds growth (a for-loop variable set N times at one level
+    // should hold ~1 entry, not N), not just that lookup() still returns
+    // the right value either way.
+    size_t debugEntryCountForTesting(const std::string& name) const {
+        auto it = stacks_.find(name);
+        return it == stacks_.end() ? 0 : it->second.size();
+    }
+
     // Ancestry-filtered snapshot -- O(total distinct names ever bound so
     // far in the whole evaluation), not O(names visible now). Only used
     // by debug-REPL/children()-splice enumeration (never a hot path); see
@@ -258,7 +287,20 @@ public:
     void set(const std::string& name, T value, int level) {
         int id = intern_->idFor(name);
         ensureSize(id);
-        stacks_[static_cast<size_t>(id)].push_back(Entry{std::move(value), level});
+        std::vector<Entry>& vec = stacks_[static_cast<size_t>(id)];
+        // Same same-level-overwrite optimization as ScopeTrailStorage::set()
+        // -- see that one's doc comment for the full rationale. Applies
+        // here too: e.g. `$fn = 1; $fn = 2;` as sibling top-level
+        // statements share one level (evalChildren's per-statement
+        // EvalContext only swaps `scope`, aliasing the same trail/level --
+        // see EvalContext::withScope's own doc comment), so repeated
+        // same-block reassignment of a $-variable used to accumulate
+        // entries here exactly like a for-loop's plain variable did.
+        if (!vec.empty() && vec.back().level == level) {
+            vec.back().value = std::move(value);
+            return;
+        }
+        vec.push_back(Entry{std::move(value), level});
         dirty_[level].push_back(id);
     }
 
@@ -299,6 +341,12 @@ public:
 
     bool has(const std::string& name, int myLevel) const { return lookup(name, myLevel) != nullptr; }
 
+    // See ScopeTrailStorage::debugEntryCountForTesting's own doc comment.
+    size_t debugEntryCountForTesting(const std::string& name) const {
+        int id = intern_->idFor(name);
+        return id >= 0 && static_cast<size_t>(id) < stacks_.size() ? stacks_[static_cast<size_t>(id)].size() : 0;
+    }
+
     std::vector<std::pair<std::string, T>> items(int myLevel) const {
         std::vector<std::pair<std::string, T>> result;
         for (size_t id = 0; id < stacks_.size(); ++id) {

{openscad_cpp_evaluator-0.4.4 → openscad_cpp_evaluator-0.4.5}/pyproject.toml

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

{openscad_cpp_evaluator-0.4.4 → openscad_cpp_evaluator-0.4.5}/tests/CMakeLists.txt

@@ -10,6 +10,7 @@ FetchContent_MakeAvailable(googletest)
 add_executable(oscad_eval_tests
   test_value.cpp
   test_eval_context.cpp
+  test_scope_trail.cpp
   test_scoping.cpp
   test_bytecode_compiler.cpp
   test_expr_eval.cpp

openscad_cpp_evaluator-0.4.5/tests/test_scope_trail.cpp

@@ -0,0 +1,79 @@
+#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