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

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

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

{openscad_cpp_evaluator-0.4.10 → openscad_cpp_evaluator-0.6.0}/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.10 → openscad_cpp_evaluator-0.6.0}/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>
@@ -99,16 +100,47 @@ enum class Op {
     // a = index into CompiledChunk::upvalues. At runtime, searches the live
     // call stack (Evaluator::findUpvalue) for a still-active call of the
     // upvalue's own target declaration and reads that call's own slot --
-    // undef if that call already returned (this codebase has no escaping
-    // closures, matching the interpreter's existing childCtx()-based
-    // semantics exactly; see scope_trail.hpp's own module comment). Never
-    // needs a STORE counterpart: a captured variable is always a
-    // parameter/let-binding of some ENCLOSING, already-executing call,
-    // and nothing this phase compiles ever writes back into an enclosing
-    // call's own slot (let/ListCompLet assignments always target a
-    // freshly-opened scope of their OWN, never a parent's).
+    // undef if that call already returned. Never needs a STORE counterpart:
+    // a captured variable is always a parameter/let-binding of some
+    // ENCLOSING, already-executing call, and nothing this phase compiles
+    // ever writes back into an enclosing call's own slot (let/ListCompLet
+    // assignments always target a freshly-opened scope of their OWN, never
+    // a parent's).
+    //
+    // NOTE: as of Op::MakeClosure (below), no CompiledChunk that's ever
+    // actually registered (chunkCache_/literalChunkCache_) has a non-empty
+    // `upvalues` list any more -- a FunctionLiteral with any real capture
+    // need (direct or transitively bubbled up from a nested literal, see
+    // bytecode_compiler.cpp's FunctionLiteral case) is now handled via
+    // Op::MakeClosure instead, and always runs interpreted when invoked
+    // (Evaluator::lookupCompiledLiteralChunk finds no entry for it). This
+    // opcode and Evaluator::findUpvalue/CallStackFrame::upvalueParent are
+    // therefore unreachable dead code today, left in place rather than
+    // removed in the same change that made them unreachable -- deleting
+    // them is a distinct, lower-risk cleanup, not bundled in here.
     LoadUpvalue,
 
+    // Escaping-closure support. a = index into CompiledChunk::closureSites.
+    // Builds a FRESH captured environment every time this instruction
+    // actually runs (never a compile-time constant -- a loop creating one
+    // closure per iteration must capture THAT iteration's own values, not
+    // share one snapshot) by reading each of the site's own captures
+    // straight out of the CURRENTLY EXECUTING frame's own `slots` (see
+    // ClosureSite's own doc comment for why every capture, however deeply
+    // the literal was originally nested, always resolves against the one
+    // chunk actually running Op::MakeClosure), and constructs
+    // Closure{node, capturedTrail} -- reusing Closure::capturedLet (value.hpp)
+    // and callCtxFor's existing capturedLet-rooting (user_calls.cpp)
+    // UNCHANGED: invoking this closure later (always via the interpreter,
+    // see ClosureSite's own doc comment for why its body is never itself
+    // compiled) works exactly like any interpreter-created escaping closure
+    // always has, no new invocation-side code needed at all. Replaces
+    // Op::PushConst's frozen `Closure{&n, nullptr}` specifically for a
+    // literal whose (transitively merged) capture set is non-empty; a
+    // literal that closes over nothing at all -- even transitively -- still
+    // takes the cheaper PushConst path, unchanged.
+    MakeClosure,
+
     // A call whose callee isn't statically resolvable to a builtin or a
     // named FunctionDeclaration (see CallFn) -- the callee expression is
     // compiled to push its own Value first, THEN each argument (so at
@@ -224,10 +256,47 @@ struct CompiledChunk {
     // inside AT COMPILE TIME (matched at runtime via Evaluator::
     // findUpvalue's exact-identity search over the live call stack, the
     // same identity CallStackFrame::declNode is stamped with), `slot` is
-    // that declaration's own slot number for the captured variable.
+    // that declaration's own slot number for the captured variable. `name`
+    // is that same variable's source name -- unused by Op::LoadUpvalue
+    // itself, needed by Op::MakeClosure's ClosureSite (below), which builds
+    // a NAME-keyed captured environment (Closure::capturedLet is a
+    // TrailView<Value>, looked up by name at invocation time, exactly like
+    // every other escaping closure) rather than a slot-indexed one.
     struct UpvalueRef {
         const oscad::ASTNode* targetDecl = nullptr;
         int slot = 0;
+        std::string name;
+    };
+
+    // One FunctionLiteral's own capture list for Op::MakeClosure, computed
+    // at compile time (bytecode_compiler.cpp's FunctionLiteral case) as the
+    // TRANSITIVE union of: every free variable `node` itself references
+    // from outside its own body, PLUS -- for each FunctionLiteral nested
+    // anywhere within `node` (however deep) -- whatever THAT nested
+    // literal's own ClosureSite still needed from beyond `node`'s own scope
+    // (i.e. any capture whose resolution target isn't `node` itself). This
+    // "bubbling" is what makes a closure nested inside another compiled-
+    // creating closure resolve correctly even though the inner one's body
+    // is never itself compiled (see this struct's own body-compilation
+    // note below): by the time a real, running CompiledChunk executes
+    // Op::MakeClosure for `node`, every one of `captures`'s entries is
+    // guaranteed to resolve against THAT SAME running chunk's own `slots`
+    // array, regardless of how many literal-within-literal levels `node`
+    // was originally nested through in the source.
+    //
+    // `node`'s own BODY is deliberately never itself compiled/registered
+    // once it has any capture need (even an empty one bubbled up from
+    // something it contains) -- it always runs via the ordinary AST
+    // interpreter when invoked (Evaluator::lookupCompiledLiteralChunk finds
+    // no cache entry for it), using Closure::capturedLet exactly like any
+    // other escaping closure the interpreter creates directly. This keeps
+    // the whole feature to "make closure CREATION safe to compile"; a
+    // closure's own body additionally getting compiled too (its captures
+    // would need to read from this snapshot instead of a live-stack walk)
+    // is a natural follow-on, not attempted here.
+    struct ClosureSite {
+        const oscad::FunctionLiteral* node = nullptr;
+        std::vector<UpvalueRef> captures;
     };
 
     // One echo() expression form's own argument names, in source order --
@@ -245,6 +314,7 @@ struct CompiledChunk {
     std::vector<std::string> names;
     std::vector<CallSite> callSites;
     std::vector<UpvalueRef> upvalues;
+    std::vector<ClosureSite> closureSites;
     std::vector<EchoSite> echoSites;
     int numSlots = 0;
     // Count of distinct ListCompFor-assignment iterLists allocated across
@@ -252,6 +322,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.10 → openscad_cpp_evaluator-0.6.0}/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.10 → openscad_cpp_evaluator-0.6.0}/pyproject.toml

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

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

@@ -40,6 +40,33 @@ bool isListCompClauseKind(oscad::NodeKind kind) {
     }
 }
 
