openscad-cpp-evaluator 0.4.6__tar.gz → 0.4.8__tar.gz

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/PKG-INFO

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

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/include/openscad_cpp_evaluator/eval_context.hpp

@@ -105,6 +105,23 @@ struct EvalContext {
                          std::shared_ptr<const ChildrenNodeList> newChildrenNodes = nullptr,
                          const EvalContext* newChildrenCallerCtx = nullptr) const;
 
+    // Identical to callCtx() except `let_`'s new isolated level is opened
+    // from `capturedLet` (a closure's own captured defining-scope trail,
+    // see Closure's doc comment in value.hpp) instead of `this->let_`.
+    // Needed specifically for an ESCAPED closure call -- one where
+    // callCtxFor's own closure-nesting check (still-live enclosing call on
+    // callStack_) comes back false, meaning the ordinary ancestry walk from
+    // `this` (the CALL SITE's context) has no path back to wherever the
+    // closure's own captured variables live. `dyn`/`dynPositions` still
+    // derive from `this` exactly like callCtx() -- $-vars are dynamically
+    // scoped (the caller's own $-vars, not the closure's definer's), so
+    // they're unaffected by where the closure came from.
+    EvalContext callCtxFromCapturedLet(const std::shared_ptr<TrailView<Value>>& capturedLet,
+                                        const oscad::Scope* newScope = nullptr,
+                                        std::optional<std::array<double, 4>> newColor = std::nullopt,
+                                        std::shared_ptr<const ChildrenNodeList> newChildrenNodes = nullptr,
+                                        const EvalContext* newChildrenCallerCtx = nullptr) const;
+
     // let(...)/list-comprehension let() scoping: opens a new level for all
     // four trails, floor unchanged on every one (reads see through to the
     // parent; this let-body's own writes -- including to dyn/dynPositions/

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -303,7 +303,7 @@ public:
     // for) -- `bound` is matched against `funcNode`'s OWN parameters
     // (discovered now, not at compile time, since the callee wasn't
     // statically known). Mirrors evalFunctionLiteral exactly otherwise.
-    Value evalFunctionLiteralFromBound(const oscad::FunctionLiteral& funcNode, BoundArgs bound, EvalContext& ctx,
+    Value evalFunctionLiteralFromBound(const Closure& closure, BoundArgs bound, EvalContext& ctx,
                                         const oscad::Position* callPos);
 
     // Testing-only override, checked before the (once-cached) env var --
@@ -466,9 +466,18 @@ private:
     // (see CallStackFrame::upvalueParent's own doc comment for the real
     // scenario this was caught on -- a closure passed through an
     // unrelated intermediary function).
+    // `capturedLet`: non-null only for a FunctionLiteral *value* callee
+    // (see Closure's doc comment, value.hpp) -- when the closure-nesting
+    // check below comes back false (the defining call has already
+    // returned -- an ESCAPED closure), the isolated call context is rooted
+    // at `capturedLet` instead of `ctx`'s own trail, so the closure's
+    // captured variables stay resolvable. Ignored (as if null) when the
+    // check comes back true: an actually-still-live enclosing call is
+    // already reachable via `ctx`'s own ancestry, the ordinary path.
     EvalContext callCtxFor(const oscad::ASTNode& decl, EvalContext& ctx, const oscad::Scope* scope,
                             std::shared_ptr<const ChildrenNodeList> childrenNodes = nullptr,
-                            const EvalContext* childrenCallerCtx = nullptr, bool* usedChildCtx = nullptr);
+                            const EvalContext* childrenCallerCtx = nullptr, bool* usedChildCtx = nullptr,
+                            const std::shared_ptr<TrailView<Value>>& capturedLet = nullptr);
 
     // Fills in any parameter not already present in `bound` (bindArgs'
     // own return value -- the authoritative "did the caller actually
@@ -629,7 +638,8 @@ private:
                                             const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& params,
                                             const oscad::Expression& body, bool hasCompiledChunk,
                                             const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
