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

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

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

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.5.1}/bindings/module.cpp

@@ -349,6 +349,51 @@ nb::object generatePartialTrampoline(const GeneratePartialFn& generatePartial) {
 // synchronously within the current hook call, same as get_frames.
 using GetChildrenPositionsFn = std::function<const std::optional<std::vector<std::pair<std::string, int>>>&()>;
 
+// Trampoline: lets the Python hook tell the Evaluator it's safe to speed
+// up function calls with the bytecode VM right now -- see
+// Evaluator::setFastContinueBreakpoints's own doc comment (evaluator.hpp)
+// for the exact contract (only when no step is pending/no pause was
+// requested/the initial break-on-first stop is already consumed) and
+// Evaluator::chunkEligibleNow for how the breakpoint set is used (a
+// per-function span check, not a blanket switch). `breakpoints=None`
+// means "no exception right now" -- i.e. every function call runs
+// interpreted, same as if this were never called at all. A callable
+// (not a return-tuple field) so DebugSession's own hook() can call it
+// exactly where it already computes should_pause, without needing to
+// widen hook()'s existing (cmd, mods) return-tuple contract -- mirrors
+// generate_partial/get_children_positions's own "extra kwarg the Python
+// side may or may not call" shape.
+using SetFastContinueFn = std::function<void(std::optional<std::unordered_map<std::string, std::set<int>>>)>;
+
+// Wraps a SetFastContinueFn as a Python callable taking either a
+// dict[str, set[int]]/dict[str, list[int]] (origin -> breakpoint lines) or
+// None. Mirrors generatePartialTrampoline's own shape.
+nb::object setFastContinueTrampoline(const SetFastContinueFn& setFastContinue) {
+    return nb::cpp_function(
+        [&setFastContinue](nb::object breakpoints) {
+            if (breakpoints.is_none()) {
+                setFastContinue(std::nullopt);
+                return;
+            }
+            std::unordered_map<std::string, std::set<int>> bp;
+            for (auto [k, v] : nb::cast<nb::dict>(breakpoints)) {
+                std::set<int> lines;
+                for (nb::handle line : v) lines.insert(nb::cast<int>(line));
+                bp.emplace(nb::cast<std::string>(k), std::move(lines));
+            }
+            setFastContinue(std::move(bp));
+        },
+        // Without .none(), nanobind rejects a Python `None` argument for an
+        // `nb::object`-typed parameter registered this ad-hoc way (unlike a
+        // `.def()`-declared function parameter, which accepts None by
+        // default) -- confirmed via a real call: "incompatible function
+        // arguments ... Invoked with types: NoneType" the first time this
+        // was called with breakpoints=None (DebugSession's own
+        // _apply_fast_continue calls it with None whenever fast-continue
+        // mode isn't safe right now -- see debugger.py).
+        nb::arg("breakpoints").none());
+}
+
 // GIL held (reacquired by the caller). `getFrame`/`callStack`/`generatePartial`/
 // `getChildrenPositions` are valid only for this synchronous call, so their
 // closures are only ever invoked from within the Python hook, before it returns.
@@ -357,7 +402,8 @@ oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, boo
                                         const std::vector<oscadeval::CallStackFrame>& callStack,
                                         const oscadeval::DebugFramesFn& getFrame,
                                         const GeneratePartialFn& generatePartial,
-                                        const GetChildrenPositionsFn& getChildrenPositions) {
+                                        const GetChildrenPositionsFn& getChildrenPositions,
+                                        const SetFastContinueFn& setFastContinue) {
     auto getFramesPy = nb::cpp_function([&callStack, &getFrame]() -> nb::object {
         std::vector<oscadeval::DebugFrame> frames = getFrame();
         nb::list allFrameLocals;
@@ -380,6 +426,7 @@ oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, boo
         for (const auto& [origin, line] : *positions) out.append(nb::make_tuple(origin, line));
         return out;
     });
+    nb::object setFastContinuePy = setFastContinueTrampoline(setFastContinue);
 
     // expr_depth stays hardcoded at 0 -- this port deliberately doesn't
     // track the reference's _expr_depth counter (no consumer reads it);
@@ -387,7 +434,8 @@ oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, boo
     nb::object ret = hook(line, depth, nb::arg("forced") = forced, nb::arg("expr_level") = exprLevel,
                           nb::arg("expr_depth") = 0, nb::arg("origin") = origin, nb::arg("get_frames") = getFramesPy,
                           nb::arg("generate_partial") = generatePartialPy,
-                          nb::arg("get_children_positions") = getChildrenPositionsPy);
+                          nb::arg("get_children_positions") = getChildrenPositionsPy,
+                          nb::arg("set_fast_continue") = setFastContinuePy);
     nb::tuple t = nb::cast<nb::tuple>(ret);
     oscadeval::DebugAction action;
     action.stop = (nb::cast<std::string>(t[0]) == "stop");