+// Merges `site`'s own captures into `out` for every entry that escapes
+// `owner` itself (targetDecl != owner) -- see ClosureSite's own doc comment
+// (bytecode.hpp) for why this "bubbling" is necessary: a literal nested
+// inside `owner` may need something from further out than `owner`'s own
+// scope, and since that inner literal's body is never itself compiled
+// (only ever invoked via the interpreter once it has any capture need),
+// `owner`'s OWN Op::MakeClosure must snapshot that name too -- otherwise
+// the inner literal's interpreter-resolved capturedLet ancestry, rooted at
+// whatever `owner` itself captured, would simply never contain it.
+// Dedupes by (targetDecl, slot): the same enclosing binding reached through
+// two different nested literals (or the same literal referencing it twice)
+// is still one capture to make.
+void bubbleEscapingCaptures(const CompiledChunk::ClosureSite& site, const oscad::ASTNode* owner,
+                             std::vector<CompiledChunk::UpvalueRef>& out) {
+    for (const auto& cap : site.captures) {
+        if (cap.targetDecl == owner) continue;
+        bool already = false;
+        for (const auto& existing : out) {
+            if (existing.targetDecl == cap.targetDecl && existing.slot == cap.slot) {
+                already = true;
+                break;
+            }
+        }
+        if (!already) out.push_back(cap);
+    }
+}
+
 // Compile-time name -> slot resolution, mirroring the LetOp/nested-scope
 // shadowing rules callCtx()/letChildCtx() apply at runtime: one frame per
 // LetOp (pushed/popped around its own assignments+body), innermost frame
