openscad-cpp-evaluator 0.42.1__tar.gz → 0.44.0__tar.gz

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/CLAUDE.md

@@ -441,6 +441,21 @@ handling in arithmetic, the closure-detection rule for `call_ctx` vs `child_ctx`
 verbatim port, not an independent design. Deliberate divergences are called out in code comments —
 grep for `ponytail:`.
 
+- **Feature detection** — `$_SUPPORTED_FEATURE` (just `true`; names the CAPABILITY rather than the
+  vendor, so any evaluator adding `supported_feature()` is meant to set it, and checking it first
+  solves the bootstrapping problem of calling a function you don't know exists. Written
+  `!is_undef($_SUPPORTED_FEATURE) && supported_feature(...)` the guard is **silent** in OpenSCAD --
+  `is_undef()` is the one way to read an unknown variable there without a warning, and `&&`
+  short-circuits past the unknown call; verified against the reference), `$_BELFRYSCAD` (seeded in `EvalContext::makeRoot`, `src/eval_context.cpp`, as
+  `[major, minor, patch]` from `OSCAD_EVAL_VERSION_*` compile definitions that the top-level
+  `CMakeLists.txt` parses out of `pyproject.toml`, so wheel and local builds cannot disagree and a
+  bump needs one edit) and `supported_feature("name")` (`featureLevels()` in
+  `src/builtins/function_builtins.cpp`, returning a LEVEL so a feature whose semantics change can
+  be told from its earlier self; 0 for unknown names and non-string arguments, deliberately
+  silent so probing for a future feature is safe). Both exist because OpenSCAD **silently ignores**
+  unknown arguments -- `children(separate=true)` renders the wrong shape there with no warning --
+  and both read as `undef` in OpenSCAD, so a guard written against them works in both.
+
 - `include/openscad_cpp_evaluator/value.hpp`, `src/value.cpp` — the `Value` variant (OpenSCAD's
   dynamic value type) and its free-function arithmetic/comparison helpers. See the plan's §1 for
   the type-mapping table and why there's no numpy-equivalent library.
@@ -481,13 +496,19 @@ grep for `ponytail:`.
   lexically nested inside an already-active call," picking `childCtx()` vs `callCtx()`
   accordingly; read its doc comment before touching it, it's the second-trickiest mechanism in this
   codebase after the CSG tree stack), `evalUserModule`/`evalUserFunction`/`evalFunctionLiteral`,
