openscad-cpp-evaluator 0.37.0__tar.gz → 0.38.0__tar.gz

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/CLAUDE.md

@@ -1094,3 +1094,84 @@ than the current pause point). Ported identically (same qualifier syntax, same e
   profiling/debugging's own bookkeeping resets happen at the right point too.
 - `tools/cli/main.cpp` — a 3-line wrapper: builds `args` from `argv`, calls `runCli(args)` with the
   real `std::cin`/`std::cout`/`std::cerr`, returns its exit code.
+
+## `render()` in expression position
+
+`render()` has two jobs, decided by where it is written:
+
+```openscad
+render() cube(1);                       // STATEMENT -- draws, as always
+obj = render() { cube(1); };            // EXPRESSION -- measures, draws NOTHING
+```
+
+The expression form builds its children's geometry, measures it, extracts the
+mesh, and **discards the geometry**. It is the only way OpenSCAD can inspect its
+own geometry — volume, surface area, genus, bounding box, and the mesh itself.
+
+```openscad
+obj = render() difference() { cube(100); sphere(20); };
+echo(obj.volume, obj.genus, obj.boundingbox);
+polyhedron(obj);                        // straight back in
+```
+
+Keys — ordered, and the order is part of the API (`ValueObject` is an ordered
+vector and `oscEqual` is order-sensitive):
+
+| dim | keys |
+|---|---|
+| 3 | `vertices`, `faces`, `volume`, `area`, `genus`, `boundingbox`, `dim`, `vnf` |
+| 2 | `vertices`, `paths`, `area`, `perimeter`, `boundingbox`, `dim` |
+| 0 | the 3D key set, all zero, `boundingbox = undef` |
+
+`vertices`/`faces` are VNF-shaped — `[x,y,z]` points, 0-based N-gon index lists,
+**clockwise seen from outside** — so they feed `polyhedron()` and BOSL2 unchanged.
+`vnf` is the `[vertices, faces]` 2-list BOSL2 functions actually take.
+`polyhedron()` and `polygon()` also accept the object directly, and will accept
+*any* object carrying the right keys, not just one `render()` produced.
+
+### Things that will bite
+
+- **`render` is a reserved keyword.** It cannot be a variable, module, function,
+  argument, or member name. Required: LALR(1) cannot otherwise tell `render(` in
+  expression position from a function call, and bison's shift-over-reduce would
+  silently turn every function call in an expression into a module instantiation.
+- **`obj = render() cube(1);` does not parse.** A bare call's `child_statement`
+  swallows the `;`, leaving the assignment unterminated. Use
+  `render() { cube(1); }` or a form ending in `}`. Inherent to OpenSCAD's grammar.
+- **`genus` is Manifold's, for the whole result.** A cube with a sealed internal
+  cavity reports `-1`, not `0` — its boundary has two components. Correct, but
+  surprising.
+- **Nothing is drawn from any context** — top level, module body, function body,
+  list comprehension, ternary. That is what preserves function purity, and why no
+  context needs a special case.
+
+### Implementation notes
+
+`Evaluator::measureCsgSubtree` (`src/measure_geometry.cpp`) is the *only*
+implementation of "CSG subtree → `object()`"; both engines call it — the
+interpreter from `evalRenderExpr`, the VM from `Op::PopBuiltinWrap`'s
+`Kind::Measure` branch.
+
+`Evaluator::measuring_` is set for the whole generate. It suppresses the four
+writes that exist solely to describe *drawn* geometry — `idToNode`/`idToColor` in
+`tagGenerated` and `tagDisplayOnly`, the `restampCachedIds` call on a cache hit,
+and `cacheProducer_` — because those tables are cleared once per pass, so a leak
+is permanent and surfaces later as wrong click-to-source. It also suppresses
+`checkDebug`, which would otherwise inject stops at the paused statement's own
+`callStack_` depth. The **geometry cache stays on**: `cacheKey` is
+content-addressed, so an entry a measurement stores is genuinely reusable by the
+real render.
+
+Two details in the mesh conversion are load-bearing and silent when wrong: the
+winding is **reversed** on the way out (Manifold's `triVerts` is CCW), and
+vertices are welded by exact position (Manifold splits property-vertices, so
+without the weld the round-tripped `polyhedron()` is an *open* mesh). A reversed
+mesh still builds — `Status() == NoError` — but comes back with **negative
+volume**, so tests assert a positive volume and must never use `abs()`.
+
+On the VM side, `Kind::Measure` captures `(name, slot)` for every visible local
+at compile time and republishes them into the children's `EvalContext` at Push.
+A compiled function keeps its parameters in frame slots, which no `EvalContext`
+can see, and the children are statement opcodes that resolve names through the
+context — without this, `function f(w) = render() { cube(w); }.volume;` finds no
+`w` and silently measures nothing.

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/ast/ast_node.hpp

@@ -61,6 +61,10 @@ enum class NodeKind {
     PrimaryCall,
     PrimaryIndex,
     PrimaryMember,
+    // render() in EXPRESSION position -- evaluates its children as geometry
+    // and yields an object() of measurements. The STATEMENT form of render()
+    // is a plain ModularCall named "render"; only this one is new.
+    RenderExpression,
     // List comprehension
     ListCompLet,
     ListCompEach,

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/ast/expression.hpp

@@ -237,6 +237,33 @@ public:
     void buildScope(Scope& parentScope) override;
 };
 
+// `render()` in EXPRESSION position: `obj = render() { cube(10); };`
+//
+// Evaluates its children as geometry, measures the result, and yields an
+// object() -- it draws nothing. The STATEMENT form (`render() cube(1);`)
+// stays a plain ModularCall named "render"; this class exists only because
+// an Expression cannot be a ModuleInstantiation (they are siblings under
+// ASTNode, not parent/child).
+//
+// `arguments` and `children` deliberately mirror ModularCall's field types
+// so the evaluator can hand them straight to resolveCallArgs()/evalChildren()
+// with no adaptation. `children` is ASTNode, not ModuleInstantiation, for
+// the same reason ModularCall's is -- a `{ ... }` block is `statement*` and
+// may hold Assignments, which is why buildScope() below hoists.
+class RenderExpression : public Expression {
+public:
+    RenderExpression(Position position, std::vector<std::unique_ptr<Argument>> arguments,
+                     std::vector<std::unique_ptr<ASTNode>> children)
+        : Expression(NodeKind::RenderExpression, std::move(position)), arguments(std::move(arguments)),
+          children(std::move(children)) {}
+
+    std::vector<std::unique_ptr<Argument>> arguments;
+    std::vector<std::unique_ptr<ASTNode>> children;
+
+    std::string toString() const override;
+    void buildScope(Scope& parentScope) override;
+};
+
 // -- Unary operators --------------------------------------------------
 
 #define OSCAD_UNARY_OP(ClassName)                                                                                    \

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/ast/ast_node.cpp

@@ -47,6 +47,7 @@ const char* nodeKindName(NodeKind kind) {
         case NodeKind::PrimaryCall: return "PrimaryCall";
         case NodeKind::PrimaryIndex: return "PrimaryIndex";
         case NodeKind::PrimaryMember: return "PrimaryMember";
+        case NodeKind::RenderExpression: return "RenderExpression";
         case NodeKind::ListCompLet: return "ListCompLet";
         case NodeKind::ListCompEach: return "ListCompEach";
         case NodeKind::ListCompFor: return "ListCompFor";

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/ast/expression.cpp

@@ -1,6 +1,7 @@
 #include "openscad_cpp_parser/ast/expression.hpp"
 
 #include "format_utils.hpp"
+#include "openscad_cpp_parser/ast/scope_builder.hpp"
 #include "openscad_cpp_parser/scope.hpp"
 
 #include <array>
@@ -155,6 +156,47 @@ void FunctionLiteral::buildScope(Scope& parentScope) {
     body->buildScope(funcScope);
 }
 
+std::string RenderExpression::toString() const {
+    // Deliberately NOT ModuleInstantiation's formatChildBlock, which omits
+    // both braces (for a lone child) and every statement terminator, because
+    // for a STATEMENT the terminators come from the statement-level printer.
+    // A RenderExpression sits inside an expression, where nothing downstream
+    // adds them -- and `render() cube(1)` unbraced is precisely the form that
+    // does NOT parse (the child_statement swallows the `;`, leaving the
+    // enclosing assignment unterminated). So: always braces, always a `;`
+    // after every child.
+    //
+    // This must stay REPARSEABLE -- pretty_print.cpp's fmtExpr falls through
+    // to toString() for expression kinds it has no case for, so this string
+    // is what a formatter emits. NodeStr.RenderExpressionRoundTrips guards it.
+    //
+    // The unconditional `;` is safe even after a child that already ends in
+    // `}` (a nested block, a module declaration): a bare `;` is itself a legal
+    // statement (parser.y's `statement: ";"`), so a redundant one is a no-op.
+    std::string s = "render(" + joinToString(arguments, ", ") + ") { ";
+    for (const auto& c : children) {
+        s += c->toString() + "; ";
+    }
+    return s + "}";
+}
+
+void RenderExpression::buildScope(Scope& parentScope) {
+    // Same shape as ModularCall::buildScope minus the name lookup (there is
+    // no Identifier -- "render" is a keyword token here). The hoist is
+    // required: `render() { x = 1; cube(x); }` must resolve x.
+    setScope(parentScope);
+    for (auto& a : arguments) {
+        a->buildScope(parentScope);
+    }
+    if (!children.empty()) {
+        Scope& childrenScope = parentScope.childScope();
+        collectHoistedDeclarations(children, childrenScope);
+        for (auto& c : children) {
+            c->buildScope(childrenScope);
+        }
+    }
+}
+
 // -- Operator precedence for minimal-parenthesization toString() ----------
 //
 // Matches the reference's nodes.py::_PREC/_lp/_rp: toString() adds parens

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/grammar/driver.cpp

@@ -153,6 +153,11 @@ NodePtr makeListComprehension(ParserDriver& driver, const OscadLocation& loc, No
     return std::make_unique<ListComprehension>(driver.toPosition(loc), std::move(elements));
 }
 
+NodePtr makeRenderExpression(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodeList children) {
+    return std::make_unique<RenderExpression>(driver.toPosition(loc), nodeListCast<Argument>(std::move(arguments)),
+                                              std::move(children));
+}
+
 NodePtr makeModularCall(ParserDriver& driver, const OscadLocation& loc, const OscadLocation& nameLoc, std::string name,
                          NodeList arguments, NodeList children) {
     auto nameNode = makeIdentifier(driver, nameLoc, std::move(name));

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -132,6 +132,8 @@ NodePtr makeListCompIfElse(ParserDriver& driver, const OscadLocation& loc, NodeP
                             NodePtr falseExpr);
 NodePtr makeListComprehension(ParserDriver& driver, const OscadLocation& loc, NodeList elements);
 
+NodePtr makeRenderExpression(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodeList children);
+
 NodePtr makeModularCall(ParserDriver& driver, const OscadLocation& loc, const OscadLocation& nameLoc, std::string name,
                          NodeList arguments, NodeList children);
 NodePtr makeModularFor(ParserDriver& driver, const OscadLocation& loc, NodeList assignments, NodeList body);

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/grammar/lexer.l

@@ -47,6 +47,11 @@ const std::unordered_map<std::string, KeywordFactory>& keywordTable() {
         {"for", [](const OscadLocation& l) { return yy::parser::make_KW_FOR(l); }},
         {"intersection_for", [](const OscadLocation& l) { return yy::parser::make_KW_INTERSECTION_FOR(l); }},
         {"each", [](const OscadLocation& l) { return yy::parser::make_KW_EACH(l); }},
+        // Reserved so `render` can lead an EXPRESSION-position geometry block
+        // (`obj = render() { cube(1); };`). LALR(1) cannot otherwise tell that
+        // apart from a function call. Note `$render` still lexes as NAME --
+        // this table is keyed on the full IDENT text, including the `$`.
+        {"render", [](const OscadLocation& l) { return yy::parser::make_KW_RENDER(l); }},
         {"undef", [](const OscadLocation& l) { return yy::parser::make_KW_UNDEF(l); }},
         {"true", [](const OscadLocation& l) { return yy::parser::make_KW_TRUE(l); }},
         {"false", [](const OscadLocation& l) { return yy::parser::make_KW_FALSE(l); }},

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/grammar/parser.y

@@ -92,6 +92,7 @@
   KW_FOR "for"
   KW_INTERSECTION_FOR "intersection_for"
   KW_EACH "each"
+  KW_RENDER "render"
   KW_UNDEF "undef"
   KW_TRUE "true"
   KW_FALSE "false"
@@ -157,6 +158,7 @@
 %type <NodePtr> modifier_show_only modifier_highlight modifier_background modifier_disable
 %type <NodePtr> if_statement ifelse_statement
 %type <NodePtr> modular_for modular_intersection_for modular_let modular_assert modular_echo modular_call
+%type <NodePtr> render_stmt render_expr
 %type <NodePtr> expr opchain postfix primary
 %type <NodePtr> range_expr vector_expr vector_element
 %type <NodePtr> listcomp_elements listcomp_paren_expr listcomp_let listcomp_each
@@ -305,6 +307,7 @@ single_module_instantiation:
   | modular_assert               { $$ = std::move($1); }
   | modular_echo                  { $$ = std::move($1); }
   | modular_call                   { $$ = std::move($1); }
+  | render_stmt                     { $$ = std::move($1); }
   ;
 
 modular_for:
@@ -343,6 +346,16 @@ modular_call:
     }
   ;
 
+// `render` is a reserved keyword (see lexer.l) purely so the EXPRESSION form
+// below is unambiguous. The STATEMENT form still builds a plain ModularCall
+// named "render", so everything downstream -- builtin dispatch, the argument
+// allowlist, the pretty-printer, json_io -- is unchanged.
+render_stmt:
+    "render" "(" arguments ")" child_statement {
+      $$ = makeModularCall(driver, @$, @1, "render", std::move($3), std::move($5));
+    }
+  ;
+
 // -- Expressions ----------------------------------------------------------
 //
 // `expr` covers let/assert/echo/funclit_def/ternary plus the operator
@@ -406,6 +419,23 @@ primary:
   | STRING                       { $$ = makeStringLiteral(driver, @$, std::move($1)); }
   | NUMBER                         { $$ = makeNumberLiteral(driver, @$, $1); }
   | NAME                             { $$ = makeIdentifier(driver, @$, std::move($1)); }
+  | render_expr                       { $$ = std::move($1); }
+  ;
+
+// Same RHS as render_stmt, reached only from `primary`. This is NOT a
+// reduce/reduce conflict: LALR merges states only on identical LR(0) cores,
+// and after shifting "render" the statement and expression kernels differ --
+// no single state closes over both (statement-start closes over
+// module_instantiation; every expr-start position closes over no statement
+// nonterminal). Bison verifies this claim at build time via %expect.
+//
+// It lives in `primary` rather than `expr` so `render(){...}.volume` parses
+// through the existing `postfix "." NAME` rule, and so it can appear as an
+// argument, a list element, or an operand.
+render_expr:
+    "render" "(" arguments ")" child_statement {
+      $$ = makeRenderExpression(driver, @$, std::move($3), std::move($5));
+    }
   ;
 
 range_expr:

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/inline_comment_attach.cpp

@@ -295,6 +295,12 @@ void classifyNode(ASTNode& node, std::vector<ExprSlot>& exprFields, std::vector<
             addAstNodeList(static_cast<ListComprehension&>(node).elements, exprFields, nonExprChildren);
             break;
 
+        case NodeKind::RenderExpression: {
+            auto& n = static_cast<RenderExpression&>(node);
+            addArgumentExprList(n.arguments, exprFields);
+            addAstNodeList(n.children, exprFields, nonExprChildren);
+            break;
+        }
         case NodeKind::ModularCall: {
             auto& n = static_cast<ModularCall&>(node);
             addArgumentExprList(n.arguments, exprFields);

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/pretty_print.cpp

@@ -207,6 +207,7 @@ std::string fmtNode(const ASTNode& node, int indent, int w);
 std::string fmtExpr(const ASTNode& expr, int indent, int w);
 std::string fmtInst(const ASTNode& node, int indent, int w, const std::string& prefix);
 std::string fmtListElem(const ASTNode& elem, int indent, int w);
+std::string fmtBlock(const std::vector<std::unique_ptr<ASTNode>>& nodes, int indent, int w);
 
 std::string fmtAssign(const Assignment& a, int indent, int w) {
     return a.name->name + " = " + fmtExpr(*a.expr, indent, w);
@@ -508,6 +509,16 @@ std::string fmtExpr(const ASTNode& exprNode, int indent, int w) {
     if (auto* lc = dynamic_cast<const ListComprehension*>(&exprNode)) {
         return fmtListComprehension(*lc, indent, w);
     }
+    if (auto* r = dynamic_cast<const RenderExpression*>(&exprNode)) {
+        // fmtBlock, NOT fmtChild: fmtChild drops the braces for a lone child,
+        // and `x = render() cube(1);` does not parse -- the child_statement
+        // swallows the `;` and leaves the assignment unterminated. fmtBlock
+        // always braces and routes children through fmtNode, which is what
+        // supplies their statement terminators. This arm is why toString()'s
+        // own (reference-matching, terminator-free) child rendering never
+        // reaches emitted source.
+        return "render(" + joinToString(r->arguments, ", ") + ") " + fmtBlock(r->children, indent, w);
+    }
     return exprNode.toString();
 }
 

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/src/serialization/json_io.cpp

@@ -267,6 +267,13 @@ json toJsonImpl(const ASTNode& node, bool includePos) {
             j["elements"] = listToJson(static_cast<const ListComprehension&>(node).elements, includePos);
             break;
 
+        case NodeKind::RenderExpression: {
+            auto& n = static_cast<const RenderExpression&>(node);
+            j["arguments"] = listToJson(n.arguments, includePos);
+            j["children"] = listToJson(n.children, includePos);
+            break;
+        }
+
         case NodeKind::ModularCall: {
             auto& n = static_cast<const ModularCall&>(node);
             j["name"] = valueToJson(n.name.get(), includePos);
@@ -543,6 +550,11 @@ const std::unordered_map<std::string, Builder>& registry() {
              return std::make_unique<ListComprehension>(std::move(pos), listFromJson<ASTNode>(j, "elements"));
          }},
 
+        {"RenderExpression",
+         [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {
+             return std::make_unique<RenderExpression>(std::move(pos), listFromJson<Argument>(j, "arguments"),
+                                                        listFromJson<ASTNode>(j, "children"));
+         }},
         {"ModularCall",
          [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {
              return std::make_unique<ModularCall>(std::move(pos), childFromJson<Identifier>(j, "name"),

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(oscad_tests
   test_scope.cpp
   test_ast_generation.cpp
   test_node_str.cpp
+  test_render_expression.cpp
 )
 target_link_libraries(oscad_tests PRIVATE openscad_cpp_parser GTest::gtest_main)
 

openscad_cpp_evaluator-0.38.0/external/openscad_cpp_parser/tests/test_render_expression.cpp

@@ -0,0 +1,186 @@
+// `render()` in EXPRESSION position: `obj = render() { cube(1); };`
+//
+// The statement form (`render() cube(1);`) is deliberately UNCHANGED -- it
+// still parses to a plain ModularCall named "render", so everything
+// downstream (builtin dispatch, the argument allowlist, json_io) sees what
+// it always saw. Only the expression form is new, and it exists at all
+// because LALR(1) cannot otherwise tell `render(` in expression position
+// apart from a function call -- hence `render` being a reserved keyword.
+
+#include "openscad_cpp_parser/api.hpp"
+#include "openscad_cpp_parser/pretty_print.hpp"
+#include "openscad_cpp_parser/serialization.hpp"
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscad;
+
+namespace {
+
+const RenderExpression* renderExprOf(const std::vector<std::unique_ptr<ASTNode>>& ast, size_t idx = 0) {
+    auto* a = dynamic_cast<Assignment*>(ast[idx].get());
+    return a ? dynamic_cast<const RenderExpression*>(a->expr.get()) : nullptr;
+}
+
+} // namespace
+
+// -- The expression form --------------------------------------------------
+
+TEST(RenderExpression, ParsesInAssignment) {
+    auto ast = parseSrc("obj = render() { cube(1); };");
+    ASSERT_EQ(ast.size(), 1u);
+    const RenderExpression* r = renderExprOf(ast);
+    ASSERT_NE(r, nullptr);
+    EXPECT_EQ(r->kind(), NodeKind::RenderExpression);
+    EXPECT_TRUE(r->arguments.empty());
+    ASSERT_EQ(r->children.size(), 1u);
+    EXPECT_EQ(r->children[0]->kind(), NodeKind::ModularCall);
+}
+
+TEST(RenderExpression, ParsesTheOriginalMotivatingExample) {
+    // A trailing `}` child needs no `;` of its own, so this form -- unlike a
+    // bare call -- terminates its enclosing assignment cleanly.
+    auto ast = parseSrc("obj = render() difference() { cube(100); sphere(20); };");
+    ASSERT_EQ(ast.size(), 1u);
+    const RenderExpression* r = renderExprOf(ast);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(r->children.size(), 1u);
+    auto* diff = dynamic_cast<ModularCall*>(r->children[0].get());
+    ASSERT_NE(diff, nullptr);
+    EXPECT_EQ(diff->name->name, "difference");
+    EXPECT_EQ(diff->children.size(), 2u);
+}
+
+TEST(RenderExpression, SupportsMemberAccess) {
+    // Lives in `primary`, not `expr`, precisely so the existing
+    // `postfix "." NAME` rule applies.
+    auto ast = parseSrc("v = render() { cube(1); }.volume;");
+    ASSERT_EQ(ast.size(), 1u);
+    auto* a = dynamic_cast<Assignment*>(ast[0].get());
+    ASSERT_NE(a, nullptr);
+    auto* member = dynamic_cast<PrimaryMember*>(a->expr.get());
+    ASSERT_NE(member, nullptr);
+    EXPECT_EQ(member->member->name, "volume");
+    EXPECT_EQ(member->left->kind(), NodeKind::RenderExpression);
+}
+
+TEST(RenderExpression, TakesArguments) {
+    auto ast = parseSrc("obj = render($fn=32) { sphere(10); };");
+    const RenderExpression* r = renderExprOf(ast);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(r->arguments.size(), 1u);
+    auto* named = dynamic_cast<NamedArgument*>(r->arguments[0].get());
+    ASSERT_NE(named, nullptr);
+    EXPECT_EQ(named->name->name, "$fn");
+}
+
+TEST(RenderExpression, AcceptsEmptyAndMultipleChildren) {
+    EXPECT_EQ(renderExprOf(parseSrc("e = render() { };"))->children.size(), 0u);
+    EXPECT_EQ(renderExprOf(parseSrc("m = render() { cube(1); sphere(2); cylinder(3); };"))->children.size(), 3u);
+}
+
+TEST(RenderExpression, WorksAsArgumentAndListElement) {
+    EXPECT_NO_THROW(parseSrc("echo(render() { cube(1); });"));
+    EXPECT_NO_THROW(parseSrc("v = [render() { cube(1); }, render() { sphere(2); }];"));
+    EXPECT_NO_THROW(parseSrc("v = 1 + render() { cube(1); }.volume;"));
+    EXPECT_NO_THROW(parseSrc("function f(a) = render() { cube(a); }.volume;"));
+    EXPECT_NO_THROW(parseSrc("v = [for (i = [0:2]) render() { cube(i); }];"));
+}
+
+// -- The statement form is untouched --------------------------------------
+
+TEST(RenderExpression, StatementFormIsStillAModularCall) {
+    auto ast = parseSrc("render() cube(1);");
+    ASSERT_EQ(ast.size(), 1u);
+    auto* call = dynamic_cast<ModularCall*>(ast[0].get());
+    ASSERT_NE(call, nullptr);
+    EXPECT_EQ(call->kind(), NodeKind::ModularCall);
+    EXPECT_EQ(call->name->name, "render");
+    EXPECT_EQ(call->children.size(), 1u);
+}
+
+TEST(RenderExpression, StatementFormKeepsArgumentsAndModifiers) {
+    auto ast = parseSrc("render(convexity=4) cube(1);\n#render() sphere(2);\nrender() { cube(1); sphere(2); }");
+    ASSERT_EQ(ast.size(), 3u);
+    auto* withArgs = dynamic_cast<ModularCall*>(ast[0].get());
+    ASSERT_NE(withArgs, nullptr);
+    EXPECT_EQ(withArgs->arguments.size(), 1u);
+    EXPECT_EQ(ast[1]->kind(), NodeKind::ModularModifierHighlight);
+    auto* braced = dynamic_cast<ModularCall*>(ast[2].get());
+    ASSERT_NE(braced, nullptr);
+    EXPECT_EQ(braced->children.size(), 2u);
+}
+
+// -- The sharp edge, asserted on purpose ----------------------------------
+
+TEST(RenderExpression, BareCallChildDoesNotTerminateTheAssignment) {
+    // `cube(1);` IS the child_statement, semicolon included, so the enclosing
+    // assignment is left unterminated. Inherent to OpenSCAD's grammar, not a
+    // choice this implementation makes. The braced form is the documented
+    // idiom; this test exists so the behaviour is pinned rather than
+    // rediscovered.
+    EXPECT_THROW(parseSrc("obj = render() cube(1);"), ParseError);
+    EXPECT_NO_THROW(parseSrc("obj = render() { cube(1); };"));
+}
+
+// -- Reserving the keyword has costs; pin them ----------------------------
+
+TEST(RenderExpression, RenderIsNowAReservedWord) {
+    EXPECT_THROW(parseSrc("render = 1;"), ParseError);
+    EXPECT_THROW(parseSrc("module render() { cube(1); }"), ParseError);
+    EXPECT_THROW(parseSrc("function render() = 1;"), ParseError);
+    EXPECT_THROW(parseSrc("cube(render=1);"), ParseError);
+    EXPECT_THROW(parseSrc("x = obj.render;"), ParseError);
+}
+
+TEST(RenderExpression, DollarRenderIsStillAnOrdinaryName) {
+    // keywordTable() is keyed on the full IDENT text, `$` included.
+    EXPECT_NO_THROW(parseSrc("$render = 1;"));
+}
+
+// -- Round-trips ----------------------------------------------------------
+
+TEST(RenderExpression, PrettyPrintOutputReparses) {
+    // The whole point: emitted source must parse back. toString()'s own
+    // child rendering follows the reference's terminator-free format, so
+    // fmtExpr has a dedicated arm that uses fmtBlock instead -- if that arm
+    // regresses, the second parse below throws.
+    const std::string src =
+        "obj = render() difference() { cube(100); sphere(20); };\n"
+        "v = render() { cube(1); }.volume;\n"
+        "w = render($fn = 32) { x = 5; cube(x); };\n"
+        "e = render() { };\n"
+        "render() cube(9);\n";
+    std::string once = toOpenscad(parseSrc(src));
+    std::string twice;
+    ASSERT_NO_THROW(twice = toOpenscad(parseSrc(once)));
+    EXPECT_EQ(once, twice) << "formatting is not idempotent:\n" << once;
+}
+
+TEST(RenderExpression, ToStringIsReparseable) {
+    auto ast = parseSrc("obj = render($fn = 32) { cube(1); sphere(2); };");
+    const RenderExpression* r = renderExprOf(ast);
+    ASSERT_NE(r, nullptr);
+    EXPECT_EQ(r->toString(), "render($fn = 32) { cube(1); sphere(2); }");
+    EXPECT_NO_THROW(parseSrc("y = " + r->toString() + ";"));
+}
+
+TEST(RenderExpression, JsonRoundTrip) {
+    const std::string src =
+        "obj = render() difference() { cube(100); sphere(20); };\n"
+        "w = render($fn = 32) { x = 5; cube(x); };\n"
+        "e = render() { };\n";
+    auto ast = parseSrc(src);
+    std::string before = toOpenscad(ast);
+    auto rebuilt = astFromJsonString(astToJsonString(ast));
+    EXPECT_EQ(before, toOpenscad(rebuilt));
+}
+
+// -- Scope ----------------------------------------------------------------
+
+TEST(RenderExpression, HoistsAssignmentsInItsChildBlock) {
+    // buildScope() must call collectHoistedDeclarations, exactly as
+    // ModularCall does, or `x` below resolves to nothing.
+    EXPECT_NO_THROW(parseSrc("obj = render() { cube(x); x = 5; };"));
+}

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -892,6 +892,13 @@ struct CompiledChunk {
             Color,
             Modifier,
             Passthrough,   // hull()/minkowski()/render() -- empty params, no compute function needed
+            // render() in EXPRESSION position. The only Kind whose Pop
+            // does NOT append a CSGNode to the parent's accumulator: it
+            // discards the subtree and pushes the measurement object() onto
+            // the operand stack instead. Its `node` is a RenderExpression,
+            // not a ModularCall -- warnUnexpectedBuiltinArgs already
+            // self-guards on that (registry.cpp).
+            Measure,
             LinearExtrude,
             RotateExtrude,
             Projection,
@@ -901,6 +908,14 @@ struct CompiledChunk {
         Kind kind;
         std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"/"hull"/...
         const oscad::ASTNode* node = nullptr;
+        // Kind::Measure only. (name, slot) for every local visible at this
+        // site, so Op::PushBuiltinWrap can publish them into the children's
+        // EvalContext. A render() expression's children are STATEMENT
+        // opcodes and resolve names through the context, but a compiled
+        // FUNCTION keeps its parameters and lets in frame slots instead --
+        // without this, `function f(w) = render() { cube(w); }.volume;`
+        // cannot see `w` and silently builds nothing.
+        std::vector<std::pair<std::string, int>> capturedLocals;
     };
 
     // One Op::PushCsgWrap/PopCsgWrap site pair -- see those ops' own doc

{openscad_cpp_evaluator-0.37.0 → openscad_cpp_evaluator-0.38.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -38,6 +38,18 @@ struct PendingBuiltinWrap {
     // other kind computes its params at Push time and leaves this default-
     // empty.
     CallArgs deferredArgs;
+
+    // ev.measuring_ as it stood immediately BEFORE this bracket opened.
+    // Recorded for EVERY kind, not just Measure, so the exception teardown
+    // can restore from front() without inspecting kinds -- a non-Measure
+    // entry simply records and restores the same value.
+    bool savedMeasuring = false;
+    // f.stack.size() and ev.treeStack_.size() at Push time. Kind::Measure's
+    // Pop asserts both: it is the first bracket that runs STATEMENT opcodes
+    // with a non-empty operand stack beneath it, and nothing structurally
+    // enforces that those statements are operand-stack-neutral.
+    size_t stackDepthAtPush = 0;
+    size_t treeStackDepthAtPush = 0;
 };
 
 // One still-open Op::PushCsgWrap bracket's own state -- see that op's own