@@ -128,6 +155,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,
@@ -135,7 +176,7 @@ public:
     // naturally resolve to the innermost active binding too.
     std::optional<CompiledChunk::UpvalueRef> resolveEnclosing(const std::string& name) const {
         for (auto it = enclosing_.rbegin(); it != enclosing_.rend(); ++it) {
-            if (auto slot = it->scope->resolve(name)) return CompiledChunk::UpvalueRef{it->decl, *slot};
+            if (auto slot = it->scope->resolve(name)) return CompiledChunk::UpvalueRef{it->decl, *slot, name};
         }
         return std::nullopt;
     }
@@ -171,6 +212,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,
@@ -238,20 +280,14 @@ public:
             // other point where its own free-variable references could be
             // resolved against this enclosing chain (AST nodes have no
             // parent pointers to discover it from later, see this file's
-            // own module notes). If the literal itself fails to compile
-            // (contains a call/echo/assert/unsupported construct, or its
-            // own free-variable resolution needs an upvalue chain going
-            // even deeper than what's captured here), the WHOLE containing
-            // declaration must also bail -- propagated by simply
-            // rethrowing, since an interpreter-executed literal nested
-            // inside a compiled container would silently read stale/undef
-            // values for the container's own (slot-only, never written to
-            // ctx.let_) locals otherwise. On success, the literal's own
-            // chunk is stashed in chunk_.nestedLiterals for
-            // Evaluator::lookupOrCompileChunk to flatten into
-            // literalChunkCache_; the emitted instruction just pushes the
-            // AST pointer as a Value, exactly like the interpreter's own
-            // `Value{&node}` (evalExpr's own FunctionLiteral case).
+            // own module notes). If the literal itself fails to compile as
+            // bytecode at all (contains an echo/assert/unsupported
+            // construct), the WHOLE containing declaration must also bail
+            // -- propagated by simply rethrowing -- since there's no lighter
+            // way left to find out what it captures (see
+            // bubbleEscapingCaptures' own doc comment for why a literal
+            // that DOES compile as bytecode no longer needs this bail just
+            // for referencing enclosing state).
             case NodeKind::FunctionLiteral: {
                 auto& n = static_cast<const oscad::FunctionLiteral&>(node);
                 std::vector<EnclosingLevel> childEnclosing = enclosing_;
@@ -261,33 +297,44 @@ public:
                                           *n.body)) {
                     throw NotCompilable{};
                 }