-  and `builtinChildren` (children()/children(N), deferred evaluation; `children(separate=true)`
-  additionally marks each forwarded node `separateOperand` so the enclosing
-  union/difference/intersection treats them as separate operands rather than one grouped one --
-  a BelfrySCAD extension, see `Evaluator::appendGroupSizes`. The marks stop at a user-module
-  boundary: only the children() call's own splice honours them
-  (`spliceModuleChildren`'s `honorSeparateMarks`), so a module wrapping such a call wraps its
-  children as usual and its own caller sees one operand). `evalFunctionCall`'s
+  and `builtinChildren` (children()/children(N), deferred evaluation).
+  **`children(..., separate=true)`** is a BelfrySCAD extension handled *before* any of that, by
+  `expandChildStatements`: a block is read with each separating forward replaced by one synthetic
+  `children(k)` statement per child it selects (`makeChildrenIndexCall`, owned by
+  `syntheticNodes_` and cleared with `idToNode` at `resolveTreeImpl` entry). Everything the
+  feature does follows from their being real statements -- `$children` counts them,
+  `children(i)` indexes them, and `union`/`difference`/`intersection` give each its own operand
+  group -- with no flag on `CSGNode` and nothing to leak. Called from `buildModuleChildCtx`,
+  `resolveCsg`, `resolveIntersectionFor`, and the VM's `Op::CsgGroupChildren`, which exists
+  because the compiler fixes group boundaries long before `$children` (and so the expansion size)
+  is knowable; it shares `expandSeparatingChildren` with the interpreter so the engines cannot
+  drift. Synthetic calls carry the author's own `Position` and no scope, so they resolve in the
+  evaluating context (`evalChildren`'s `runAll`). `evalFunctionCall`'s
   precedence order (checked in this exact sequence): `import` (special-cased, its own
   module/expression-context split) → `isBuiltinFunctionName` (function_builtins.hpp — always wins
   if true) → user function lookup → function-literal *value* probe → "unknown function" warning.

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/CMakeLists.txt

@@ -1,5 +1,17 @@
 cmake_minimum_required(VERSION 3.24)
-project(openscad_cpp_evaluator CXX)
+
+# Read the version straight out of pyproject.toml rather than repeating it
+# here. It reaches C++ as OSCAD_EVAL_VERSION_{MAJOR,MINOR,PATCH} (see
+# src/CMakeLists.txt), which is what seeds $_BELFRYSCAD -- so a released
+# wheel and a local `cmake --build` always report the same numbers, and a
+# version bump needs one edit, not three.
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/pyproject.toml" _oscad_pyproject)
+if(NOT _oscad_pyproject MATCHES "\nversion = \"([0-9]+)\.([0-9]+)\.([0-9]+)\"")
+    message(FATAL_ERROR "could not read version = \"X.Y.Z\" from pyproject.toml")
+endif()
+set(OSCAD_EVAL_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
+
+project(openscad_cpp_evaluator VERSION ${OSCAD_EVAL_VERSION} LANGUAGES CXX)
 
 # On Apple Silicon, warn (don't fail -- a universal or intentionally-x86_64
 # build is legitimate) if the effective target architecture is x86_64 while

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -426,6 +426,21 @@ enum class Op {
     // own `groupSizes.push_back(Value{...})` loop.
     CsgGroupEnd,
 
+    // One `children(..., separate=true)` statement inside a CSG bracket.
+    // `a` interns the ModularCall in nativeStatements.
+    //
+    // A statement of its own, rather than a CsgGroupStart/End pair around
+    // compiled code, because how many groups it contributes is only known
+    // at RUNTIME -- `children([2:$children-1], separate=true)` reads
+    // $children, and the compiler emits its group boundaries long before
+    // any of that exists. So this op expands the call (the same
+    // Evaluator::expandSeparatingChildren the interpreter uses, so the two
+    // engines cannot drift) and records one group per expanded statement.
+    //
+    // Not an interpreter bail: the forwarded statements go through
+    // evalChildren, which self-gates and retries its own compiled chunks.
+    CsgGroupChildren,
+
     // Closes the matching Op::PushCsgWrap bracket: pops
     // VmFrame::csgWrapStack's own top entry FIRST (before anything that can
     // itself throw, e.g. setTreeDepthOrThrow below -- same "exception-

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -219,10 +219,6 @@ struct VmFrame {
     // mirrors evalModularCall's own `&node` (csg_resolve.cpp). Only
     // meaningful when ownsModuleSplice is true.
     const oscad::ASTNode* moduleSpliceCallNode = nullptr;
-    // children(separate=true) on the call this frame is forwarding for.
-    // Only meaningful while ownsModuleSplice is true, same as the two
-    // fields above; reset in releaseVmFrame for the same pooling reason.
-    bool separateChildren = false;
 
     // Whether callStack_.back() (at push time) genuinely IS this frame's
     // own logical call, and therefore safe for a tail hop inside this

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -34,15 +34,6 @@ struct CSGNode {
     CSGParams params;                      // resolve step's plain-data output
     bool uncacheable = false;              // set by a later phase (ManifoldCache, Phase 8)
 
-    // Set only by children(separate=true): this node begins its OWN operand
-    // group in an enclosing union/difference/intersection/intersection_for,
-    // instead of merging into the single group its enclosing statement
-    // would otherwise form. See Evaluator::appendGroupSizes.
-    //
-    // Deliberately absent from cacheKey()'s allowlist (manifold_cache.cpp):
-    // it changes the PARENT's hashed "group_sizes" param, never this node's
-    // own geometry, so the parent already re-keys and this node must not.
-    bool separateOperand = false;
 
     // The call site that entered this node's call chain from the top
     // level, captured at RESOLVE time -- non-owning, AST-lifetime-bound
@@ -83,12 +74,5 @@ struct CSGNode {
     std::optional<std::string> cachedKey;
 };
 
-// Marks every node from `from` onward as starting its own operand group --
-// what children(separate=true) does to the geometry it just forwarded.
-// A free function, not a member, so all three splice sites (user_calls.cpp
-// and bytecode_vm.cpp's two) can reach it from this header alone.
-inline void markSeparateOperands(std::vector<std::unique_ptr<CSGNode>>& nodes, size_t from) {
-    for (size_t i = from; i < nodes.size(); ++i) nodes[i]->separateOperand = true;
-}
 
 } // namespace oscadeval

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -190,29 +190,6 @@ public:
     // statement.
     size_t currentTreeFrameSize() const { return treeStack_.back().size(); }
 
-    // Records the group(s) one child statement contributed, given the frame
-    // size captured before it ran. Normally that is exactly one group, of
-    // however many nodes the statement pushed -- including a group of size
-    // ZERO for a statement that produced no geometry (a disabled `*cube()`),
-    // which generateCsg relies on to reset intersection() and to bail
-    // difference(). Only children(separate=true) produces more than one:
-    // each node it marked starts a fresh group, so its forwarded children
-    // reach the enclosing operator as separate operands.
-    //
-    // Shared by all four group builders -- resolveCsg, resolveIntersectionFor
-    // and the VM's Op::CsgGroupEnd (which serves both) -- because
-    // "group_sizes" is otherwise built twice, once per engine, and would
-    // drift.
-    void appendGroupSizes(std::vector<Value>& groupSizes, size_t before) const {
-        const std::vector<std::unique_ptr<CSGNode>>& frame = treeStack_.back();
-        size_t start = before;
-        for (size_t i = before + 1; i < frame.size(); ++i) {
-            if (!frame[i]->separateOperand) continue;
-            groupSizes.push_back(Value{static_cast<double>(i - start)});
-            start = i;
-        }
-        groupSizes.push_back(Value{static_cast<double>(frame.size() - start)});
-    }
 
     // Generate pass: walks `tree` bottom-up (children before their own
     // node), calling each node's registered GenerateFn (falling back to
@@ -366,14 +343,56 @@ public:
     struct ChildrenForward {
         EvalContext evalCtx;
         std::vector<const oscad::ASTNode*> nodes;
-        // children(separate=true): hand these to the enclosing union/
-        // difference/intersection as SEPARATE operands rather than as one
-        // grouped operand. Acted on after the nodes are evaluated, by
-        // marking the CSGNodes they produced -- see markSeparateOperands.
+        // The `separate` flag as written at the call. Read by
+        // expandSeparatingChildren, which turns the forward into one
+        // statement per child; builtinChildren itself ignores it, since by
+        // the time a forward runs the expansion has already happened.
         bool separate = false;
+        // Which of the caller's geometry statements `nodes` came from, in
+        // the same order. Needed by expandChildStatements, which turns each
+        // one back into its own `children(k)` statement.
+        std::vector<size_t> pickedIndices;
     };
     std::optional<ChildrenForward> prepareChildrenForward(const CallArgs& args, EvalContext& ctx);
 
+    // A child-statement block with every `children(..., separate=true)`
+    // replaced by one synthetic `children(k)` statement per child it
+    // selects. That is the whole of what separate=true does: the forwarded
+    // children become real, countable statements at this call site, so
+    // $children sees them, children(i) indexes them, and a boolean operator
+    // gives each its own operand group -- all for free, because they ARE
+    // statements rather than nodes wearing a flag.
+    //
+    // Called wherever a block is consumed: a module call's children
+    // (buildModuleChildCtx), and union/difference/intersection/
+    // intersection_for's own child list.
+    std::vector<const oscad::ASTNode*> expandChildStatements(
+        const std::vector<std::unique_ptr<oscad::ASTNode>>& block, EvalContext& ctx);
+
+    // One synthetic `children(index)` statement, owned by syntheticNodes_.
+    const oscad::ASTNode* makeChildrenIndexCall(const oscad::ModularCall& origin, size_t index);
+
+    // The sole argument of `is_undef(x)` when x is a bare identifier, else
+    // nullptr. That call is a PROBE -- asking whether a name is defined must
+    // not itself complain that it isn't -- so the name is read with
+    // warnIfUndef=false. Static and syntactic so the bytecode compiler can
+    // ask at compile time and emit LoadFreeNoWarn.
+    static const oscad::Identifier* undefProbeTarget(const oscad::PrimaryCall& call);
+
+    // Syntactic gate: is this statement a `children(..., separate=true)`?
+    // Cheap and side-effect-free, so the bytecode compiler can ask it at
+    // COMPILE time to decide which opcode to emit, long before the flag's
+    // value (or the child count it selects) is knowable.
+    static bool isSeparatingChildrenCall(const oscad::ASTNode& stmt);
+
+    // The runtime half: the statements `call` expands to. nullopt means the
+    // `separate` flag resolved falsey after all, and the caller should run
+    // the original statement unchanged. Shared by expandChildStatements
+    // (interpreter) and Op::CsgGroupChildren (VM) so the engines cannot
+    // drift on what expansion means.
+    std::optional<std::vector<const oscad::ASTNode*>> expandSeparatingChildren(const oscad::ModularCall& call,
+                                                                               EvalContext& ctx);
+
     // "WARNING: {message}{locSuffix(position)}" via echoFn_, no-op if unset.
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
@@ -999,13 +1018,8 @@ public:
     // (evalModularCall's OWN "is this splice or wrap-as-a-tagged-node"
     // branch already decided `splice` before ever reaching a user module,
     // so this helper never needs that decision itself).
-    // `honorSeparateMarks` is true only for a children() call's OWN splice.
-    // A user module's splice passes false, so it wraps its marked children
-    // as usual and the marks stop there -- children(separate=true) applies
-    // to the operator enclosing that call, not to whatever encloses the
-    // module the call happens to sit in.
     void spliceModuleChildren(std::vector<std::unique_ptr<CSGNode>> children, std::uint64_t randsBefore,
-                               const oscad::ASTNode& callNode, bool honorSeparateMarks = false);
+                               const oscad::ASTNode& callNode);
 private:
     Value evalUserFunction(const std::string& name, const oscad::FunctionDeclaration& decl,
                             const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
@@ -1661,6 +1675,12 @@ public:
     // is on top *at that moment* -- the frame this node's own build call
     // pushed just before resolving. See csg_resolve.cpp for the full
     // push/call/pop sequence.
+    // Synthetic `children(k)` calls built by expandChildStatements. Owned
+    // here because CSGNode::node and idToNode hold non-owning pointers into
+    // them, so they must outlive the pass; cleared with those maps at
+    // resolveTreeImpl entry.
+    std::vector<std::unique_ptr<oscad::ASTNode>> syntheticNodes_;
+
     std::vector<std::vector<std::unique_ptr<CSGNode>>> treeStack_;
 
 private:

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/CMakeLists.txt

@@ -46,6 +46,14 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/surface.cpp
 )
 
+# Seeds $_BELFRYSCAD (eval_context.cpp). Parsed from pyproject.toml by the
+# top-level CMakeLists so there is one source of truth for the version.
+target_compile_definitions(openscad_cpp_evaluator PRIVATE
+  OSCAD_EVAL_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}
+  OSCAD_EVAL_VERSION_MINOR=${PROJECT_VERSION_MINOR}
+  OSCAD_EVAL_VERSION_PATCH=${PROJECT_VERSION_PATCH}
+)
+
 target_include_directories(openscad_cpp_evaluator PUBLIC
   $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/builtins/booleans.cpp

@@ -70,10 +70,11 @@ std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBo
 // misbehave when e.g. BOSL2's attachable() returns multiple bodies (parent
 // + attached children) as one operand.
 //
-// One statement can contribute MORE than one group: children(separate=true)
-// marks the nodes it forwards so each starts its own operand group, which is
+// One statement can still turn into several: children(separate=true) is
+// expanded into one `children(k)` statement per child it forwards, before
+// this loop ever sees the block (Evaluator::expandChildStatements), which is
 // how `difference() children(separate=true)` subtracts children 1..n from
-// child 0. See Evaluator::appendGroupSizes, which both engines share. Mirrors _resolve_csg/_generate_csg,
+// child 0. Nothing special happens here -- they are simply statements. Mirrors _resolve_csg/_generate_csg,
 // minus _attach_tri_colors' multi-color-merge provenance (ponytail: a
 // merged body always takes its first contributing child's color, matching
 // this evaluator's own pre-tri_colors baseline behavior -- revisit
@@ -92,11 +93,11 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
     std::vector<const oscad::ASTNode*> assignNodes;
     std::vector<const oscad::ASTNode*> geoNodes;
-    for (const auto& c : node.children) {
+    for (const oscad::ASTNode* c : ev.expandChildStatements(node.children, effCtx)) {
         if (c->kind() == oscad::NodeKind::Assignment) {
-            assignNodes.push_back(c.get());
+            assignNodes.push_back(c);
         } else if (c->kind() != oscad::NodeKind::ModuleDeclaration && c->kind() != oscad::NodeKind::FunctionDeclaration) {
-            geoNodes.push_back(c.get());
+            geoNodes.push_back(c);
         }
     }
     if (!assignNodes.empty()) ev.evalChildren(assignNodes, effCtx);
@@ -106,7 +107,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
         ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, effCtx);
-        ev.appendGroupSizes(groupSizes, before);
+        groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
     }
 
     CSGParams params;

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/builtins/control.cpp

@@ -97,9 +97,10 @@ ColoredBody combineBodies(const std::vector<ColoredBody>& bodies) {
 // children) -- same rationale as booleans.cpp's own group_sizes. Mirrors
 // _resolve_intersection_for/_generate_intersection_for.
 CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersectionFor& node, EvalContext& ctx) {
-    std::vector<const oscad::ASTNode*> bodyNodes;
-    bodyNodes.reserve(node.body.size());
-    for (const auto& b : node.body) bodyNodes.push_back(b.get());
+    // Expanded for the same reason resolveCsg expands its own block: a
+    // children(..., separate=true) here contributes one statement -- and so
+    // one operand group per iteration -- per child it selects.
+    const std::vector<const oscad::ASTNode*> bodyNodes = ev.expandChildStatements(node.body, ctx);
 
     std::vector<Value> groupSizes;
 
@@ -119,7 +120,7 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
             if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
             const size_t before = ev.currentTreeFrameSize();
             ev.evalChildren(bodyNodes, parentCtx);
-            ev.appendGroupSizes(groupSizes, before);
+            groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
             return;
         }
         const auto& assign = node.assignments[depth];

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/builtins/function_builtins.cpp

@@ -449,7 +449,7 @@ bool isBuiltinFunctionName(const std::string& name) {
         "acos", "atan", "atan2", "max", "min", "pow", "norm", "cross", "rands", "concat", "len", "str",
         "chr", "ord", "is_undef", "is_num", "is_bool", "is_string", "is_list", "is_function", "is_object",
         "search", "lookup", "has_key", "version", "version_num", "parent_module",
-        "object", "textmetrics", "fontmetrics", "dxf_dim", "dxf_cross",
+        "object", "textmetrics", "fontmetrics", "dxf_dim", "dxf_cross", "supported_feature",
     };
     return names.count(name) > 0;
 }
@@ -591,9 +591,37 @@ enum class BuiltinFnId {
     TextMetrics, FontMetrics, Abs, Sign, Ceil, Floor, Round, Sqrt, Ln, Log, Exp, Sin, Cos, Tan,
     Asin, Acos, Atan, Atan2, Max, Min, Pow, Norm, Cross, Rands, Concat, Len, Str, Chr, Ord,
     IsUndef, IsNum, IsBool, IsString, IsList, IsFunction, IsObject, Search, Lookup, HasKey,
-    Version, VersionNum, ParentModule, DxfDim, DxfCross,
+    Version, VersionNum, ParentModule, DxfDim, DxfCross, SupportedFeature,
 };
 
+// supported_feature("name") -> the level at which this build implements that
+// feature, or 0 for one it does not implement (and for a name it has never
+// heard of, which is deliberate: probing for a feature from a future release
+// is supposed to be safe).
+//
+// A LEVEL rather than a boolean so a feature whose semantics change later
+// can be told apart from its earlier self. Everything here is 1 today;
+// nothing has changed since this function existed, and a script cannot
+// observe what a build without supported_feature() did anyway.
+//
+// This is the answer to a real hazard: OpenSCAD does not reject arguments or
+// names it doesn't know -- children(separate=true) is silently ignored there
+// -- so a script using an extension runs and quietly renders something else.
+// Guarding on supported_feature() is how a script says so out loud.
+const std::unordered_map<std::string, double>& featureLevels() {
+    static const std::unordered_map<std::string, double> levels = {
+        {"separate-children", 1.0},  // children(..., separate=true)
+        {"minkowski-diff", 1.0},     // minkowski_difference()
+        {"sphere-styles", 1.0},      // sphere(style=)
+        {"export-name", 1.0},        // $export_name
+        {"simplify-op", 1.0},        // simplify()
+        {"expr-import", 1.0},        // import() in expression position
+        {"object-function", 1.0},    // object(), unconditional here
+        {"roof-op", 1.0},            // roof(), method="voronoi" only
+    };
+    return levels;
+}
+
 const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
     static const std::unordered_map<std::string, BuiltinFnId> ids = {
         {"textmetrics", BuiltinFnId::TextMetrics}, {"fontmetrics", BuiltinFnId::FontMetrics},
@@ -614,6 +642,7 @@ const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
         {"version", BuiltinFnId::Version}, {"version_num", BuiltinFnId::VersionNum},
         {"parent_module", BuiltinFnId::ParentModule},
         {"dxf_dim", BuiltinFnId::DxfDim}, {"dxf_cross", BuiltinFnId::DxfCross},
+        {"supported_feature", BuiltinFnId::SupportedFeature},
     };
     return ids;
 }
@@ -694,6 +723,7 @@ const std::unordered_map<int, BuiltinCheck>& builtinChecks() {
         // warning, so only the too-many case is an arity error.
         add(BuiltinFnId::ParentModule, {0, 1, "1", {kNum}});
         add(BuiltinFnId::HasKey, {-1, -1, nullptr, {{TObj, "object"}, {TStr, "string"}}});
+        add(BuiltinFnId::SupportedFeature, {1, 1, "1", {}});
         for (BuiltinFnId id : {BuiltinFnId::IsUndef, BuiltinFnId::IsNum, BuiltinFnId::IsBool,
                                 BuiltinFnId::IsString, BuiltinFnId::IsList, BuiltinFnId::IsFunction,
                                 BuiltinFnId::IsObject}) {
@@ -1008,6 +1038,17 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         // The OpenSCAD release we track. version_num() is that same
         // year/month/day folded as y * 10000 + m * 100 + d, exactly like the
         // reference's own builtin_version_num (builtin_functions.cc).
+        case BuiltinFnId::SupportedFeature: {
+            const Value name = getArg(args, 0, "feature", Value{});
+            const std::string* s = std::get_if<std::string>(&name);
+            // A non-string is 0 rather than an error, same as an unknown
+            // name: the whole point of this function is that asking is
+            // always safe.
+            if (!s) return Value{0.0};
+            const auto& levels = featureLevels();
+            const auto it = levels.find(*s);
+            return Value{it == levels.end() ? 0.0 : it->second};
+        }
         case BuiltinFnId::Version: return numList({2026.0, 1.0, 1.0});
         case BuiltinFnId::VersionNum: {
             // The optional vector argument the reference also accepts: with

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/bytecode_compiler.cpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/dispatch.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/function_builtins.hpp"
 
 #include "builtins/builtins.hpp"
@@ -619,15 +620,24 @@ public:
                     }
                 }
 
-                for (const auto& argPtr : n.arguments) {
-                    if (argPtr->kind() == NodeKind::NamedArgument) {
-                        auto& a = static_cast<const oscad::NamedArgument&>(*argPtr);
-                        compileExpr(*a.expr, out, scope); // an argument is never tail
-                        site.argNames.push_back(a.name->name);
-                    } else {
-                        auto& a = static_cast<const oscad::PositionalArgument&>(*argPtr);
-                        compileExpr(*a.expr, out, scope);
-                        site.argNames.push_back(std::nullopt);
+                // is_undef(name) probes rather than reads -- the same quiet
+                // load the interpreter uses (Evaluator::undefProbeTarget),
+                // so the two engines agree on which reads warn.
+                if (const oscad::Identifier* undefProbe = Evaluator::undefProbeTarget(n)) {
+                    compileIdentifierLoad(undefProbe->name, undefProbe->position(), out, scope,
+                                          /*warnIfUndef=*/false);
+                    site.argNames.push_back(std::nullopt);
+                } else {
+                    for (const auto& argPtr : n.arguments) {
+                        if (argPtr->kind() == NodeKind::NamedArgument) {
+                            auto& a = static_cast<const oscad::NamedArgument&>(*argPtr);
+                            compileExpr(*a.expr, out, scope); // an argument is never tail
+                            site.argNames.push_back(a.name->name);
+                        } else {
+                            auto& a = static_cast<const oscad::PositionalArgument&>(*argPtr);
+                            compileExpr(*a.expr, out, scope);
+                            site.argNames.push_back(std::nullopt);
+                        }
                     }
                 }
                 int siteIdx = static_cast<int>(chunk_.callSites.size());
@@ -1292,6 +1302,12 @@ public:
         }
         compileStatementList(assignNodes, out);
         for (const oscad::ASTNode* geoNode : geoNodes) {
+            // A separating children() forward contributes a runtime-decided
+            // NUMBER of groups, so it cannot be bracketed at compile time.
+            if (Evaluator::isSeparatingChildrenCall(*geoNode)) {
+                out.push_back({Op::CsgGroupChildren, internNativeStatement(geoNode), 0, &geoNode->position()});
+                continue;
+            }
             out.push_back({Op::CsgGroupStart, 0, 0, nullptr});
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
             out.push_back({Op::CsgGroupEnd, 0, 0, nullptr});

{openscad_cpp_evaluator-0.42.1 → openscad_cpp_evaluator-0.44.0}/src/bytecode_vm.cpp

@@ -360,7 +360,7 @@ void pushBracketedModuleFrame(Evaluator& ev, const CompiledChunk& chunk, const o
 // because module chunks never contain tail-call opcodes); don't inherit
 // a pooled function frame's stale true here either.
 void pushChildrenForwardFrame(Evaluator& ev, const CompiledChunk& chunk, EvalContext evalCtx,
-                               std::uint64_t randsBefore, const oscad::ASTNode& callNode, bool separate) {
+                               std::uint64_t randsBefore, const oscad::ASTNode& callNode) {
     if (ev.vmCallStack_.size() >= Evaluator::kMaxVmCallStackDepth) {
         ev.error("Recursion too deep while forwarding children()", callNode);
     }
@@ -381,7 +381,6 @@ void pushChildrenForwardFrame(Evaluator& ev, const CompiledChunk& chunk, EvalCon
     frame->ownsModuleSplice = true;
     frame->moduleRandsBefore = randsBefore;
     frame->moduleSpliceCallNode = &callNode;
-    frame->separateChildren = separate;
     ev.vmCallStack_.push_back(std::move(frame));
     ev.vmCallBrackets_.emplace_back(std::nullopt);
 }
@@ -506,7 +505,6 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 const bool ownsModuleSplice = finished->ownsModuleSplice;
                 const std::uint64_t moduleRandsBefore = finished->moduleRandsBefore;
                 const oscad::ASTNode* moduleSpliceCallNode = finished->moduleSpliceCallNode;
-                const bool separateChildren = finished->separateChildren;
                 while (!finished->ctxChain.empty()) finished->ctxChain.pop_back();
                 // Module frames never fire returnHook (native evalUserModule
                 // never did either -- a module call has no "return value"
@@ -516,12 +514,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 if (isModule && ownsModuleSplice) {
                     std::vector<std::unique_ptr<CSGNode>> children = std::move(ev.treeStack_.back());
                     ev.treeStack_.pop_back();
-                    // separateChildren is set only by pushChildrenForwardFrame,
-                    // so it also answers "is this a children() splice?" -- a
-                    // user module's frame always passes false and wraps.
-                    if (separateChildren) markSeparateOperands(children, 0);
-                    ev.spliceModuleChildren(std::move(children), moduleRandsBefore, *moduleSpliceCallNode,
-                                            /*honorSeparateMarks=*/separateChildren);
+                    ev.spliceModuleChildren(std::move(children), moduleRandsBefore, *moduleSpliceCallNode);
                 }
                 if (isFloorFrame) {
                     finalResult = std::move(result); // unused by a module caller (runCompiledModuleBody ignores it)
@@ -1051,11 +1044,9 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     const CompiledChunk* chunk = (ev.useBytecodeVm() && ev.inResolvePass())
                                                      ? ev.lookupOrCompileChildrenListChunk(fwd->nodes)
                                                      : nullptr;
-                    // Read before fwd->evalCtx is moved from.
-                    const bool separate = fwd->separate;
                     if (chunk) {
                         ev.treeStack_.emplace_back();
-                        pushChildrenForwardFrame(ev, *chunk, std::move(fwd->evalCtx), randsBefore, *callNode, separate);
+                        pushChildrenForwardFrame(ev, *chunk, std::move(fwd->evalCtx), randsBefore, *callNode);
                         // f.pc deliberately NOT advanced -- resumes when
                         // the pushed frame completes; driveVm's completion
                         // branch runs the splice (isModule &&
@@ -1079,9 +1070,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         }
                         std::vector<std::unique_ptr<CSGNode>> children = std::move(ev.treeStack_.back());
                         ev.treeStack_.pop_back();
-                        if (separate) markSeparateOperands(children, 0);
-                        ev.spliceModuleChildren(std::move(children), randsBefore, *callNode,
-                                                /*honorSeparateMarks=*/true);
+                        ev.spliceModuleChildren(std::move(children), randsBefore, *callNode);
                         ++f.pc;
                     }
                     break;
@@ -1318,9 +1307,30 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
+                case Op::CsgGroupChildren: {
+                    const auto& call =
+                        static_cast<const oscad::ModularCall&>(*f.chunk->nativeStatements[static_cast<size_t>(ins.a)]);
+                    PendingCsgWrap& pending = f.csgWrapStack.back();
+                    std::optional<std::vector<const oscad::ASTNode*>> expanded =
+                        ev.expandSeparatingChildren(call, ctx);
+                    // nullopt = `separate` resolved falsey: one group, the
+                    // original statement, exactly as CsgGroupStart/End would
+                    // have done for it.
+                    const std::vector<const oscad::ASTNode*> stmts =
+                        expanded ? *expanded : std::vector<const oscad::ASTNode*>{&call};
+                    for (const oscad::ASTNode* stmt : stmts) {
+                        const size_t before = ev.treeStack_.back().size();
+                        ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, ctx);
+                        pending.groupSizes.push_back(
+                            Value{static_cast<double>(ev.treeStack_.back().size() - before)});
+                    }
+                    ++f.pc;
+                    break;
+                }
                 case Op::CsgGroupEnd: {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
-                    ev.appendGroupSizes(pending.groupSizes, pending.groupStartSize);
+                    const size_t after = ev.treeStack_.back().size();
+                    pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
                     ++f.pc;
                     break;
                 }