openscad-cpp-evaluator 0.2.0__tar.gz → 0.4.0__tar.gz

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/CLAUDE.md

@@ -241,15 +241,32 @@ Roman:style=Bold"`) silently gets Liberation Sans instead under this default pro
 path needed in this repo: the fix is a Qt host application supplying its own `FontProvider`, which
 is exactly what the injection seam exists for.
 
-**Debugger/profiler, Phase 9 (the last phase)**: `checkDebug()` fires from exactly one call site
-(`evalChildren`'s `runAll`, plus one explicit call each at user-function/function-literal body entry
-and inside `breakpoint()`'s resolve) rather than the reference's several dozen `_check_debug` call
-sites scattered across nearly every statement/expression-eval function — a deliberate scope
-reduction (see `debug_hooks.hpp`'s `DebugHookFn` doc comment for the full reasoning): the reference's
-extra sites exist for `expr_level` sub-statement stepping (individual list-comprehension clauses,
-ternary branches) that neither this port's own `debug_repl.cpp` REPL nor the reference's own
-`_debug_repl.py` REPL ever actually uses (both only ever pause/step at statement granularity in
-practice). Verified this is a faithful, not just simplified, port by running an *identical*
+**Debugger/profiler, Phase 9 (the last phase)**: `checkDebug()` fires at **full parity with the
+reference's `_check_debug` call sites** — the statement checkpoint in `evalChildren`'s `runAll`,
+user-function/function-literal body entry, `breakpoint()`'s resolve, *and* the reference's
+sub-statement sites: if/else branch entry (`evalStatement`), for-loop per-variable bindings and
+per-iteration body entry (`evalFor`), `intersection_for` body entry, statement- and
+expression-form `let()` assignments, expression-form `echo()`/`assert()`, ternary
+condition/chosen-branch, every list-comprehension clause including the C-style `for`
+(`evalListElement`), modifier-wrapped children (`evalModifier`), and user function/function-literal
+call sites (`evalFunctionCall`, plus their duplicates in `simplifyTailStep` so a tail chain isn't
+debug-invisible). Each carries the reference's `expr_level` flag, threaded all the way through
+`DebugHookFn` and the nanobind trampoline. `expr_depth` is *not* tracked (hardcoded 0 through the
+Python surface) — no consumer reads it.
+
+An earlier revision of this file argued the sub-statement sites were unnecessary because no REPL
+steps at that granularity. That was wrong: BelfrySCAD's debugger UI consumes them, and one case was
+an outright bug — a C-style `for` *inside a list comprehension* got zero debug checks anywhere,
+so a breakpoint set on it never fired. Two consequences of full parity worth knowing:
+`useBytecodeVm()` returns false whenever a debug hook is installed (compiled chunks flatten away the
+AST nodes these checkpoints hang off, so debugging always takes the interpreter path), and
+`evalChildren` deliberately skips its own check for `ModularLet` — the reference's
+`_eval_statement_impl` skips it too, pausing on the let's assignments instead. Parity is verified
+test-by-test in `tests/test_debug_hooks.cpp`'s `DebugHooksParity` suite, whose expected
+`(line, expr_level, forced)` sequences were captured by running the Python reference over the same
+sources, not written down from this port's own output.
+
+The port was also verified end to end by running an *identical*
 `--debug` session (same script, same `break`/`run`/`print`/`continue`/`step`/`backtrace`/`set`
 sequence) against both this port's CLI and the real Python reference's own `openscad-evaluator
 --debug` side by side: transcripts matched exactly, **including** an unexpected extra pause neither

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/bindings/module.cpp

@@ -292,13 +292,42 @@ nb::list callStackToPy(const std::vector<oscadeval::CallStackFrame>& cs) {
     return out;
 }
 
+// Called from within a debug_hook/error_break callback (never after it
+// returns) to best-effort generate a live render of whatever's been
+// resolved so far -- see Evaluator::generatePartialTree()'s own doc
+// comment for why this is safe to call mid-resolve.
+using GeneratePartialFn = std::function<std::vector<oscadeval::ColoredBody>()>;
+
+// Wraps a GeneratePartialFn as a Python callable returning a plain list of
+// body-dicts (bodiesToList's own shape) -- the facade's _generate_partial_render
+// converts these to ColoredBody and catches whatever exception a GenerateFn
+// raises, the same try/except shape it already had calling generate_tree()
+// directly. No error handling needed here: a C++ exception crossing into
+// Python via this cpp_function is nanobind's normal std::exception ->
+// RuntimeError mapping, which that Python try/except already catches.
+nb::object generatePartialTrampoline(const GeneratePartialFn& generatePartial) {
+    return nb::cpp_function([&generatePartial]() -> nb::list {
+        std::vector<oscadeval::ColoredBody> bodies = generatePartial();
+        return bodiesToList(bodies);
+    });
+}
+
 // Trampoline: C++ debug hook -> the Python DebugSession hook. Runs with the
-// GIL held (reacquired by the caller). `getFrame`/`callStack` are valid only
-// for this synchronous call, so the get_frames closure is only ever invoked
-// from within the Python hook, before it returns.
-oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, bool forced, const std::string& origin,
+// (origin, line) targets children()/children(N) might forward control to
+// from the just-checked debug-hook node, for the "step to child" command.
+// See Evaluator::lastChildrenPositions()'s own doc comment: valid only
+// synchronously within the current hook call, same as get_frames.
+using GetChildrenPositionsFn = std::function<const std::optional<std::vector<std::pair<std::string, int>>>&()>;
+
+// 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.
+oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, bool forced, bool exprLevel,
+                                        const std::string& origin,
                                         const std::vector<oscadeval::CallStackFrame>& callStack,
-                                        const oscadeval::DebugFramesFn& getFrame) {
+                                        const oscadeval::DebugFramesFn& getFrame,
+                                        const GeneratePartialFn& generatePartial,
+                                        const GetChildrenPositionsFn& getChildrenPositions) {
     auto getFramesPy = nb::cpp_function([&callStack, &getFrame]() -> nb::object {
         std::vector<oscadeval::DebugFrame> frames = getFrame();
         nb::list allFrameLocals;
@@ -313,9 +342,22 @@ oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, boo
         }
         return nb::make_tuple(nb::make_tuple(lastLocals, allFrameLocals), callStackToPy(callStack));
     });
+    nb::object generatePartialPy = generatePartialTrampoline(generatePartial);
+    auto getChildrenPositionsPy = nb::cpp_function([&getChildrenPositions]() -> nb::object {
+        const std::optional<std::vector<std::pair<std::string, int>>>& positions = getChildrenPositions();
+        if (!positions) return nb::none();
+        nb::list out;
+        for (const auto& [origin, line] : *positions) out.append(nb::make_tuple(origin, line));
+        return out;
+    });
 
-    nb::object ret = hook(line, depth, nb::arg("forced") = forced, nb::arg("expr_level") = false,
-                          nb::arg("expr_depth") = 0, nb::arg("origin") = origin, nb::arg("get_frames") = getFramesPy);
+    // expr_depth stays hardcoded at 0 -- this port deliberately doesn't
+    // track the reference's _expr_depth counter (no consumer reads it);
+    // expr_level, which consumers do read, is the real threaded value.
+    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::tuple t = nb::cast<nb::tuple>(ret);
     oscadeval::DebugAction action;
     action.stop = (nb::cast<std::string>(t[0]) == "stop");
@@ -327,11 +369,13 @@ oscadeval::DebugAction callPyDebugHook(nb::handle hook, int line, int depth, boo
 // Trampoline: C++ errorBreak -> the Python DebugSession error hook.
 void callPyErrorBreak(nb::handle errorBreak, int line, const std::string& header, const std::string& origin,
                        const std::vector<oscadeval::CallStackFrame>& callStack,
-                       const oscadeval::DebugFramesFn& getFrame) {
+                       const oscadeval::DebugFramesFn& getFrame, const GeneratePartialFn& generatePartial) {
     std::vector<oscadeval::DebugFrame> frames = getFrame();
     nb::list allFrameLocals;
     for (const oscadeval::DebugFrame& f : frames) allFrameLocals.append(frameToDict(f));
-    errorBreak(line, header, allFrameLocals, callStackToPy(callStack), nb::arg("origin") = origin);
+    nb::object generatePartialPy = generatePartialTrampoline(generatePartial);
+    errorBreak(line, header, allFrameLocals, callStackToPy(callStack), nb::arg("origin") = origin,
+               nb::arg("generate_partial") = generatePartialPy);
 }
 
 // Trampoline: C++ returnHook -> the Python DebugSession return hook. Only
@@ -362,17 +406,34 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             nb::gil_scoped_acquire g;
             echoFn(m);
         };
+        // Set right after `ev` is constructed below, before evaluate() runs
+        // -- every hook fires only from within that call, by which point
+        // this is always valid. Needed because `hooks` (captured by the
+        // lambdas below) must be fully built and passed into Evaluator's
+        // constructor before `ev` exists, so the lambdas can't capture `ev`
+        // itself; they capture this pointer's address instead, which DOES
+        // already exist (see generatePartial's own doc comment on why
+        // GeneratePartialFn needs a live Evaluator& at all).
+        oscadeval::Evaluator* evPtr = nullptr;
+        GeneratePartialFn generatePartial = [&evPtr]() -> std::vector<oscadeval::ColoredBody> {
+            return evPtr->generatePartialTree();
+        };
+        GetChildrenPositionsFn getChildrenPositions =
+            [&evPtr]() -> const std::optional<std::vector<std::pair<std::string, int>>>& {
+            return evPtr->lastChildrenPositions();
+        };
         oscadeval::DebugHooks hooks;
-        hooks.debugHook = [&](int line, int depth, bool forced, const std::string& origin,
+        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, origin, cs, gf);
+            return callPyDebugHook(debugHook, line, depth, forced, exprLevel, origin, cs, gf, generatePartial,
+                                    getChildrenPositions);
         };
         hooks.errorBreak = [&](int line, const std::string& header, const std::string& origin,
                                const std::vector<oscadeval::CallStackFrame>& cs, const oscadeval::DebugFramesFn& gf) {
             nb::gil_scoped_acquire g;
-            callPyErrorBreak(errorBreak, line, header, origin, cs, gf);
+            callPyErrorBreak(errorBreak, line, header, origin, cs, gf, generatePartial);
         };
         if (!returnHook.is_none()) {
             hooks.returnHook = [&](const std::string& name, const oscadeval::Value& result, int depth) {
@@ -384,6 +445,7 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(path);
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, echoCpp);
             oscadeval::Evaluator ev(echoCpp, nullptr, manifoldCache, hooks, false);
+            evPtr = &ev;
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
             bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
             collectIdSpans(ev, idSpans);

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/examples/minimal_debugger.cpp

@@ -46,7 +46,7 @@ std::string fmtLocals(const std::unordered_map<std::string, Value>& locals) {
 void traceEveryStatement() {
     std::cout << "1. trace every statement:\n";
     DebugHooks hooks;
-    hooks.debugHook = [](int line, int depth, bool, const std::string&, const std::vector<CallStackFrame>&,
+    hooks.debugHook = [](int line, int depth, bool, bool, const std::string&, const std::vector<CallStackFrame>&,
                           const DebugFramesFn& getFrame) {
         std::vector<DebugFrame> frames = getFrame();
         DebugFrame frame = frames.empty() ? DebugFrame{} : frames.front();
@@ -69,7 +69,7 @@ void stopAtBreakpoint() {
     constexpr int kBreakLine = 3; // the `translate(...) sphere(...)` statement
 
     DebugHooks hooks;
-    hooks.debugHook = [](int line, int, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+    hooks.debugHook = [](int line, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
         DebugAction action;
         if (line == kBreakLine) {
             std::cout << "  breakpoint hit at line " << line << "\n";
@@ -97,7 +97,7 @@ void stopAtBreakpoint() {
 void overrideVariableViaMods() {
     std::cout << "3. override a variable via mods:\n";
     DebugHooks hooks;
-    hooks.debugHook = [](int line, int, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+    hooks.debugHook = [](int line, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
         DebugAction action;
         if (line == 2) action.mods["width"] = Value{2.0}; // about to run `cube([width, width, width])`
         return action;

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/include/openscad_cpp_evaluator/debug_hooks.hpp

@@ -86,25 +86,31 @@ inline constexpr const char* kDebuggingStoppedMessage = "Debugging stopped.";
 // genuine (non-debugger-triggered) EvalError leaves it at.
 enum class PostRunAction { None, Stopped, Restart, Quit };
 
-// Called at (approximately) every top-level statement in every block --
-// see Evaluator::evalChildren's single call site for the exact mechanism,
-// and its own comment for why this port checks at statement granularity
-// only, not the reference's additional expr_level sub-expression checks
-// (list-comprehension clauses, ternary branches, ...): those exist in the
-// reference to let a debugger single-step through individual expression
-// evaluation, which no consumer of this seam (debug_repl.cpp's REPL,
-// nor a plausible future GUI one) actually needs -- "pause on any
-// statement, inspect locals, set a breakpoint" is fully served by
-// statement-level granularity alone, at a small fraction of the
-// reference's own call-site count. Also called once, with `forced=true`,
-// right before evaluating a user function/function-literal's body
-// expression (functions have no statement-level granularity to hang a
-// hook off otherwise) and by breakpoint() (forced=true, unconditionally,
-// matching the reference's own _check_debug(..., forced=True) call).
+// Called at every point the Python reference calls _check_debug: every
+// top-level statement in every block (Evaluator::evalChildren's single
+// statement checkpoint), plus the reference's finer-grained sub-statement
+// sites -- ternary condition and chosen branch, if/else branch entry,
+// for-loop per-variable bindings and per-iteration body entry,
+// statement- and expression-form let() assignments, expression-form
+// echo()/assert(), every list-comprehension clause (if / if-else / let /
+// each / for / C-style-for, plus bare elements), modifier-wrapped
+// children, and user function / function-literal call sites. Also called
+// once right before evaluating a user function/function-literal's body
+// expression, and by breakpoint() (forced=true, unconditionally, matching
+// the reference's own _check_debug(..., forced=True) call).
+//
+// `exprLevel` mirrors the reference's `expr_level` keyword exactly: true
+// for the sub-expression markers a debugger should NOT treat as a
+// steppable/breakpointable statement (a chosen ternary or if branch, a
+// for-loop body entry, a list-comprehension body element, a C-style-for
+// condition re-check). Both this port's own debug_repl.cpp and the
+// reference's _debug_repl.py gate every step/breakpoint decision on
+// `!exprLevel`, while still pausing unconditionally on `forced`.
+//
 // `depth` is the live user-call-stack depth (Evaluator::callStack_.size())
 // at the pause point. Mirrors Evaluator._check_debug/the debug_hook
 // callback contract.
-using DebugHookFn = std::function<DebugAction(int line, int depth, bool forced, const std::string& origin,
+using DebugHookFn = std::function<DebugAction(int line, int depth, bool forced, bool exprLevel, const std::string& origin,
                                                const std::vector<CallStackFrame>& callStack, const DebugFramesFn& getFrame)>;
 
 // Called from Evaluator::error() right before it throws, if set -- gives a

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/include/openscad_cpp_evaluator/debug_repl.hpp

@@ -128,7 +128,7 @@ public:
     bool runPrompt();
 
     // Wire these three into Evaluator's DebugHooks (see debug_hooks.hpp).
-    DebugAction debugHook(int line, int depth, bool forced, const std::string& origin,
+    DebugAction debugHook(int line, int depth, bool forced, bool exprLevel, const std::string& origin,
                            const std::vector<CallStackFrame>& callStack, const DebugFramesFn& getFrame);
     void errorBreak(int line, const std::string& header, const std::string& origin, const std::vector<CallStackFrame>& callStack,
                      const DebugFramesFn& getFrame);

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -174,6 +174,26 @@ public:
     // top-level show_only filter -- see evaluate().
     std::vector<ColoredBody> generateTree(const std::vector<std::unique_ptr<CSGNode>>& tree);
 
+    // Best-effort generate over whatever's been resolved SO FAR, for a live
+    // partial render while genuinely paused inside a debug hook mid-
+    // evaluation (resolveTree()/evaluate() haven't returned yet) -- flattens
+    // treeStack_ across every nesting level and runs the same bottom-up
+    // generate walk generateTree() uses, via generateTreeImpl(), over
+    // non-owning pointers into nodes treeStack_ (not this call) still owns.
+    // Safe to call mid-resolve: the resolve pass never reads CSGNode::bodies,
+    // only ever writes kind/params/children, so populating .bodies early
+    // here cannot corrupt or race the resolve that's paused around this
+    // call -- and if a ManifoldCache is set, the real generateTree() call at
+    // the end of evaluate() gets a cache hit for any subtree this already
+    // generated, so a debug session pays no repeated Manifold work session-
+    // wide (see manifold_cache.hpp's own doc comment on this exact use
+    // case). Only meaningful to call synchronously from within a
+    // DebugHookFn/ErrorBreakFn callback; the caller must not retain a
+    // reference into anything treeStack_ owns past that callback's return.
+    // Mirrors the reference's `ev.generate_tree(partial_nodes)` called from
+    // `_generate_partial_render`.
+    std::vector<ColoredBody> generatePartialTree();
+
     // Provenance tables populated by tagGenerated() during generate --
     // originalID -> the AST node that produced it / that node's own
     // resolved color. Public, read by a caller (CLI, WYSIWYG picking) after
@@ -303,13 +323,16 @@ public:
     // filtering, which lives entirely in the injected hook, not here) --
     // it's simply passed through so the hook itself can distinguish an
     // unconditional breakpoint()/function-entry pause from a normal
-    // statement-boundary check. Public: called from evalChildren() (every
-    // ordinary statement), evalUserFunction()/evalFunctionLiteral() (function
-    // body entry), and builtins/control.cpp's resolveBreakpoint (a free
-    // function). See debug_hooks.hpp's DebugHookFn doc comment for the
-    // exact statement-level-only scope decision. Mirrors
-    // Evaluator._check_debug.
-    void checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool forced = false);
+    // statement-boundary check. `exprLevel=true` marks a sub-statement
+    // (expression-granularity) checkpoint that a stepping debugger should
+    // not treat as a statement boundary -- see debug_hooks.hpp's
+    // DebugHookFn doc comment for the full list of call sites and the
+    // exprLevel contract. Public: called from evalChildren() (every
+    // ordinary statement), evalUserFunction()/evalFunctionLiteral()
+    // (function body entry), and builtins/control.cpp's
+    // resolveBreakpoint/resolveIntersectionFor (free functions). Mirrors
+    // Evaluator._check_debug, including its parameter defaults.
+    void checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool forced = false, bool exprLevel = false);
 
     // (origin, line) for each top-level, non-declaration child of the
     // node checkDebug() was just called with -- i.e., if that node is a
@@ -357,6 +380,12 @@ private:
     std::vector<ColoredBody> evaluateImpl(const NodeList& nodes, EvalContext& ctx,
                                            const std::unordered_map<std::string, Value>& viewportParams);
 
+    // Shared bottom-up generate walk behind generateTree()/generatePartialTree()
+    // -- see generatePartialTree()'s own doc comment and this function's
+    // definition (csg_generate.cpp) for why non-owning pointers, not
+    // unique_ptr, let both callers share one implementation.
+    std::vector<ColoredBody> generateTreeImpl(const std::vector<CSGNode*>& tree);
+
     // Evaluates one top-level element of a `[...]` list literal (a plain
     // expression, or one of the 6 list-comprehension clause kinds --
     // for/c-for/let/if/if-else/each), appending whatever it contributes to
@@ -763,6 +792,17 @@ private:
     // strategy this enables).
     static bool bytecodeVmEnabled();
 
+    // Per-evaluator gate actually consulted before using a compiled chunk.
+    // Compiled bytecode has no per-AST-node debug checkpoints (its whole
+    // point is to flatten those nodes away), so a function body run on the
+    // VM would silently skip every checkDebug() call site the interpreter
+    // path makes -- ternary branches, let()/echo()/assert() expression
+    // forms, list-comprehension clauses, nested call sites. Debugging
+    // 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(); }
+
     // -- Profiling (Phase 9) --------------------------------------------
 
     // (kind, name, callOrigin, callLine) -- the exact call-site identity a

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/python/openscad_cpp_evaluator/__init__.py

@@ -17,7 +17,7 @@ from ._openscad_cpp_evaluator import ManifoldCache
 
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
-    "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree",
+    "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
 ]
 
 
@@ -132,7 +132,7 @@ class _CSGNode:
     def __init__(self, kind, params, bodies, is_builtin, children):
         self.kind = kind
         self.params = params
-        self.bodies = [ColoredBody(_BodyShim(d), d["color"], None, d["flat_preview"]) for d in bodies]
+        self.bodies = bodies_from_dicts(bodies)
         self.is_builtin = is_builtin
         self.children = children
 
@@ -289,6 +289,15 @@ class ColoredBody:
     flat_preview: bool = False
 
 
+def bodies_from_dicts(body_dicts) -> list:
+    """Convert raw body-dicts (the shape both evaluate()/debug_evaluate() and
+    a debug hook's `generate_partial()` callable return) to ColoredBody
+    instances. Shared by Evaluator.evaluate() and a debug session's own live
+    partial-render (see debug_evaluate()'s `generate_partial` hook kwarg,
+    module.cpp) so both paths convert identically."""
+    return [ColoredBody(_BodyShim(d), d["color"], None, d["flat_preview"]) for d in body_dicts]
+
+
 class Evaluator:
     """Drop-in for belfryscad.engine.evaluator.Evaluator, backed by C++.
 
@@ -355,7 +364,7 @@ class Evaluator:
             raise
         except Exception as e:  # ParseError/EvalError from C++ arrive as RuntimeError
             raise EvalError(str(e)) from e
-        bodies = [ColoredBody(_BodyShim(d), d["color"], None, d["flat_preview"]) for d in body_dicts]
+        bodies = bodies_from_dicts(body_dicts)
         # originalID -> a node with `.position` (start/end offsets) for WYSIWYG
         # picking and gizmo write-back.
         id_to_node = {

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/src/builtins/control.cpp

@@ -112,6 +112,11 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
 
     std::function<void(size_t, EvalContext&)> recurse = [&](size_t depth, EvalContext& parentCtx) {
         if (depth == varSeqs.size()) {
+            // One body-entry marker per full cartesian-product iteration
+            // and nothing per individual variable binding (unlike
+            // evalFor) -- mirrors _resolve_intersection_for's single
+            // `_check_debug(body_node[0], loop_ctx, expr_level=True)`.
+            if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
             const size_t before = ev.currentTreeFrameSize();
             ev.evalChildren(bodyNodes, parentCtx);
             const size_t after = ev.currentTreeFrameSize();

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/src/csg_generate.cpp

@@ -22,10 +22,18 @@ std::vector<ColoredBody> flattenCsgTree(const std::vector<std::unique_ptr<CSGNod
     return result;
 }
 
-std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_ptr<CSGNode>>& tree) {
+// Shared bottom-up walk behind generateTree() (owning unique_ptr tree) and
+// generatePartialTree() (a live, still-being-resolved treeStack_ level,
+// which the resolve pass -- not this function -- continues to own): takes
+// non-owning CSGNode* so both callers share one implementation without
+// either transferring ownership. unique_ptr's constness doesn't propagate
+// to the pointee, so mutating node.bodies here is legal even from a const
+// vector<unique_ptr<CSGNode>>& (see csg_node.hpp) -- this overload just
+// makes that non-owning access explicit for the treeStack_ caller too.
+std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>& tree) {
     std::vector<ColoredBody> topLevelBodies;
     const auto& dispatch = generateDispatch();
-    for (const auto& nodePtr : tree) {
+    for (CSGNode* nodePtr : tree) {
         CSGNode& node = *nodePtr;
 
         // ManifoldCache lookup: node.uncacheable (rands() taint, set
@@ -43,10 +51,11 @@ std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_p
         } else {
             // Recurse into children first (bottom-up) -- populates each
             // child's own .bodies in place so flattenCsgTree/a GenerateFn
-            // can read them back. unique_ptr's constness doesn't propagate
-            // to the pointee, so this mutation is legal even though `tree`
-            // is a const& (see csg_node.hpp).
-            generateTree(node.children);
+            // can read them back.
+            std::vector<CSGNode*> childPtrs;
+            childPtrs.reserve(node.children.size());
+            for (const std::unique_ptr<CSGNode>& c : node.children) childPtrs.push_back(c.get());
+            generateTreeImpl(childPtrs);
 
             auto it = dispatch.find(node.kind);
             if (node.isBuiltin && it != dispatch.end()) {
@@ -66,6 +75,28 @@ std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_p
     return topLevelBodies;
 }
 
+std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_ptr<CSGNode>>& tree) {
+    std::vector<CSGNode*> ptrs;
+    ptrs.reserve(tree.size());
+    for (const std::unique_ptr<CSGNode>& n : tree) ptrs.push_back(n.get());
+    return generateTreeImpl(ptrs);
+}
+
+std::vector<ColoredBody> Evaluator::generatePartialTree() {
+    // Flatten treeStack_ across every nesting level (mirrors the reference's
+    // `[node for level in ev._tree_stack for node in level]`): a CSGNode
+    // only lands in its parent's own accumulator once the parent's resolve
+    // finishes, so for a script whose whole geometry is one deeply-nested
+    // top-level statement, the *top* of the tree stays empty for the entire
+    // time spent stepping through its innermost leaves -- flattening every
+    // level picks up already-resolved leaves (e.g. a finished cube() sitting
+    // in a still-in-progress union()'s accumulator) regardless of how deep.
+    std::vector<CSGNode*> flat;
+    for (const std::vector<std::unique_ptr<CSGNode>>& level : treeStack_)
+        for (const std::unique_ptr<CSGNode>& node : level) flat.push_back(node.get());
+    return generateTreeImpl(flat);
+}
+
 ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue) {
     manifold::MeshGL mesh = body.GetMeshGL();
     std::optional<std::array<float, 4>> color = valueToColor(colorValue);

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/src/csg_resolve.cpp

@@ -140,6 +140,16 @@ void Evaluator::evalModifier(const oscad::ModuleInstantiation& child, const osca
     // always empty (role tagging happens entirely in the matching
     // generate function -- generateHighlight/Background/ShowOnly).
     buildTreeNode(kind, wrapperNode, [&]() {
+        // The wrapped child gets its own statement-level stop, in addition
+        // to the modifier node's (which evalChildren already fired before
+        // dispatching here) -- so `#cube(1);` pauses twice, like the
+        // reference. There, _resolve_modifier_child has no _check_debug of
+        // its own: it calls _eval_statement(node.child, ctx), and _that_
+        // dispatcher independently checks every _TREE_NODE_TYPES node it
+        // is handed. This port's evalStatement has no such blanket check
+        // (evalChildren owns it), so the equivalent stop is made explicit
+        // here.
+        checkDebug(child, ctx);
         evalStatement(child, ctx);
         return CSGParams{};
     });

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/src/debug/debug_repl.cpp

@@ -425,18 +425,24 @@ bool DebugRepl::runPrompt() {
     }
 }
 
-DebugAction DebugRepl::debugHook(int line, int depth, bool forced, const std::string& origin,
+DebugAction DebugRepl::debugHook(int line, int depth, bool forced, bool exprLevel, const std::string& origin,
                                   const std::vector<CallStackFrame>& callStack, const DebugFramesFn& getFrame) {
     if (quit_) return DebugAction{true, {}};
 
+    // Every step/breakpoint/first-statement decision below is gated on
+    // !exprLevel -- a sub-expression marker (chosen ternary/if branch,
+    // loop body entry, list-comprehension body element) is not a statement
+    // this REPL steps to or breaks on. Only `forced` (breakpoint()) and an
+    // async pause request ignore it. Mirrors _debug_repl.py's debug_hook
+    // exactly, clause for clause.
     const std::string resolved = resolveOrigin(origin);
     bool stepHit = false;
     if (stepCmd_ == "over") {
-        stepHit = depth <= stepDepth_ && resolved == stepOrigin_ && line != stepLine_;
+        stepHit = depth <= stepDepth_ && resolved == stepOrigin_ && line != stepLine_ && !exprLevel;
     } else if (stepCmd_ == "into") {
-        stepHit = line != stepLine_ || resolved != stepOrigin_;
+        stepHit = (line != stepLine_ || resolved != stepOrigin_) && !exprLevel;
     } else if (stepCmd_ == "out") {
-        stepHit = depth < stepDepth_;
+        stepHit = depth < stepDepth_ && !exprLevel;
     } else if (stepCmd_ == "to_child") {
         // Pause the first time control reaches one of the paused call's
         // own children (wherever children()/children(N) forwards to
@@ -444,7 +450,7 @@ DebugAction DebugRepl::debugHook(int line, int depth, bool forced, const std::st
         // back to the same "call returned" safety net step-out uses, so
         // this can never hang. Mirrors BelfrySCAD's DebugSession::
         // _make_hook exactly.
-        stepHit = stepToChildTargets_.count({resolved, line}) > 0 || depth < stepDepth_;
+        stepHit = !exprLevel && (stepToChildTargets_.count({resolved, line}) > 0 || depth < stepDepth_);
     }
 
     // Read-and-clear, same as BelfrySCAD's own DebugSession.pause()/
@@ -454,8 +460,8 @@ DebugAction DebugRepl::debugHook(int line, int depth, bool forced, const std::st
     // immediate re-pause; a harmless quirk, not a hang or crash.
     const bool pauseRequested = pauseRequested_.exchange(false, std::memory_order_relaxed);
 
-    const bool shouldPause = forced || pauseRequested || (breakOnFirst_ && resolved == sourcePath_) ||
-                              breakpoints_[resolved].count(line) > 0 || stepHit;
+    const bool shouldPause = forced || pauseRequested || (breakOnFirst_ && !exprLevel && resolved == sourcePath_) ||
+                              (breakpoints_[resolved].count(line) > 0 && !exprLevel) || stepHit;
     if (!shouldPause) return DebugAction{};
 
     breakOnFirst_ = false;

{openscad_cpp_evaluator-0.2.0 → openscad_cpp_evaluator-0.4.0}/src/debug_profile.cpp

@@ -74,14 +74,14 @@ std::vector<DebugFrame> Evaluator::buildDebugFrames(const EvalContext* ctx) cons
     return frames;
 }
 
-void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool forced) {
+void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool forced, bool exprLevel) {
     if (!debugHooks_.debugHook) return;
     const oscad::Position& pos = node.position();
     const int depth = static_cast<int>(callStack_.size());
     const DebugFramesFn getFrame = [this, &ctx]() { return buildDebugFrames(&ctx); };
     lastChildrenPositions_ = childStatementPositions(node);
 
-    DebugAction action = debugHooks_.debugHook(pos.line, depth, forced, pos.origin, callStack_, getFrame);
+    DebugAction action = debugHooks_.debugHook(pos.line, depth, forced, exprLevel, pos.origin, callStack_, getFrame);
     for (auto& [k, v] : action.mods) ctx.let_->set(k, v);
     if (action.stop) throw EvalError(kDebuggingStoppedMessage);
 }