@@ -452,13 +500,17 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             [&evPtr]() -> const std::optional<std::vector<std::pair<std::string, int>>>& {
             return evPtr->lastChildrenPositions();
         };
+        SetFastContinueFn setFastContinue =
+            [&evPtr](std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints) {
+            evPtr->setFastContinueBreakpoints(std::move(breakpoints));
+        };
         oscadeval::DebugHooks hooks;
         hooks.debugHook = [&](int line, int depth, bool forced, bool exprLevel, const std::string& origin,
                               const std::vector<oscadeval::CallStackFrame>& cs,
                               const oscadeval::DebugFramesFn& gf) -> oscadeval::DebugAction {
             nb::gil_scoped_acquire g;
             return callPyDebugHook(debugHook, line, depth, forced, exprLevel, origin, cs, gf, generatePartial,
-                                    getChildrenPositions);
+                                    getChildrenPositions, setFastContinue);
         };
         hooks.errorBreak = [&](int line, const std::string& header, const std::string& origin,
                                const std::vector<oscadeval::CallStackFrame>& cs, const oscadeval::DebugFramesFn& gf) {

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.5.1}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -4,6 +4,7 @@
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
 
+#include <limits>
 #include <optional>
 #include <string>
 #include <vector>
@@ -252,6 +253,23 @@ struct CompiledChunk {
     // sizes its own native iterLists/iterIndex scratch vectors to this.
     int numIterLists = 0;
 
+    // Source-file/line span this chunk's own body+defaults were compiled
+    // from -- the min/max of every AST node's own position().line actually
+    // visited during compilation (see Compiler::trackSpan, bytecode_compiler.cpp),
+    // not just the declaration's own header line. Used by Evaluator::
+    // chunkEligibleNow (debug "fast continue" mode) to decide, per
+    // function, whether ANY currently-set breakpoint line could fall
+    // inside this chunk's own body -- a plain integer-range check, chosen
+    // specifically so that decision never needs the original source text
+    // or an offset->line conversion at eligibility-check time (called on
+    // every single compiled call, not just once). origin empty / minLine >
+    // maxLine (never updated) should not happen for any chunk that
+    // actually compiled a real body -- every function has at least one
+    // expression to visit.
+    std::string origin;
+    int minLine = std::numeric_limits<int>::max();
+    int maxLine = 0;
+
     // FunctionLiteral chunks discovered while compiling THIS chunk (a
     // FunctionLiteral expression appearing anywhere in its body/defaults),
     // recursively containing their own nested literals in turn. The

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.5.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -315,6 +315,28 @@ public:
     // the env var.
     static void setBytecodeVmEnabledForTesting(std::optional<bool> enabled);
 
+    // Tells this Evaluator it's safe to speed up function calls with the
+    // bytecode VM even though a debugger is attached, PROVIDED the caller
+    // has already verified none of the reasons that's normally unsafe
+    // apply right now: no step command (`into`/`over`/`out`/`to_child`)
+    // pending, no explicit pause requested, and the session's own initial
+    // break-on-first stop already consumed. `breakpoints` is exactly the
+    // caller's own current breakpoint set (origin file -> line numbers) --
+    // see useBytecodeVm()/chunkEligibleNow's own doc comments for how it's
+    // used (a per-function span check, not a blanket switch: a function
+    // whose own body could contain one of these lines still always runs
+    // interpreted). Call with std::nullopt to go back to "no debugger
+    // exception at all" (today's original, always-safe behavior) --
+    // e.g. the instant a step command starts or a pause is requested.
+    // Cheap to call as often as the debugger's own state changes: this
+    // just updates one member, no cache invalidation needed (chunkEligibleNow
+    // is re-checked on every lookupOrCompileChunk/lookupCompiledLiteralChunk
+    // call, not cached itself -- only the compiled bytecode ITSELF, which
+    // never depends on debugger state, is cached forever).
+    void setFastContinueBreakpoints(std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints) {
+        fastContinueBreakpoints_ = std::move(breakpoints);
+    }
+
     // Checks whether a debug pause should happen at `node` (via the
     // injected DebugHooks::debugHook, if any -- a no-op otherwise),
     // applying any `mods` the hook returns to `ctx.let_` and throwing
@@ -815,7 +837,46 @@ private:
     // therefore always takes the interpreter path, where the port matches
     // the reference's _check_debug placement exactly. Costs nothing when
     // no debugger is attached, which is every non-debug render.
-    bool useBytecodeVm() const { return !debugHooks_.debugHook && bytecodeVmEnabled(); }
+    //
+    // EXCEPT: a caller that knows none of that applies right now -- no
+    // step command pending, no explicit pause requested, the session's
+    // own initial break-on-first stop already consumed -- can call
+    // setFastContinueBreakpoints() with the CURRENT breakpoint set instead
+    // of leaving it unset. That alone doesn't turn the VM on for
+    // everything; see chunkEligibleNow, which still forces the
+    // interpreter for any specific function whose own compiled span could
+    // contain one of those lines. This only ever helps a plain "Continue,
+    // pause only at a known breakpoint" -- the far more common case in a
+    // long debug session than active single-stepping, and exactly the
+    // case where "every function pays the interpreter tax because a
+    // debugger happens to be attached somewhere" wastes the most time
+    // (see docs/debugger.md and this method's own callers for the full
+    // story).
+    bool useBytecodeVm() const {
+        return bytecodeVmEnabled() && (!debugHooks_.debugHook || fastContinueBreakpoints_.has_value());
+    }
+
+    // The fine-grained half of the check above: even when useBytecodeVm()
+    // says compiling/using bytecode is on the table at all, a SPECIFIC
+    // chunk is only actually safe to run compiled if nothing about it
+    // could matter to the debugger right now. No debugger attached at
+    // all -- always fine, unaffected by any of this. Debugger attached: only
+    // safe in fast-continue mode (useBytecodeVm() already checked that),
+    // and only if the chunk's own [minLine, maxLine] span (see
+    // CompiledChunk's own doc comment, bytecode.hpp) contains none of the
+    // breakpoint lines currently set for its origin file -- a checkpoint
+    // for one of those lines could fire mid-body, and compiled code has no
+    // way to stop there.
+    bool chunkEligibleNow(const CompiledChunk& chunk) const {
+        if (!debugHooks_.debugHook) return true;
+        if (!fastContinueBreakpoints_) return false;
+        auto it = fastContinueBreakpoints_->find(chunk.origin);
+        if (it == fastContinueBreakpoints_->end()) return true;
+        for (int line : it->second) {
+            if (line >= chunk.minLine && line <= chunk.maxLine) return false;
+        }
+        return true;
+    }
 
     // -- Profiling (Phase 9) --------------------------------------------
 
@@ -886,6 +947,11 @@ private:
     // -- Debugging (Phase 9) --------------------------------------------
 
     DebugHooks debugHooks_;
+    // See setFastContinueBreakpoints's own doc comment. nullopt (the
+    // default, and what a plain debugger attach without ever calling that
+    // setter leaves it at) means "no fast-continue exception" -- exactly
+    // today's original, always-safe behavior.
+    std::optional<std::unordered_map<std::string, std::set<int>>> fastContinueBreakpoints_;
     // The root EvalContext resolveTree() was called with -- lets
     // checkDebug()'s locals snapshot fall back to top-level script
     // variables when paused inside a nested user call, the same way the

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

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

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

@@ -128,6 +128,20 @@ public:
         return slot;
     }
 