-                // A nested literal that reads ANY enclosing variable
-                // (literalChunk.upvalues non-empty) is compiled via
-                // Op::LoadUpvalue -- a live-call-stack walk (findUpvalue)
-                // that only ever resolves a still-active enclosing call,
-                // never a captured environment (see LoadUpvalue/
-                // findUpvalue's own doc comments: "this codebase has no
-                // escaping closures"). A closure that escapes its creating
-                // call (returned, stored, passed on -- see Closure's own
-                // doc comment, value.hpp, for the motivating BOSL2
-                // example) would silently read undef for every captured
-                // variable through this path. Bailing the WHOLE containing
-                // compilation here forces such a function to run through
-                // the interpreter instead, which DOES support escaping
-                // closures correctly (evalExpr's FunctionLiteral case
-                // captures ctx.let_ itself). A literal with no upvalues at
-                // all (doesn't reference anything from an enclosing scope)
-                // has nothing that needs escaping-capture support, so it's
-                // unaffected and keeps compiling normally.
-                if (!literalChunk.upvalues.empty()) throw NotCompilable{};
-                chunk_.nestedLiterals.emplace_back(&n, std::move(literalChunk));
-                // No captured `let_` trail here (nullptr) -- a compile-time
-                // constant can't carry per-invocation runtime state, but
-                // (per the upvalues check just above) this literal doesn't
-                // reference anything outside itself, so there is nothing
-                // capture. Not a regression; just not (yet) extended here.
-                out.push_back({Op::PushConst, internConst(Value{std::make_shared<const Closure>(Closure{&n, nullptr})}),
-                               0, nullptr});
+                // Effective capture set: `n`'s own direct free-variable
+                // references, plus -- transitively -- whatever any literal
+                // nested inside `n` still needs from beyond `n`'s own scope
+                // (see bubbleEscapingCaptures' own doc comment, above, and
+                // ClosureSite's, bytecode.hpp).
+                std::vector<CompiledChunk::UpvalueRef> effectiveCaptures = literalChunk.upvalues;
+                for (const auto& nestedSite : literalChunk.closureSites) {
+                    bubbleEscapingCaptures(nestedSite, &n, effectiveCaptures);
+                }
+                if (effectiveCaptures.empty()) {
+                    // Closes over nothing at all, even transitively -- the
+                    // existing fast path: a single frozen constant works
+                    // for every invocation, and this literal's own compiled
+                    // chunk (possibly containing its OWN MakeClosure sites
+                    // for anything nested inside IT that closes only over
+                    // ITS OWN scope) is genuinely usable, registered as
+                    // before.
+                    chunk_.nestedLiterals.emplace_back(&n, std::move(literalChunk));
+                    out.push_back(
+                        {Op::PushConst, internConst(Value{std::make_shared<const Closure>(Closure{&n, nullptr})}), 0,
+                         nullptr});
+                    return;
+                }
+                // Escaping-closure support (Op::MakeClosure, bytecode.hpp).
+                // `literalChunk`'s own bytecode is discarded here -- its own
+                // upvalue reads would resolve via the live-call-stack walk
+                // (Op::LoadUpvalue), which is wrong for a closure that
+                // outlives its creator -- so this literal always runs
+                // interpreted when invoked instead (Evaluator::
+                // lookupCompiledLiteralChunk finds no cache entry for it),
+                // using the exact same Closure::capturedLet machinery every
+                // other escaping closure the interpreter creates directly
+                // already relies on. Only `effectiveCaptures` (the names/
+                // slots to snapshot right now) survives from the discarded
+                // compile attempt.
+                int siteIdx = static_cast<int>(chunk_.closureSites.size());
+                chunk_.closureSites.push_back(CompiledChunk::ClosureSite{&n, std::move(effectiveCaptures)});
+                out.push_back({Op::MakeClosure, siteIdx, 0, nullptr});
                 return;
             }
             case NodeKind::RangeLiteral: {
@@ -609,6 +656,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);

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

@@ -4,6 +4,7 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/function_builtins.hpp"
 #include "openscad_cpp_evaluator/import_builtin.hpp"
+#include "openscad_cpp_evaluator/scope_trail.hpp"
 
 #include "openscad_cpp_parser/ast/declarations.hpp"
 
@@ -132,6 +133,33 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                 ++pc;
                 break;
             }
+            case Op::MakeClosure: {
+                // Builds a FRESH captured environment every time this
+                // instruction actually runs (never a compile-time constant
+                // -- a loop creating one closure per iteration must capture
+                // THAT iteration's own values, not share one snapshot) by
+                // reading each of the site's own captures straight out of
+                // THIS frame's own `slots` -- see ClosureSite's own doc
+                // comment (bytecode.hpp) for why every capture, however
+                // deeply the literal was originally nested, is guaranteed
+                // to resolve against this SAME currently-running chunk.
+                // The resulting Closure::capturedLet is a real, standalone
+                // TrailView (isolated root -- nothing else shares it, and
+                // it owes nothing to `ctx.let_`, which a compiled call
+                // never populates -- see bindCompiledArgs' own doc
+                // comment), so invoking this closure later works through
+                // the EXACT same callCtxFor/capturedLetTrail machinery
+                // every interpreter-created escaping closure already uses,
+                // unchanged.
+                const CompiledChunk::ClosureSite& site = chunk.closureSites[static_cast<size_t>(ins.a)];
+                auto capturedTrail = TrailView<Value>::makeRoot();
+                for (const auto& cap : site.captures) {
+                    capturedTrail->set(cap.name, slots[static_cast<size_t>(cap.slot)]);
+                }
+                stack.push_back(Value{std::make_shared<const Closure>(Closure{site.node, std::move(capturedTrail)})});
+                ++pc;
+                break;
+            }
             case Op::Range: {
                 Value step = std::move(stack.back());
                 stack.pop_back();

{openscad_cpp_evaluator-0.4.10 → openscad_cpp_evaluator-0.6.0}/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) {