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

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

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

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

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

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.4.10}/src/bytecode_compiler.cpp

@@ -676,6 +676,27 @@ public:
                     int slot = declareLocal(scope, assign->name->name);
                     out.push_back({Op::StoreLocal, slot, 0, &assign->position()});
                 }
+                // Pre-declare every incr-list name NOW, before compiling the
+                // condition/body/incr expressions below -- an incr name
+                // introduced fresh (not in the init list, e.g. BOSL2's
+                // skin.scad: `best_i = result[0]<bestcost ? i : best_i,`)
+                // can be READ, including by its OWN incr assignment's RHS
+                // (a self-reference to its prior iteration's value) or by
+                // the loop body, before its OWN StoreLocal below would
+                // otherwise have declared it. Without this, that read
+                // compiles to Op::LoadFree (the "not a known local/upvalue/
+                // dyn-var, might be dynamic, warn if truly missing"
+                // fallback) -- permanently, since compilation happens once
+                // but the resulting instruction runs every iteration: every
+                // read silently misses the real value stored into the
+                // local slot moments later at runtime, not just an extra
+                // warning but a genuinely wrong result (confirmed: BOSL2's
+                // own best_i accumulator came back undef on every read).
+                // Declaring the slot here first means the SAME reads below
+                // resolve as ordinary Op::LoadLocal instead.
+                for (const auto& assign : n.incrs) {
+                    if (!scope.resolve(assign->name->name)) declareLocal(scope, assign->name->name);
+                }
                 int counterSlot = nextSlot_++;
                 out.push_back({Op::PushConst, internConst(Value{0.0}), 0, nullptr});
                 out.push_back({Op::StoreLocal, counterSlot, 0, nullptr});

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.4.10}/src/bytecode_vm.cpp

@@ -40,6 +40,16 @@ private:
 struct IterList {
     IterableValues values;
     size_t index = 0;
+    // Cached once at IterMaterialize time -- IterableValues::size() is O(1)
+    // for a list/owned vector, but walks a RANGE's whole sequence from
+    // scratch every call (its own doc comment: "no caller in this codebase
+    // actually calls size() on a range today" -- Op::IterNext, below, used
+    // to be exactly that stale caller). Recomputing it once per IterNext
+    // call turned a single range-based for()/list-comp `for` into an O(n^2)
+    // walk (a 100,000-element range: interpreter ~0.03s, VM ~9.5s) -- caught
+    // via a BOSL2 corpus sweep (test_math.scadtest's own gaussian_rands(),
+    // which builds a 100,000-element list via `count()`).
+    size_t total = 0;
 };
 
 // Shared by Op::CallFn's isBuiltin (evalBuiltinFunction) and isImport
@@ -244,6 +254,7 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                     ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", ins.pos);
                 });
                 il.index = 0;
+                il.total = il.values.size(); // once here, never per-iteration -- see IterList's own doc comment
                 ++pc;
                 break;
             }
@@ -254,7 +265,7 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
             }
             case Op::IterNext: {
                 IterList& il = iterLists[static_cast<size_t>(ins.b)];
-                if (il.index < il.values.size()) {
+                if (il.index < il.total) {
                     slots[static_cast<size_t>(ins.a)] = il.values[il.index];
                     ++il.index;
                     ++pc;

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.4.10}/tests/test_bytecode_compiler.cpp

@@ -4,6 +4,7 @@
 
 #include "test_helpers.hpp"
 
+#include <chrono>
 #include <filesystem>
 #include <fstream>
 #include <gtest/gtest.h>
@@ -721,3 +722,58 @@ TEST(BytecodeCompiler, VmOffAndVmOnAgreeOnEchoAssertImportObjectCases) {
     EXPECT_EQ(offResult, onResult);
     std::filesystem::remove(path);
 }
+
+TEST(BytecodeCompiler, RangeBasedForListCompDoesNotReMaterializeRangeSizePerIteration) {
+    ScopedVm vm(true);
+    // Op::IterNext used to bound-check via `il.index < il.values.size()`
+    // every single iteration. IterableValues::size() is O(1) for a
+    // materialized list, but for a RANGE it walks the whole sequence from
+    // scratch (its own doc comment already flagged this as a stale
+    // assumption: "no caller in this codebase actually calls size() on a
+    // range today" -- Op::IterNext was exactly that caller). Recomputing an
+    // O(n) size every one of n iterations is O(n^2) overall -- a
+    // 100,000-element range list comprehension took ~9.5s compiled vs
+    // ~0.03s interpreted before the fix (caught via a BOSL2 corpus sweep,
+    // test_math.scadtest's gaussian_rands()). Fixed by caching the size
+    // once at IterMaterialize time (IterList::total). 200,000 elements
+    // finishes in well under a second now; the old behavior would have
+    // taken tens of seconds, so a generous 5s bound cleanly separates
+    // "fixed" from "regressed" without making this test itself slow.
+    const auto start = std::chrono::steady_clock::now();
+    EXPECT_EQ(runCapturingEcho("function myrange(n) = [for (i=[0:1:n-1]) i];\n"
+                                "r = myrange(200000);\n"
+                                "echo(len(r));"),
+              "ECHO: 200000");
+    const auto elapsed = std::chrono::steady_clock::now() - start;
+    EXPECT_LT(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count(), 5000);
+}
+
+TEST(BytecodeCompiler, CStyleForIncrNameCanReadItsOwnPriorValueInTheSameAssignment) {
+    ScopedVm vm(true);
+    // A C-style for's incr list can introduce a name that reads its OWN
+    // not-yet-assigned-this-iteration value on the right-hand side (its
+    // prior iteration's value) -- e.g. BOSL2's skin.scad: `best_i =
+    // result[0]<bestcost ? i : best_i,`. The compiler used to compile each
+    // incr assignment's RHS BEFORE declaring that assignment's own local
+    // slot (declareLocal ran only after compileExpr), so a self-reference
+    // like this -- and the loop BODY's own read, compiled even earlier --
+    // resolved via Op::LoadFree (the "not a known local, might be dynamic"
+    // fallback) instead of Op::LoadLocal. That's not just an extra
+    // "unknown variable" warning: LoadFree runs identically on every
+    // iteration once compiled, so it NEVER saw what Op::StoreLocal had
+    // written moments earlier at runtime -- a genuinely wrong final
+    // result (undef), not merely a cosmetic warning-count mismatch. Real
+    // OpenSCAD gives [4] here (one "unknown variable" warning for the
+    // first, genuinely-unassigned read, then the accumulator works
+    // correctly from there). Fixed by pre-declaring every incr name's slot
+    // before compiling the condition/body/incr expressions at all.
+    EXPECT_EQ(runCapturingEcho("function myloop(n) =\n"
+                                "    [for (i=0, bestcost=1/0;\n"
+                                "          i<=n;\n"
+                                "          bestcost = (i==2||i==4) ? i : bestcost,\n"
+                                "          best_i = (i==2||i==4) ? i : best_i,\n"
+                                "          i=i+1)\n"
+                                "          if (i==n) best_i];\n"
+                                "echo(myloop(5));"),
+              "ECHO: [4]");
+}