+    // Widens chunk_'s own [minLine, maxLine] span to include `node` --
+    // called at the top of every AST-node-visiting entry point
+    // (compileExpr/compileListElement/compileListCompBody) so the chunk's
+    // final span covers every line actually compiled into it, not just the
+    // declaration's own header line. See CompiledChunk::origin/minLine/
+    // maxLine's own doc comment (bytecode.hpp) for why this matters --
+    // Evaluator::chunkEligibleNow's debug "fast continue" check.
+    void trackSpan(const oscad::ASTNode& node) {
+        const oscad::Position& pos = node.position();
+        chunk_.origin = pos.origin;
+        if (pos.line < chunk_.minLine) chunk_.minLine = pos.line;
+        if (pos.line > chunk_.maxLine) chunk_.maxLine = pos.line;
+    }
+
     // Walks `enclosing_` from innermost (back()) to outermost, looking for
     // a level whose own CompileScope resolves `name` -- the first (most
     // deeply nested, i.e. most recently active at runtime) match wins,
@@ -171,6 +185,7 @@ public:
     void compileExpr(const oscad::Expression& node, std::vector<Instruction>& out, CompileScope& scope,
                       bool tail = false) {
         using oscad::NodeKind;
+        trackSpan(node);
         switch (node.kind()) {
             case NodeKind::NumberLiteral:
                 out.push_back({Op::PushConst, internConst(Value{static_cast<const oscad::NumberLiteral&>(node).val}), 0,
@@ -609,6 +624,7 @@ public:
     // list too, when reached via a clause's own nested body.
     void compileListElement(const oscad::ASTNode& elem, std::vector<Instruction>& out, CompileScope& scope) {
         using oscad::NodeKind;
+        trackSpan(elem);
         switch (elem.kind()) {
             case NodeKind::ListCompFor: {
                 auto& n = static_cast<const oscad::ListCompFor&>(elem);
@@ -676,6 +692,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.5.1}/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.5.1}/src/user_calls.cpp

@@ -14,12 +14,20 @@ const CompiledChunk* Evaluator::lookupOrCompileChunk(const oscad::FunctionDeclar
         it = chunkCache_.emplace(&decl, tryCompileFunction(decl)).first;
         if (it->second) flattenNestedLiterals(*it->second);
     }
-    return it->second ? &*it->second : nullptr;
+    if (!it->second) return nullptr;
+    // Compilation itself is cached forever above (never depends on
+    // debugger state); ELIGIBILITY to actually use that compiled chunk
+    // right now is re-checked every call instead -- see chunkEligibleNow's
+    // own doc comment for why that's still cheap (no debugger: one bool
+    // check; fast-continue mode: a handful of integer comparisons against
+    // whatever breakpoints happen to be set right now).
+    return chunkEligibleNow(*it->second) ? &*it->second : nullptr;
 }
 
 const CompiledChunk* Evaluator::lookupCompiledLiteralChunk(const oscad::FunctionLiteral& node) const {
     auto it = literalChunkCache_.find(&node);
-    return it != literalChunkCache_.end() ? &it->second : nullptr;
+    if (it == literalChunkCache_.end()) return nullptr;
+    return chunkEligibleNow(it->second) ? &it->second : nullptr;
 }
 
 void Evaluator::flattenNestedLiterals(CompiledChunk& chunk) {

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

@@ -4,6 +4,7 @@
 
 #include "test_helpers.hpp"
 
+#include <chrono>
 #include <filesystem>
 #include <fstream>
 #include <gtest/gtest.h>
@@ -48,6 +49,33 @@ std::string runCapturingEcho(const std::string& code) {
     return captured;
 }
 
+// Counts total debugHook invocations (statement- and expr-level combined)
+// running `code` with a debugger attached. A VM-compiled function call
+// gets exactly ONE stop -- evalUserFunctionCore's own unconditional
+// body-entry checkDebug(), the only checkpoint compiled bytecode has left
+// (see useBytecodeVm()/chunkEligibleNow's own doc comments, evaluator.hpp)
+// -- while an interpreted call additionally hits every sub-expression
+// checkpoint inside it (ternary condition + chosen branch, at minimum, for
+// the functions these tests use). That gap is the only observable,
+// black-box signal these tests have for "did this call actually run
+// compiled or interpreted" -- there's no other public introspection point.
+int countDebugHookStops(const std::string& code, std::optional<std::unordered_map<std::string, std::set<int>>> fastContinueBreakpoints) {
+    int stops = 0;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&,
+                          const DebugFramesFn&) {
+        ++stops;
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    if (fastContinueBreakpoints) ev.setFastContinueBreakpoints(std::move(fastContinueBreakpoints));
+    auto ast = parseSrc(code);
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.resolveTree(ast, ctx);
+    return stops;
+}
+
 std::filesystem::path tempPath(const std::string& name) {
     return std::filesystem::temp_directory_path() / ("oscad_bytecode_compiler_test_" + name);
 }
@@ -721,3 +749,135 @@ 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);
+}
+
+// -- Debug "fast continue" per-function VM gating --------------------------
+//
+// A debugger attached AND actively single-stepping needs every checkDebug()
+// checkpoint the interpreter provides (a compiled function has none for a
+// step to land on) -- that's the pre-existing, always-safe, never-changed
+// behavior when Evaluator::setFastContinueBreakpoints is never called at
+// all (fastContinueBreakpoints_ stays nullopt). But a plain "Continue,
+// pause only at a known breakpoint line" doesn't need that: a function
+// whose own compiled span contains none of the currently-set breakpoint
+// lines can safely run on the VM, since nothing inside it could possibly
+// need a checkpoint right now.
+
+// Expected stop counts below are empirically verified (via a temporary
+// direct instrumentation pass through lookupOrCompileChunk/evalUserFunction,
+// not guessed): calling `f(5)` for `function f(x) = x > 0 ? x + 1 : x - 1;`
+// as the lone argument of a top-level `echo(...)` produces 3 checkDebug
+// stops when f runs compiled (the top-level echo statement's own stop,
+// f's call-site stop from evalFunctionCall, and evalUserFunctionCore's
+// unconditional body-entry stop -- no others, since compiled bytecode has
+// no sub-expression checkpoints) versus 5 when f runs interpreted (those
+// same 3, plus the ternary's own condition-check and chosen-branch-entry
+// sub-expression stops). A FunctionDeclaration statement itself never adds
+// its own top-level stop (evalChildren's per-statement checkpoint skips
+// declarations, mirroring $children's own count -- see
+// Evaluator::evalUserModule's childrenCount loop), so adding a second,
+// uncalled function declaration to a script doesn't change either count.
+
+TEST(BytecodeCompiler, DebugAttachedWithoutFastContinueAlwaysInterprets) {
+    ScopedVm vm(true);
+    // No setFastContinueBreakpoints call at all (nullopt, the default):
+    // must behave exactly as before this feature existed -- always
+    // interpreted -- regardless of the function's own line having no
+    // breakpoint anywhere near it.
+    const int stops = countDebugHookStops("function f(x) = x > 0 ? x + 1 : x - 1;\n"
+                                           "echo(f(5));",
+                                           std::nullopt);
+    EXPECT_EQ(stops, 5);
+}
+
+TEST(BytecodeCompiler, FastContinueWithNoBreakpointInFunctionUsesVm) {
+    ScopedVm vm(true);
+    // Breakpoint set, but only on line 2 (the echo statement) -- f's own
+    // body is entirely on line 1, outside that set, so it's eligible to
+    // run compiled.
+    const int stops = countDebugHookStops("function f(x) = x > 0 ? x + 1 : x - 1;\n"
+                                           "echo(f(5));",
+                                           std::unordered_map<std::string, std::set<int>>{{"<string>", {2}}});
+    EXPECT_EQ(stops, 3);
+}
+
+TEST(BytecodeCompiler, FastContinueWithBreakpointInsideFunctionStillInterprets) {
+    ScopedVm vm(true);
+    // Breakpoint on line 1 itself -- inside f's own compiled span -- must
+    // still force the interpreter for f specifically, even in fast-continue
+    // mode: something on that exact line could need a real checkpoint.
+    const int stops = countDebugHookStops("function f(x) = x > 0 ? x + 1 : x - 1;\n"
+                                           "echo(f(5));",
+                                           std::unordered_map<std::string, std::set<int>>{{"<string>", {1}}});
+    EXPECT_EQ(stops, 5);
+}
+
+TEST(BytecodeCompiler, FastContinueWithBreakpointInDifferentFunctionUsesVmForThisOne) {
+    ScopedVm vm(true);
+    // Two ternary-bodied functions (so both would show the same VM-vs-
+    // interpreter stop-count gap if called), breakpoint only inside g's
+    // body (line 2) -- f (line 1) must still run compiled since its own
+    // span doesn't contain line 2, even though SOME breakpoint exists in
+    // this same file. Confirms the gating is genuinely per-function, not
+    // "any breakpoint anywhere disables the whole file." Only f is ever
+    // called, so g's own eligibility is never directly observed here.
+    const int stops = countDebugHookStops("function f(x) = x > 0 ? x + 1 : x - 1;\n"
+                                           "function g(x) = x > 0 ? x + 1 : x - 1;\n"
+                                           "echo(f(5));",
+                                           std::unordered_map<std::string, std::set<int>>{{"<string>", {2}}});
+    EXPECT_EQ(stops, 3);
+}
+
+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]");
+}

{openscad_cpp_evaluator-0.4.9 → openscad_cpp_evaluator-0.5.1}/tests/test_python_bindings.py

@@ -97,7 +97,7 @@ def test_return_hook_fires_for_user_function():
     returns = []
 
     def debug_hook(line, depth, forced=False, expr_level=False, expr_depth=0, origin=None, get_frames=None,
-                   generate_partial=None, get_children_positions=None):
+                   generate_partial=None, get_children_positions=None, set_fast_continue=None):
         return ("continue", {})
 
     def return_hook(name, value, depth):