-                                            EvalContext& ctx, const oscad::Position& callPos);
+                                            EvalContext& ctx, const oscad::Position& callPos,
+                                            const std::shared_ptr<TrailView<Value>>& capturedLet = nullptr);
 
     // Marker for "not one of the 5 trampolinable node kinds" -- the
     // trampoline falls back to a genuine evalExpr(node, ctx) call for
@@ -655,7 +665,7 @@ private:
     Value evalUserFunction(const std::string& name, const oscad::FunctionDeclaration& decl,
                             const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
                             const oscad::ASTNode* callNode);
-    Value evalFunctionLiteral(const oscad::FunctionLiteral& funcNode,
+    Value evalFunctionLiteral(const Closure& closure,
                                const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
                                const oscad::ASTNode* callNode);
 
@@ -741,7 +751,11 @@ public:
     // nullopt if `declNode` is closure-nested inside the currently-active
     // call, in which case the caller must fall back to a real recursive
     // call (evalUserFunctionFromBound/evalFunctionLiteralFromBound).
-    std::optional<EvalContext> isolatedCallCtxFor(const oscad::ASTNode& declNode, EvalContext& ctx);
+    // `capturedLet`: see callCtxFor's own doc comment -- pass the callee
+    // closure's captured trail for a FunctionLiteral-value callee (nullptr
+    // for a named FunctionDeclaration callee, which has none).
+    std::optional<EvalContext> isolatedCallCtxFor(const oscad::ASTNode& declNode, EvalContext& ctx,
+                                                   const std::shared_ptr<TrailView<Value>>& capturedLet = nullptr);
 
     // Shared per-hop bookkeeping for BOTH trampolines (evalFunctionBodyTrampoline,
     // user_calls.cpp, AND runCompiledFunctionTrampoline/

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/include/openscad_cpp_evaluator/value.hpp

@@ -18,19 +18,23 @@ namespace oscadeval {
 
 struct ValueList;
 struct ValueObject;
+struct Closure;
 
 using ListPtr = std::shared_ptr<const ValueList>;
 using ObjectPtr = std::shared_ptr<const ValueObject>;
+using ClosurePtr = std::shared_ptr<const Closure>;
 
 // The OpenSCAD dynamic value type. `bool` is a distinct alternative from
 // `double` throughout the evaluator -- never implicitly coerced, unlike
 // Python's own bool-is-int -- see every free function below.
 //
-// A function-literal *value* (`g = function(x) x*2;`) is the AST node
-// pointer itself, mirroring the Python reference's _expr_function_literal
-// (`return node`) -- no separate closure-capture wrapper. Non-owning; valid
-// as long as the parsed AST it points into is alive (see evaluator.hpp's
-// ownership contract, added in a later phase).
+// A function-literal *value* (`g = function(x) x*2;`) is a Closure: the AST
+// node pointer plus a captured snapshot of its defining scope's own `let_`
+// trail (see Closure's own doc comment below) -- unlike the Python
+// reference's _expr_function_literal (a bare `return node`, no capture at
+// all), needed for a closure that outlives the call that created it (see
+// Closure's doc comment for the motivating BOSL2 example and why the
+// simpler bare-pointer approach silently breaks that pattern).
 using Value = std::variant<std::monostate, // undef
                             bool,
                             double, // OpenSCAD has one numeric type
@@ -38,7 +42,52 @@ using Value = std::variant<std::monostate, // undef
                             ListPtr,
                             OscRange,
                             ObjectPtr,
-                            const oscad::FunctionLiteral*>;
+                            ClosurePtr>;
+
+// A function-literal value: the AST node (params/body, non-owning -- valid
+// as long as the parsed AST it points into is alive, same ownership
+// contract as every other raw AST pointer this evaluator holds) plus
+// `capturedLet`, a type-erased `shared_ptr<TrailView<Value>>` (see
+// scope_trail.hpp) snapshotting the `let_` trail live at the moment this
+// literal was evaluated into a value. Type-erased here (not
+// `shared_ptr<TrailView<Value>>` directly) purely to avoid a value.hpp <->
+// scope_trail.hpp circular include (scope_trail.hpp already includes
+// value.hpp for Value itself); callers that need the typed pointer back
+// (eval_context.cpp, user_calls.cpp, bytecode_vm.cpp -- anywhere
+// scope_trail.hpp is already visible) use capturedLetTrail() below.
+//
+// WHY this exists: a plain `TrailView` level is popped (and its bindings
+// destroyed) the instant the EvalContext holding it goes out of scope --
+// fine for ordinary nested evaluation, wrong for a closure that ESCAPES
+// its creating call, e.g. BOSL2's `hashmap()`:
+//   function make_closure(captured) = function(k) captured + k;
+//   c = make_closure(10);
+//   echo(c(5));  // must be 15 -- `captured` has to survive make_closure()
+//                // having already returned by the time c(5) runs.
+// Holding this shared_ptr copy keeps that trail level's refcount above
+// zero for as long as ANY closure value referencing it is still reachable,
+// so `captured` stays resolvable via the ordinary ancestry-walk lookup
+// long after the call that bound it has returned -- no snapshot/copy of
+// the bindings themselves needed, just extending what already exists.
+// `Closure::operator==` compares `node` only (matching the old bare-
+// pointer equality exactly) -- two closures over the same AST node are
+// still "the same function", regardless of what each captured.
+struct Closure {
+    const oscad::FunctionLiteral* node = nullptr;
+    std::shared_ptr<void> capturedLet;
+
+    friend bool operator==(const Closure& a, const Closure& b) { return a.node == b.node; }
+};
+
+template <typename T>
+class TrailView;
+
+// Typed access to Closure::capturedLet -- see its own doc comment for why
+// the field itself is type-erased. Only ever called where scope_trail.hpp
+// is already included.
+inline std::shared_ptr<TrailView<Value>> capturedLetTrail(const Closure& c) {
+    return std::static_pointer_cast<TrailView<Value>>(c.capturedLet);
+}
 
 // Defined after Value so both can hold Value by value -- the standard
 // recursive-variant pattern (indirection through a forward-declared,

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/pyproject.toml

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

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/builtins/function_builtins.cpp

@@ -615,7 +615,7 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         }
         case BuiltinFnId::IsFunction: {
             const Value x = getArg(args, 0, "x", Value{});
-            return Value{std::holds_alternative<const oscad::FunctionLiteral*>(x) && std::get<const oscad::FunctionLiteral*>(x) != nullptr};
+            return Value{std::holds_alternative<ClosurePtr>(x) && std::get<ClosurePtr>(x) != nullptr};
         }
         case BuiltinFnId::IsObject: {
             const Value x = getArg(args, 0, "x", Value{});

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/bytecode_compiler.cpp

@@ -261,8 +261,33 @@ 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));
-                out.push_back({Op::PushConst, internConst(Value{&n}), 0, nullptr});
+                // 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});
                 return;
             }
             case NodeKind::RangeLiteral: {

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/bytecode_vm.cpp

@@ -342,22 +342,23 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                 Value callee = std::move(stack.back());
                 stack.pop_back();
                 Value result;
-                if (const auto* flPtr = std::get_if<const oscad::FunctionLiteral*>(&callee); flPtr && *flPtr) {
+                if (const auto* closurePtr = std::get_if<ClosurePtr>(&callee); closurePtr && *closurePtr) {
+                    const Closure& closure = **closurePtr;
                     BoundArgs bound;
                     bound.reserve(argCount);
                     size_t positionalIdx = 0;
-                    const size_t nparams = (*flPtr)->parameters.size();
+                    const size_t nparams = closure.node->parameters.size();
                     for (size_t i = 0; i < argCount; ++i) {
                         if (site.argNames[i]) {
                             bound.set(*site.argNames[i], std::move(args[i]));
                         } else {
                             if (positionalIdx < nparams) {
-                                bound.set((*flPtr)->parameters[positionalIdx]->name->name, std::move(args[i]));
+                                bound.set(closure.node->parameters[positionalIdx]->name->name, std::move(args[i]));
                             }
                             ++positionalIdx;
                         }
                     }
-                    result = ev.evalFunctionLiteralFromBound(**flPtr, std::move(bound), ctx, ins.pos);
+                    result = ev.evalFunctionLiteralFromBound(closure, std::move(bound), ctx, ins.pos);
                 } else if (!site.calleeName.empty()) {
                     ev.warn("Ignoring unknown function '" + site.calleeName + "'", ins.pos);
                 }
@@ -424,8 +425,9 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                 Value callee = std::move(stack.back());
                 stack.pop_back();
                 Value result;
-                if (const auto* flPtr = std::get_if<const oscad::FunctionLiteral*>(&callee); flPtr && *flPtr) {
-                    const oscad::FunctionLiteral& funcNode = **flPtr;
+                if (const auto* closurePtr = std::get_if<ClosurePtr>(&callee); closurePtr && *closurePtr) {
+                    const Closure& closure = **closurePtr;
+                    const oscad::FunctionLiteral& funcNode = *closure.node;
                     BoundArgs bound;
                     bound.reserve(argCount);
                     size_t positionalIdx = 0;
@@ -441,7 +443,7 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                         }
                     }
                     if (tailOut != nullptr) {
-                        if (auto hopCtx = ev.isolatedCallCtxFor(funcNode, ctx)) {
+                        if (auto hopCtx = ev.isolatedCallCtxFor(funcNode, ctx, capturedLetTrail(closure))) {
                             if (ev.lookupCompiledLiteralChunk(funcNode) != nullptr) {
                                 tailOut->decl = nullptr;
                                 tailOut->literal = &funcNode;
@@ -453,7 +455,7 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                             }
                         }
                     }
-                    result = ev.evalFunctionLiteralFromBound(funcNode, std::move(bound), ctx, ins.pos);
+                    result = ev.evalFunctionLiteralFromBound(closure, std::move(bound), ctx, ins.pos);
                 } else if (!site.calleeName.empty()) {
                     ev.warn("Ignoring unknown function '" + site.calleeName + "'", ins.pos);
                 }

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/eval_context.cpp

@@ -60,6 +60,31 @@ EvalContext EvalContext::callCtx(const oscad::Scope* newScope, std::optional<std
     return result;
 }
 
+EvalContext EvalContext::callCtxFromCapturedLet(const std::shared_ptr<TrailView<Value>>& capturedLet,
+                                                 const oscad::Scope* newScope,
+                                                 std::optional<std::array<double, 4>> newColor,
+                                                 std::shared_ptr<const ChildrenNodeList> newChildrenNodes,
+                                                 const EvalContext* newChildrenCallerCtx) const {
+    EvalContext result;
+    result.scope = newScope ? newScope : scope;
+    auto newDynTrail = dyn.trail()->openChild(/*isolate=*/false); // stays dynamically scoped through the CALL SITE
+    result.dyn = DynValueView(newDynTrail);
+    result.dynExplicit = DynExplicitView(newDynTrail);
+    // isolate=false: continue the ancestry chain THROUGH capturedLet, not
+    // terminate at it -- the entire point is inheriting the closure's own
+    // captured bindings (isolate=true would sever that immediately,
+    // making the capture pointless; the isolation this needs -- NOT
+    // seeing the call SITE's own locals -- already comes for free from
+    // rooting at capturedLet instead of at `this->let_` in the first
+    // place).
+    result.let_ = capturedLet->openChild(/*isolate=*/false);
+    result.dynPositions = dynPositions->openChild(true);
+    result.color = newColor.has_value() ? newColor : color;
+    result.childrenNodes = newChildrenNodes ? newChildrenNodes : std::make_shared<const ChildrenNodeList>();
+    result.childrenCallerCtx = newChildrenCallerCtx;
+    return result;
+}
+
 EvalContext EvalContext::letChildCtx() const {
     EvalContext result = *this;
     auto newDynTrail = dyn.trail()->openChild(/*isolate=*/false);

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/expr_eval.cpp

@@ -103,7 +103,23 @@ Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position*
     if (const Value* v = ctx.let_->find(name)) return *v;
 
     if (!name.empty() && name[0] == '$') {
-        if (const Value* v = ctx.dyn->find(name)) return *v;
+        // $-prefixed names are dynamic variables: a completely separate
+        // namespace from lexically-scoped identifiers, never requiring a
+        // scope declaration (unlike a bare identifier). Found via
+        // BelfrySCAD/BOSL2's constants.scad `get_slop()`
+        // (`is_undef($slop) ? 0 : $slop` with $slop never assigned
+        // anywhere) producing a spurious "Ignoring unknown variable
+        // '$slop'" warning here but not through the bytecode VM's
+        // Op::LoadDyn (bytecode_vm.cpp), which already does exactly
+        // this -- find in ctx.dyn, undef if absent, no scope-lookup
+        // fallback, no warning, ever. Verified against real OpenSCAD.app:
+        // no warning for a never-set $-variable. Must return here
+        // unconditionally rather than falling through to the
+        // scope->lookupVariable() check below, which can never resolve a
+        // $-name anyway (dynamic variables aren't scope-declarable) and
+        // exists only for plain identifiers.
+        const Value* v = ctx.dyn->find(name);
+        return v ? *v : Value{};
     }
 
     if (name == "PI") return Value{std::numbers::pi};
@@ -375,11 +391,17 @@ Value Evaluator::evalExpr(const oscad::Expression& node, EvalContext& ctx) {
         case NodeKind::ListComprehension:
             return evalListLiteral(static_cast<const oscad::ListComprehension&>(node), ctx);
         case NodeKind::FunctionLiteral:
-            // A function-literal *value* is the AST node pointer itself --
-            // no closure-capture wrapper (evalFunctionLiteral re-resolves
-            // the node's own lexical scope at call time). Mirrors
-            // _expr_function_literal's `return node` exactly.
-            return Value{static_cast<const oscad::FunctionLiteral*>(&node)};
+            // A function-literal *value* captures ctx.let_ (extending that
+            // trail level's lifetime for as long as this Closure is
+            // reachable -- see Closure's own doc comment, value.hpp) so a
+            // closure that escapes this call (returned, stored, passed on)
+            // can still resolve variables from its defining scope after
+            // this call has returned. `dyn`/scope are NOT captured: $-vars
+            // are dynamically scoped (see the caller's own ctx.dyn at call
+            // time, matching real OpenSCAD), and the lexical scope is
+            // static AST data already reachable via the node itself.
+            return Value{std::make_shared<const Closure>(
+                Closure{static_cast<const oscad::FunctionLiteral*>(&node), ctx.let_})};
         case NodeKind::PrimaryCall:
             return evalFunctionCall(static_cast<const oscad::PrimaryCall&>(node), ctx);
         case NodeKind::LetOp:

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/manifold_cache.cpp

@@ -84,9 +84,9 @@ std::string canonValue(const Value& v) {
                 }
                 out += ")";
                 return out;
-            } else { // const oscad::FunctionLiteral*
+            } else { // ClosurePtr
                 char buf[32];
-                std::snprintf(buf, sizeof(buf), "F%p", static_cast<const void*>(val));
+                std::snprintf(buf, sizeof(buf), "F%p", val ? static_cast<const void*>(val->node) : nullptr);
                 return buf;
             }
         },

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/user_calls.cpp

@@ -104,7 +104,30 @@ BoundArgs Evaluator::bindArgs(const std::vector<std::unique_ptr<oscad::Parameter
 
 EvalContext Evaluator::callCtxFor(const oscad::ASTNode& decl, EvalContext& ctx, const oscad::Scope* scope,
                                    std::shared_ptr<const ChildrenNodeList> childrenNodes,
-                                   const EvalContext* childrenCallerCtx, bool* usedChildCtx) {
+                                   const EvalContext* childrenCallerCtx, bool* usedChildCtx,
+                                   const std::shared_ptr<TrailView<Value>>& capturedLet) {
+    // A closure's own captured environment (capturedLet, non-null for
+    // every interpreter-evaluated FunctionLiteral -- see expr_eval.cpp's
+    // own FunctionLiteral case) is always the correct root for this call,
+    // full stop -- checked BEFORE the live-call-stack walk below.
+    // callCtxFromCapturedLet roots the new scope at `capturedLet` itself,
+    // never at `ctx.let_`, so it's already correct regardless of whether
+    // `ctx` (the CALLER's own context) happens to be ancestor-linked back
+    // to the closure's declaring call or not. That distinction matters in
+    // exactly the case the live-frame walk below gets wrong: a closure
+    // declared inside function A, passed as a Value into a plain function
+    // B, and invoked from inside B's body. B's own ctx is isolated from
+    // A's (an ordinary call boundary, see EvalContext::callCtx's own
+    // isolate=true), so even though A's own frame may still be technically
+    // live on callStack_ (matching the containment check below) and this
+    // WOULD take the childCtx() branch, `ctx.childCtx()` continues B's own
+    // (isolated) ancestry, not A's -- silently losing every variable the
+    // closure captured from A. Skipping straight to capturedLet avoids
+    // this regardless of which frames happen to still be live.
+    if (capturedLet) {
+        if (usedChildCtx) *usedChildCtx = false;
+        return ctx.callCtxFromCapturedLet(capturedLet, scope, std::nullopt, std::move(childrenNodes), childrenCallerCtx);
+    }
     const oscad::Position& declPos = decl.position();
     for (const CallStackFrame& frame : callStack_) {
         const oscad::Position* outer = frame.declPosition;
@@ -119,9 +142,10 @@ EvalContext Evaluator::callCtxFor(const oscad::ASTNode& decl, EvalContext& ctx,
     return ctx.callCtx(scope, std::nullopt, std::move(childrenNodes), childrenCallerCtx);
 }
 
-std::optional<EvalContext> Evaluator::isolatedCallCtxFor(const oscad::ASTNode& declNode, EvalContext& ctx) {
+std::optional<EvalContext> Evaluator::isolatedCallCtxFor(const oscad::ASTNode& declNode, EvalContext& ctx,
+                                                          const std::shared_ptr<TrailView<Value>>& capturedLet) {
     bool usedChildCtx = false;
-    EvalContext result = callCtxFor(declNode, ctx, ctx.scope, nullptr, nullptr, &usedChildCtx);
+    EvalContext result = callCtxFor(declNode, ctx, ctx.scope, nullptr, nullptr, &usedChildCtx, capturedLet);
     if (usedChildCtx) return std::nullopt;
     return result;
 }
@@ -242,11 +266,11 @@ std::optional<Evaluator::TailStep> Evaluator::tryTailStepFor(
     const std::string& calleeName, const oscad::ASTNode& declNode,
     const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& params, const oscad::Expression& body,
     bool hasCompiledChunk, const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
-    const oscad::Position& callPos) {
+    const oscad::Position& callPos, const std::shared_ptr<TrailView<Value>>& capturedLet) {
     if (hasCompiledChunk) return std::nullopt;
     const oscad::Scope* fnScope = declNode.scope() ? declNode.scope() : ctx.scope;
     bool usedChildCtx = false;
-    EvalContext childCtx = callCtxFor(declNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx);
+    EvalContext childCtx = callCtxFor(declNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx, capturedLet);
     if (usedChildCtx) return std::nullopt;
     bindCallArgsInto(params, bindArgs(params, arguments, ctx), childCtx);
     TailStep step;
@@ -360,14 +384,16 @@ std::variant<Value, Evaluator::TailStep, Evaluator::NotTailStep> Evaluator::simp
             // directly. Never re-evaluate n.left below this point -- it
             // may itself be an arbitrary (side-effecting) expression.
             Value funcVal = leftId ? evalIdentifier(leftId->name, &leftId->position(), ctx, false) : evalExpr(*n.left, ctx);
-            if (const auto* flPtr = std::get_if<const oscad::FunctionLiteral*>(&funcVal); flPtr && *flPtr) {
-                const oscad::FunctionLiteral& funcNode = **flPtr;
+            if (const auto* closurePtr = std::get_if<ClosurePtr>(&funcVal); closurePtr && *closurePtr) {
+                const Closure& closure = **closurePtr;
+                const oscad::FunctionLiteral& funcNode = *closure.node;
                 checkDebug(n, ctx); // call-site stop, function-literal callee
                 const bool hasChunk = useBytecodeVm() && lookupCompiledLiteralChunk(funcNode) != nullptr;
-                std::optional<TailStep> step = tryTailStepFor("<function literal>", funcNode, funcNode.parameters,
-                                                               *funcNode.body, hasChunk, n.arguments, ctx, n.position());
+                std::optional<TailStep> step =
+                    tryTailStepFor("<function literal>", funcNode, funcNode.parameters, *funcNode.body, hasChunk,
+                                   n.arguments, ctx, n.position(), capturedLetTrail(closure));
                 if (step) return std::move(*step);
-                return Value{evalFunctionLiteral(funcNode, n.arguments, ctx, &n)};
+                return Value{evalFunctionLiteral(closure, n.arguments, ctx, &n)};
             }
 
             if (leftId) warn("Ignoring unknown function '" + leftId->name + "'", &n.position());
@@ -484,13 +510,15 @@ Value Evaluator::evalUserFunctionFromBound(const std::string& name, const oscad:
     });
 }
 
-Value Evaluator::evalFunctionLiteral(const oscad::FunctionLiteral& funcNode,
+Value Evaluator::evalFunctionLiteral(const Closure& closure,
                                       const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
                                       const oscad::ASTNode* callNode) {
+    const oscad::FunctionLiteral& funcNode = *closure.node;
     const oscad::Scope* fnScope = funcNode.scope() ? funcNode.scope() : ctx.scope;
     const int callerFrameIdx = callStack_.empty() ? -1 : static_cast<int>(callStack_.size()) - 1;
     bool usedChildCtx = false;
-    EvalContext childCtx = callCtxFor(funcNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx);
+    EvalContext childCtx =
+        callCtxFor(funcNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx, capturedLetTrail(closure));
     const int upvalueParent = usedChildCtx ? callerFrameIdx : -1;
 
     // A literal only ever has a compiled chunk if some OTHER declaration's
@@ -519,12 +547,14 @@ Value Evaluator::evalFunctionLiteral(const oscad::FunctionLiteral& funcNode,
                                  });
 }
 
-Value Evaluator::evalFunctionLiteralFromBound(const oscad::FunctionLiteral& funcNode, BoundArgs bound,
+Value Evaluator::evalFunctionLiteralFromBound(const Closure& closure, BoundArgs bound,
                                                EvalContext& ctx, const oscad::Position* callPos) {
+    const oscad::FunctionLiteral& funcNode = *closure.node;
     const oscad::Scope* fnScope = funcNode.scope() ? funcNode.scope() : ctx.scope;
     const int callerFrameIdx = callStack_.empty() ? -1 : static_cast<int>(callStack_.size()) - 1;
     bool usedChildCtx = false;
-    EvalContext childCtx = callCtxFor(funcNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx);
+    EvalContext childCtx =
+        callCtxFor(funcNode, ctx, fnScope, nullptr, nullptr, &usedChildCtx, capturedLetTrail(closure));
     const int upvalueParent = usedChildCtx ? callerFrameIdx : -1;
     const CompiledChunk* chunk = useBytecodeVm() ? lookupCompiledLiteralChunk(funcNode) : nullptr;
     if (!chunk) {
@@ -579,10 +609,10 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
     // g(3)`). warnIfUndef=false: probing here shouldn't itself warn
     // "unknown variable" if `left` isn't bound to anything -- a genuinely
     // unknown callee gets exactly one warning below, not two.
-    Value funcNode = leftId ? evalIdentifier(leftId->name, &leftId->position(), ctx, false) : evalExpr(*node.left, ctx);
-    if (const auto* flPtr = std::get_if<const oscad::FunctionLiteral*>(&funcNode); flPtr && *flPtr) {
+    Value funcVal = leftId ? evalIdentifier(leftId->name, &leftId->position(), ctx, false) : evalExpr(*node.left, ctx);
+    if (const auto* closurePtr = std::get_if<ClosurePtr>(&funcVal); closurePtr && *closurePtr) {
         checkDebug(node, ctx); // same call-site stop, function-literal callee
-        return evalFunctionLiteral(**flPtr, node.arguments, ctx, &node);
+        return evalFunctionLiteral(**closurePtr, node.arguments, ctx, &node);
     }
 
     if (leftId) {

{openscad_cpp_evaluator-0.4.6 → openscad_cpp_evaluator-0.4.8}/src/value.cpp

@@ -53,7 +53,7 @@ std::string oscTypeName(const Value& v) {
     if (std::holds_alternative<std::string>(v)) return "string";
     if (std::holds_alternative<ListPtr>(v)) return "vector";
     if (std::holds_alternative<ObjectPtr>(v)) return "object";
-    return "undefined"; // OscRange, FunctionLiteral*
+    return "undefined"; // OscRange, ClosurePtr
 }
 
 bool oscEqual(const Value& a, const Value& b) {
@@ -88,9 +88,21 @@ bool oscEqual(const Value& a, const Value& b) {
         return true;
     }
 
-    // Neither operand is a list or object here, so this only ever compares
-    // monostate/bool/double/string/OscRange/FunctionLiteral* against its own
-    // kind (variant::operator== checks the active index first).
+    // ClosurePtr is a shared_ptr -- its own operator== compares the pointee
+    // ADDRESS, not Closure::operator==(), so two independently-created
+    // closures over the identical AST node (the semantics this mirrors --
+    // see Closure's own doc comment) would wrongly compare unequal via the
+    // variant fallthrough below. Dereference and compare explicitly.
+    const ClosurePtr* ca = std::get_if<ClosurePtr>(&a);
+    const ClosurePtr* cb = std::get_if<ClosurePtr>(&b);
+    if (ca || cb) {
+        if (!ca || !cb || !*ca || !*cb) return false;
+        return **ca == **cb;
+    }
+
+    // Neither operand is a list, object, or closure here, so this only ever
+    // compares monostate/bool/double/string/OscRange against its own kind
+    // (variant::operator== checks the active index first).
     return a == b;
 }
 
@@ -107,7 +119,7 @@ bool truthy(const Value& v) {
     if (const ListPtr* l = std::get_if<ListPtr>(&v)) return *l && !(*l)->items.empty();
     if (const ObjectPtr* o = std::get_if<ObjectPtr>(&v)) return *o && !(*o)->items.empty();
     if (std::holds_alternative<std::monostate>(v)) return false;
-    return true; // OscRange, FunctionLiteral*
+    return true; // OscRange, ClosurePtr
 }
 
 bool oscComparable(const Value& a, const Value& b) {
@@ -325,7 +337,7 @@ std::string fmtValue(const Value& v) {
         return s + ")";
     }
     if (const std::string* s = std::get_if<std::string>(&v)) return "\"" + *s + "\"";
-    return "<function-literal>"; // const FunctionLiteral* -- no meaningful textual form in the reference either
+    return "<function-literal>"; // OscRange handled above; ClosurePtr has no meaningful textual form either
 }
 
 // (Range::numValues()'s own count, closed-form) -- 1 + floor((end-start)/step),