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

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

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

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

@@ -100,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
@@ -225,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 --
@@ -246,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

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

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

{openscad_cpp_evaluator-0.5.1 → openscad_cpp_evaluator-0.6.1}/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
@@ -149,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;
     }
@@ -253,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_;
@@ -276,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: {

{openscad_cpp_evaluator-0.5.1 → openscad_cpp_evaluator-0.6.1}/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();
@@ -636,10 +664,38 @@ Value runCompiledFunctionFromBound(Evaluator& ev, const CompiledChunk& chunk, co
 // *stack* growth (what this trampoline exists to eliminate) for heap
 // growth instead -- O(iteration count) EvalContext objects, bounded by
 // available RAM rather than a ~few-MB thread stack.
+namespace {
+// Tears a trampoline's own `chain` down back-to-front on EVERY exit path --
+// normal return OR exception unwind (recordTailCallHop's own recursion-guard
+// error is the exact case that matters: an infinite tail-recursive function
+// with no base case throws out of the loop entirely, bypassing any teardown
+// code placed after it). Relying on `chain` simply falling out of scope
+// instead is NOT equivalent: std::vector<T>'s own element-destruction order
+// is unspecified by the standard -- libc++ destroys back-to-front (matching
+// ScopeTrailStorage::popLevel's own "scan from the back" doc comment, which
+// assumes the level being popped is usually the most recently pushed one --
+// O(1) per pop that way), but libstdc++ destroys front-to-back, the
+// adversarial order for that same scan -- each pop then walks almost the
+// entire remaining vector, turning an intended O(N) teardown into a real,
+// measured O(N^2) (see issue #50: an N-scaling experiment plus a minimal
+// repro proving libc++/libstdc++ disagree on std::vector<T>::clear()'s
+// destruction order for identical source). Popping back-to-front explicitly,
+// via a destructor that always runs before `chain`'s own, is correct AND
+// O(N) on every standard library and every exit path, not just the ones
+// that happen to agree with libc++ and return normally.
+struct ChainTeardown {
+    std::vector<EvalContext>& chain;
+    ~ChainTeardown() {
+        while (!chain.empty()) chain.pop_back();
+    }
+};
+} // namespace
+
 Value runCompiledFunctionTrampoline(Evaluator& ev, const CompiledChunk& chunk,
                                      const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
                                      EvalContext& callerCtx, EvalContext& childCtx) {
     std::vector<EvalContext> chain{childCtx};
+    ChainTeardown teardown{chain};
     TailCallRequest req;
     Value result = runCompiledFunction(ev, chunk, arguments, callerCtx, chain.back(), &req);
     unsigned recursionGuard = 0;
@@ -661,6 +717,7 @@ Value runCompiledFunctionTrampoline(Evaluator& ev, const CompiledChunk& chunk,
 Value runCompiledFunctionFromBoundTrampoline(Evaluator& ev, const CompiledChunk& chunk, const BoundArgs& bound,
                                               EvalContext& childCtx) {
     std::vector<EvalContext> chain{childCtx};
+    ChainTeardown teardown{chain};
     TailCallRequest req;
     Value result = runCompiledFunctionFromBound(ev, chunk, bound, chain.back(), &req);
     unsigned recursionGuard = 0;

{openscad_cpp_evaluator-0.5.1 → openscad_cpp_evaluator-0.6.1}/src/user_calls.cpp

@@ -443,6 +443,32 @@ Value Evaluator::evalFunctionBodyTrampoline(const oscad::Expression& bodyExpr, E
     // dropped there) if memory ever measurably matters more than this
     // simpler all-or-nothing approach.
     std::vector<EvalContext> chain{ctx};
+    // Tears `chain` down back-to-front on EVERY exit path -- normal return
+    // OR exception unwind (recordTailCallHop's own recursion-guard error,
+    // below, is the exact case that matters: an infinite tail-recursive
+    // function with no base case throws out of this loop entirely,
+    // bypassing any teardown code placed after it). Relying on `chain`
+    // simply falling out of scope instead is NOT equivalent: std::vector<T>'s
+    // own element-destruction order is unspecified by the standard --
+    // libc++ destroys back-to-front (matching ScopeTrailStorage::popLevel's
+    // own "scan from the back" doc comment, which assumes the level being
+    // popped is usually the most recently pushed one -- O(1) per pop that
+    // way), but libstdc++ destroys front-to-back, the adversarial order for
+    // that same scan -- each pop then walks almost the entire remaining
+    // vector, turning an intended O(N) teardown into a real, measured
+    // O(N^2) (see issue #50: an N-scaling experiment plus a minimal repro
+    // proving libc++/libstdc++ disagree on std::vector<T>::clear()'s
+    // destruction order for identical source). Popping back-to-front
+    // explicitly, via a destructor that always runs before `chain`'s own,
+    // is correct AND O(N) on every standard library and every exit path,
+    // not just the ones that happen to agree with libc++ and return
+    // normally.
+    struct ChainTeardown {
+        std::vector<EvalContext>& chain;
+        ~ChainTeardown() {
+            while (!chain.empty()) chain.pop_back();
+        }
+    } teardown{chain};
     unsigned recursionGuard = 0;
     while (true) {
         auto result = simplifyTailStep(*expr, ctx);

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

@@ -380,14 +380,27 @@ TEST(BytecodeCompiler, VmOffAndVmOnAgreeOnListComprehensionCases) {
 }
 
 // -- Phase 2: closures/upvalues --------------------------------------------
-// A closure has no practical payoff unless something can call it BACK
-// while its capturing frame is still active (this codebase has no
-// escaping closures) -- the natural, most common shape is calling a
-// locally-held function value directly (`g(5)` where `g` is a let/param
-// bound to a FunctionLiteral), which needed its own dynamic-dispatch
-// opcode (CALL_DYNAMIC) alongside LOAD_UPVALUE to be reachable at all; see
-// bytecode_compiler.cpp's PrimaryCall case and bytecode_vm.cpp's
-// CallDynamic handler.
+// The natural, most common shape is calling a locally-held function value
+// directly (`g(5)` where `g` is a let/param bound to a FunctionLiteral),
+// which needed its own dynamic-dispatch opcode (CALL_DYNAMIC) alongside
+// LOAD_UPVALUE to be reachable at all; see bytecode_compiler.cpp's
+// PrimaryCall case and bytecode_vm.cpp's CallDynamic handler.
+//
+// Phase 2b (Op::MakeClosure) then made the CONTAINING function compilable
+// even when it creates a closure that escapes (returned, stored, passed on)
+// -- previously ANY FunctionLiteral referencing enclosing state bailed the
+// whole container, unconditionally, since Op::LOAD_UPVALUE's live-call-
+// stack walk (findUpvalue) can only resolve a still-active call frame,
+// never survive past it. Op::MakeClosure instead snapshots the exact
+// values a literal needs into a real TrailView<Value> at the moment of
+// creation (see bytecode.hpp's own doc comment), reusing Closure::
+// capturedLet/callCtxFor's existing capture-rooting unchanged -- so the
+// closure's own BODY still always runs interpreted when invoked (never
+// itself compiled), but the function that CREATES it no longer has to.
+// Several tests below predate Phase 2b and were written to describe the
+// OLD bail-and-fall-back behavior; their own comments now note what
+// actually happens post-Phase-2b instead of describing stale behavior as
+// if it were still current.
 
 TEST(BytecodeCompiler, ClosureCapturesParameterAndIsCalledDirectly) {
     ScopedVm vm(true);
@@ -457,13 +470,12 @@ TEST(BytecodeCompiler, ClosureOverNonActiveEnclosingCallResolvesCorrectly) {
     // (no escaping-closure support) as if it were the intended contract.
     // The fix: Value's FunctionLiteral alternative became a real Closure
     // (node + capturedLet, a shared_ptr<TrailView<Value>> snapshot of
-    // ctx.let_ at creation time, see value.hpp), and every FunctionLiteral
-    // whose body reads any enclosing-scope variable (non-empty upvalues)
-    // is now deliberately kept off the VM's compiled path (thrown as
-    // NotCompilable in bytecode_compiler.cpp) since Op::LoadUpvalue can
-    // only resolve a still-live call frame, never a captured environment --
-    // such a closure always runs through the interpreter, which reads its
-    // capturedLet directly.
+    // ctx.let_ at creation time, see value.hpp). Post-Phase-2b, `outer`
+    // itself now compiles too (Op::MakeClosure builds an equivalent
+    // snapshot from compiled code, see bytecode.hpp) -- only the returned
+    // closure's own body (`function(y) y + n`) still always runs
+    // interpreted when invoked, reading its capturedLet directly via the
+    // same callCtxFor path an interpreter-created closure always has.
     EXPECT_EQ(runCapturingEcho("function outer(n) = function(y) y + n;\n"
                                 "stored = outer(5);\n"
                                 "echo(stored(3));"),
@@ -490,6 +502,100 @@ TEST(BytecodeCompiler, VmOffAndVmOnAgreeOnClosureCases) {
     EXPECT_EQ(offResult, onResult);
 }
 
+TEST(BytecodeCompiler, MakeClosureLetsContainerCompileDespiteNonEscapingClosure) {
+    ScopedVm vm(true);
+    // `make` creates AND immediately calls `g` -- before Op::MakeClosure
+    // this bailed `make` entirely (any non-empty upvalues did, escaping or
+    // not). A debug hook alone forces the interpreter regardless of
+    // compilability (see DebugAttachedWithoutFastContinueAlwaysInterprets
+    // above), so fast-continue must be enabled (an empty breakpoint map --
+    // fast-continue "on", nothing set) to actually observe whether `make`
+    // runs compiled here.
+    const int stops = countDebugHookStops("function make(x) = let(g = function(y) y + x) g(5);\n"
+                                           "echo(make(10));",
+                                           std::unordered_map<std::string, std::set<int>>{});
+    EXPECT_EQ(stops, 4);
+}
+
+TEST(BytecodeCompiler, MakeClosureLetsContainerCompileDespiteEscapingClosure) {
+    ScopedVm vm(true);
+    // `outer` returns a closure that escapes past its own call entirely
+    // (called later, from a separate top-level statement, see
+    // ClosureOverNonActiveEnclosingCallResolvesCorrectly above for the
+    // correctness side of this same shape) -- `outer` itself now compiles
+    // too (fast-continue enabled for the same reason as the non-escaping
+    // case above). The ternary is needed here purely to make compiled-vs-
+    // interpreted OBSERVABLE via stop count: a body that's nothing but
+    // "return a closure" has no sub-expression checkpoints in the
+    // interpreter either way (a FunctionLiteral's own creation isn't itself
+    // a checkpoint), so it produces the SAME stop count whether `outer`
+    // compiled or not -- confirmed empirically, not assumed, by diffing
+    // this test's own result against the pre-Op::MakeClosure compiler.
+    const int stops = countDebugHookStops(
+        "function outer(n) = n > 0 ? function(y) y + n : function(y) y - n;\n"
+        "stored = outer(5);\n"
+        "echo(stored(3));",
+        std::unordered_map<std::string, std::set<int>>{});
+    EXPECT_EQ(stops, 6);
+}
+
+TEST(BytecodeCompiler, MakeClosureCapturesFreshValuePerInvocation) {
+    ScopedVm vm(true);
+    // Op::MakeClosure runs fresh every time the instruction is actually
+    // reached (never a compile-time constant) -- a closure built once per
+    // list-comprehension iteration must capture THAT iteration's own `i`,
+    // not all share whatever `i` ended at. `make_adders(3)` returns
+    // [function(y) y+0, function(y) y+1, function(y) y+2]; calling each
+    // with 10 and summing proves each closed over its OWN value.
+    EXPECT_EQ(runCapturingEcho("function make_adders(n) = [for (i = [0:1:n-1]) function(y) y + i];\n"
+                                "fns = make_adders(3);\n"
+                                "echo(fns[0](10) + fns[1](10) + fns[2](10));"),
+              "ECHO: 33");
+}
+
+TEST(BytecodeCompiler, MakeClosureBubblesCaptureThroughAnIntermediateClosureLevel) {
+    ScopedVm vm(true);
+    // `inner` (nested inside `mid`, nested inside `outer`) references
+    // `outer`'s own `x` DIRECTLY, skipping `mid` entirely -- exercising
+    // bubbleEscapingCaptures' own transitive merge (bytecode_compiler.cpp):
+    // `mid`'s own ClosureSite must bubble this capture up so `outer`'s own
+    // Op::MakeClosure (for `mid`) snapshots `x` too, even though `mid`
+    // itself never reads `x`. Same values/shape as
+    // NestedClosureCapturesBothEnclosingLevels above, but this time
+    // `mid` escapes `outer` (returned, called from a separate statement)
+    // rather than being called back immediately -- so `outer` itself must
+    // now compile, and the correctness depends on the bubbled capture
+    // actually reaching `mid`'s own snapshot correctly.
+    const std::string script = "function outer(x) = let(mid = function(y) let(inner = function(z) x + y + z) "
+                                "inner(1)) mid;\n"
+                                "stored = outer(100);\n"
+                                "echo(stored(10));";
+    EXPECT_EQ(runCapturingEcho(script), "ECHO: 111");
+}
+
+TEST(BytecodeCompiler, ClosureWithDollarParameterStillBailsContainer) {
+    ScopedVm vm(true);
+    // Residual, deliberate limitation: a FunctionLiteral with its OWN
+    // dollar-prefixed parameter still fails compileFunctionLike outright
+    // (same $-prefixed-parameter rule as a plain named function, see
+    // DollarPrefixedParameterBailsCompilationAndStillWorks above) -- there's
+    // no lighter way left to discover what it captures in that case, so the
+    // WHOLE containing declaration still bails (throw NotCompilable), same
+    // as before Op::MakeClosure. Value must still be correct via the
+    // interpreter fallback.
+    const int stops = countDebugHookStops(
+        "function outer(x) = let(g = function(y, $fn) y + x + $fn) g(5, $fn=2);\n"
+        "echo(outer(10));",
+        std::nullopt);
+    // `outer` never compiles at all here (more than 1 stop for its own
+    // call), unlike MakeClosureLetsContainerCompileDespiteNonEscapingClosure
+    // above where the analogous ($-free) container compiles to 1.
+    EXPECT_GT(stops, 2);
+    EXPECT_EQ(runCapturingEcho("function outer(x) = let(g = function(y, $fn) y + x + $fn) g(5, $fn=2);\n"
+                                "echo(outer(10));"),
+              "ECHO: 17");
+}
+
 // -- Tail-call optimization, VM path (Phase B) -----------------------------
 //
 // Mirrors tests/test_tail_calls.cpp's own Phase A (interpreter) suite, but
@@ -537,13 +643,17 @@ TEST(BytecodeCompiler, MixedCompiledInterpretedTailChainStaysCorrect) {
 
 TEST(BytecodeCompiler, ClosureNestedTailCallUnderVmFallsBackAndStillResolves) {
     ScopedVm vm(true);
-    // Same closure-nesting hazard as the interpreter path's own
+    // `g` (a closure over `make`'s own `x`) is called in tail position from
+    // `make`'s own compiled body -- but `g`'s own body is never itself
+    // compiled post-Phase-2b (Op::MakeClosure's whole point is to let
+    // `make` compile despite creating `g`; `g` still always runs
+    // interpreted when invoked, see Op::MakeClosure's own doc comment,
+    // bytecode.hpp). CallDynamicTail's handler therefore finds no compiled
+    // chunk for `g` (Evaluator::lookupCompiledLiteralChunk returns nullptr)
+    // and falls back to a real evalFunctionLiteralFromBound call instead of
+    // trampolining, exactly like the interpreter path's own
     // ClosureNestedTailCallFallsBackToRealRecursionAndStillResolves
-    // (test_tail_calls.cpp) -- g's own call is lexically nested inside
-    // make's body (a closure over `x`, read via Op::LoadUpvalue), so
-    // isolatedCallCtxFor must return nullopt for it, and CallDynamicTail's
-    // handler must fall back to a real evalFunctionLiteralFromBound call
-    // instead of trampolining.
+    // (test_tail_calls.cpp).
     const std::string script = "function make(x) = let(g = function(y) y + x) g(5);\necho(make(10));";
     EXPECT_EQ(runCapturingEcho(script), "ECHO: 15");
 }

{openscad_cpp_evaluator-0.5.1 → openscad_cpp_evaluator-0.6.1}/tests/test_tail_calls.cpp

@@ -19,6 +19,7 @@
 
 #include "test_helpers.hpp"
 
+#include <chrono>
 #include <gtest/gtest.h>
 
 using namespace oscadeval;
@@ -153,6 +154,34 @@ TEST(TailCalls, InfiniteTailRecursionErrorMentionsTheFunctionName) {
     }
 }
 
+TEST(TailCalls, InfiniteTailRecursionHitsTheCapInBoundedWallTime) {
+    // Regression tripwire for issue #50: evalFunctionBodyTrampoline's own
+    // `chain` (every hop's EvalContext, kept alive for $-var ancestry --
+    // see its own doc comment) used to rely on std::vector<EvalContext>'s
+    // OWN destructor to tear itself down, whose element-destruction order
+    // is unspecified by the standard. libstdc++ (GCC) and, per CI evidence,
+    // MSVC destroy front-to-back -- the adversarial order for
+    // ScopeTrailStorage::popLevel's "scan from the back" optimization
+    // (its own doc comment), turning an intended O(N) teardown into a
+    // real, measured O(N^2): the exact same 1,000,000-iteration script
+    // below took 25-50+ minutes on GCC/MSVC CI runners before the fix
+    // (an explicit back-to-front teardown, immune to the underlying
+    // vector's own unspecified order), vs ~1s on Clang/libc++ throughout.
+    // ponytail: generous fixed ceiling, not a strict perf target -- trips
+    // only on a real regression (this exact O(N^2) reintroduced), not
+    // machine noise; raise if a slower CI runner ever needs it.
+    ScopedVm vm(false);
+    Evaluator ev;
+    auto ast = parseSrc("function loop(n) = loop(n + 1);\nresult = loop(0);");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    const auto start = std::chrono::steady_clock::now();
+    EXPECT_THROW(ev.resolveTree(ast, ctx), EvalError);
+    const double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
+    constexpr double kCeilingMs = 30000.0;
+    EXPECT_LT(ms, kCeilingMs) << "took " << ms << "ms -- possible O(N^2) regression, see issue #50";
+}
+
 TEST(TailCalls, ErrorThrownDeepInATailChainProducesABoundedTrace) {
     ScopedVm vm(false);
     Evaluator ev;