@@ -120,7 +120,7 @@ def test_generate_partial_during_a_live_pause():
     seen_partial_counts = []
 
     def debug_hook(line, depth, forced=False, expr_level=False, expr_depth=0, origin=None, get_frames=None,
-                   generate_partial=None, get_children_positions=None):
+                   generate_partial=None, get_children_positions=None, set_fast_continue=None):
         if forced:
             bodies = generate_partial()
             seen_partial_counts.append(len(bodies))
@@ -144,7 +144,7 @@ def test_generate_partial_on_an_empty_tree_returns_empty_not_an_error():
     seen = []
 
     def debug_hook(line, depth, forced=False, expr_level=False, expr_depth=0, origin=None, get_frames=None,
-                   generate_partial=None, get_children_positions=None):
+                   generate_partial=None, get_children_positions=None, set_fast_continue=None):
         if forced:
             seen.append(generate_partial())
         return ("continue", {})
@@ -164,7 +164,7 @@ def test_get_children_positions_reports_module_call_block_children():
     seen = []
 
     def debug_hook(line, depth, forced=False, expr_level=False, expr_depth=0, origin=None, get_frames=None,
-                   generate_partial=None, get_children_positions=None):
+                   generate_partial=None, get_children_positions=None, set_fast_continue=None):
         positions = get_children_positions()
         if positions:
             seen.append((line, positions))