openscad-cpp-evaluator 0.15.0__tar.gz → 0.17.0__tar.gz

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/bindings/CMakeLists.txt

@@ -15,6 +15,7 @@ find_package(nanobind CONFIG REQUIRED)
 # from-source Manifold/Boost rebuild per interpreter in CI.
 nanobind_add_module(_openscad_cpp_evaluator NB_STATIC STABLE_ABI
   module.cpp
+  ast_to_py.cpp
 )
 
 # The static evaluator lib PUBLIC-links parser + manifold + Boost::polygon,

openscad_cpp_evaluator-0.17.0/bindings/ast_to_py.cpp

@@ -0,0 +1,326 @@
+// Snapshots the parser's AST into plain Python dicts.
+//
+// Deliberately a COPY rather than wrappers around live ASTNode pointers.
+// The tree is owned by a `std::vector<std::unique_ptr<ASTNode>>` local to
+// whichever binding parsed it, and dies when that call returns; handing
+// Python raw pointers into it would be a use-after-free the moment anything
+// outlived the call, and this project has already shipped one dangling
+// pointer of exactly that shape (the bodyCtx bug fixed in v0.13.1). It also
+// sidesteps the threading problem entirely -- a render worker thread can
+// parse, hand the snapshot to the GUI thread, and exit, with nothing shared.
+//
+// The cost is one walk plus allocation per parse. That is affordable
+// because callers ask for this explicitly (parse_ast()), not on the render
+// path, which never needs it.
+//
+// Every node dict carries at least:
+//   kind      -- str, the NodeKind name ("NumberLiteral", "ModularCall", ...)
+//   position  -- dict(origin, line, column, start_offset, end_offset)
+// plus that kind's own fields, named in snake_case. Child nodes are nested
+// dicts; child lists are lists of dicts; an absent optional child is None.
+//
+// `position.start_offset`/`end_offset` are the point of the whole exercise:
+// they let a caller recover the ORIGINAL source text of any subexpression
+// and reuse it verbatim, rather than re-serialising a parsed value and
+// losing how the author wrote it (1.500 -> 1.5, 1e3 -> 1000).
+
+#include "openscad_cpp_parser/api.hpp"
+#include "openscad_cpp_parser/ast/ast_node.hpp"
+#include "openscad_cpp_parser/ast/comments.hpp"
+#include "openscad_cpp_parser/ast/declarations.hpp"
+#include "openscad_cpp_parser/ast/expression.hpp"
+#include "openscad_cpp_parser/ast/module_instantiation.hpp"
+#include "openscad_cpp_parser/ast/vector_element.hpp"
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+#include <memory>
+#include <vector>
+
+namespace nb = nanobind;
+
+namespace oscadbind {
+
+namespace {
+
+nb::dict positionToPy(const oscad::Position& p) {
+    nb::dict d;
+    // origin is "" for the main file (matching how the evaluator reports
+    // it); left as-is rather than mapped to None, so a caller can compare
+    // it against a path without a null check.
+    d["origin"] = p.origin;
+    d["line"] = p.line;
+    d["column"] = p.column;
+    d["start_offset"] = p.start_offset;
+    d["end_offset"] = p.end_offset;
+    return d;
+}
+
+nb::object nodeToPy(const oscad::ASTNode* n);
+
+// A null unique_ptr child (e.g. a parameter with no default) becomes None
+// rather than being omitted, so a consumer can index the key unconditionally.
+template <typename T>
+nb::object childToPy(const std::unique_ptr<T>& p) {
+    return p ? nodeToPy(p.get()) : nb::none();
+}
+
+template <typename T>
+nb::list listToPy(const std::vector<std::unique_ptr<T>>& v) {
+    nb::list out;
+    for (const std::unique_ptr<T>& item : v) out.append(nodeToPy(item.get()));
+    return out;
+}
+
+nb::dict baseDict(const oscad::ASTNode* n) {
+    nb::dict d;
+    d["kind"] = oscad::nodeKindName(n->kind());
+    d["position"] = positionToPy(n->position());
+    return d;
+}
+
+nb::object nodeToPy(const oscad::ASTNode* n) {
+    if (n == nullptr) return nb::none();
+    nb::dict d = baseDict(n);
+
+    // kind() is authoritative about the concrete type (every leaf class sets
+    // its own), so static_cast is safe here and avoids a dynamic_cast per
+    // node on what is already an allocation-heavy walk.
+#define OSC_NODE(KindName, Type) case oscad::NodeKind::KindName: { const auto* x = static_cast<const oscad::Type*>(n); (void)x;
+#define OSC_END break; }
+
+    switch (n->kind()) {
+        // -- comments ---------------------------------------------------
+        OSC_NODE(CommentLine, CommentLine) d["text"] = x->text; OSC_END
+        OSC_NODE(BlankLine, BlankLine) OSC_END
+        OSC_NODE(CommentSpan, CommentSpan) d["text"] = x->text; OSC_END
+        OSC_NODE(CommentedExpr, CommentedExpr)
+            d["leading_comments"] = listToPy(x->leadingComments);
+            d["trailing_comments"] = listToPy(x->trailingComments);
+            d["expr"] = childToPy(x->expr);
+        OSC_END
+
+        // -- primaries / literals ---------------------------------------
+        OSC_NODE(Identifier, Identifier) d["name"] = x->name; OSC_END
+        // `val` is the DECODED string minus its quotes; escape sequences
+        // are kept raw (a source \n stays two characters). Use the span to
+        // recover exactly what was written.
+        OSC_NODE(StringLiteral, StringLiteral) d["val"] = x->val; OSC_END
+        // Parsed to double, so the source spelling (1.500, 1e3, 0x10) is
+        // NOT recoverable from here -- that is what the span is for.
+        OSC_NODE(NumberLiteral, NumberLiteral) d["val"] = x->val; OSC_END
+        OSC_NODE(BooleanLiteral, BooleanLiteral) d["val"] = x->val; OSC_END
+        OSC_NODE(UndefinedLiteral, UndefinedLiteral) OSC_END
+        OSC_NODE(RangeLiteral, RangeLiteral)
+            d["start"] = childToPy(x->start);
+            d["end"] = childToPy(x->end);
+            // Never null: the parser defaults an omitted step to 1.
+            d["step"] = childToPy(x->step);
+        OSC_END
+
+        // -- declarations / arguments -----------------------------------
+        OSC_NODE(ParameterDeclaration, ParameterDeclaration)
+            d["name"] = childToPy(x->name);
+            d["default_value"] = childToPy(x->defaultValue); // nullable
+            d["leading_comments"] = listToPy(x->leadingComments);
+            d["trailing_comments"] = listToPy(x->trailingComments);
+        OSC_END
+        OSC_NODE(PositionalArgument, PositionalArgument) d["expr"] = childToPy(x->expr); OSC_END
+        OSC_NODE(NamedArgument, NamedArgument)
+            d["name"] = childToPy(x->name);
+            d["expr"] = childToPy(x->expr);
+        OSC_END
+        OSC_NODE(Assignment, Assignment)
+            d["name"] = childToPy(x->name);
+            d["expr"] = childToPy(x->expr);
+        OSC_END
+
+        // -- prefix expression forms ------------------------------------
+        OSC_NODE(LetOp, LetOp)
+            d["assignments"] = listToPy(x->assignments);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(EchoOp, EchoOp)
+            d["arguments"] = listToPy(x->arguments);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(AssertOp, AssertOp)
+            d["arguments"] = listToPy(x->arguments);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(FunctionLiteral, FunctionLiteral)
+            d["parameters"] = listToPy(x->parameters);
+            d["body"] = childToPy(x->body);
+        OSC_END
+
+        // -- unary operators --------------------------------------------
+#define OSC_UNARY(KindName) OSC_NODE(KindName, KindName) d["expr"] = childToPy(x->expr); OSC_END
+        OSC_UNARY(UnaryMinusOp)
+        OSC_UNARY(LogicalNotOp)
+        OSC_UNARY(BitwiseNotOp)
+#undef OSC_UNARY
+
+        // -- binary operators -------------------------------------------
+#define OSC_BINARY(KindName)                                                                                          \
+    OSC_NODE(KindName, KindName) d["left"] = childToPy(x->left); d["right"] = childToPy(x->right); OSC_END
+        OSC_BINARY(AdditionOp)
+        OSC_BINARY(SubtractionOp)
+        OSC_BINARY(MultiplicationOp)
+        OSC_BINARY(DivisionOp)
+        OSC_BINARY(ModuloOp)
+        OSC_BINARY(ExponentOp)
+        OSC_BINARY(BitwiseAndOp)
+        OSC_BINARY(BitwiseOrOp)
+        OSC_BINARY(BitwiseShiftLeftOp)
+        OSC_BINARY(BitwiseShiftRightOp)
+        OSC_BINARY(LogicalAndOp)
+        OSC_BINARY(LogicalOrOp)
+        OSC_BINARY(EqualityOp)
+        OSC_BINARY(InequalityOp)
+        OSC_BINARY(GreaterThanOp)
+        OSC_BINARY(GreaterThanOrEqualOp)
+        OSC_BINARY(LessThanOp)
+        OSC_BINARY(LessThanOrEqualOp)
+#undef OSC_BINARY
+
+        OSC_NODE(TernaryOp, TernaryOp)
+            d["condition"] = childToPy(x->condition);
+            d["true_expr"] = childToPy(x->trueExpr);
+            d["false_expr"] = childToPy(x->falseExpr);
+        OSC_END
+
+        // -- postfix ----------------------------------------------------
+        OSC_NODE(PrimaryCall, PrimaryCall)
+            d["left"] = childToPy(x->left);
+            d["arguments"] = listToPy(x->arguments);
+        OSC_END
+        OSC_NODE(PrimaryIndex, PrimaryIndex)
+            d["left"] = childToPy(x->left);
+            d["index"] = childToPy(x->index);
+        OSC_END
+        OSC_NODE(PrimaryMember, PrimaryMember)
+            d["left"] = childToPy(x->left);
+            d["member"] = childToPy(x->member);
+        OSC_END
+
+        // -- list comprehension clauses ---------------------------------
+        OSC_NODE(ListCompLet, ListCompLet)
+            d["assignments"] = listToPy(x->assignments);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(ListCompEach, ListCompEach) d["body"] = childToPy(x->body); OSC_END
+        OSC_NODE(ListCompFor, ListCompFor)
+            d["assignments"] = listToPy(x->assignments);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(ListCompCFor, ListCompCFor)
+            d["inits"] = listToPy(x->inits);
+            d["condition"] = childToPy(x->condition);
+            d["incrs"] = listToPy(x->incrs);
+            d["body"] = childToPy(x->body);
+        OSC_END
+        OSC_NODE(ListCompIf, ListCompIf)
+            d["condition"] = childToPy(x->condition);
+            d["true_expr"] = childToPy(x->trueExpr);
+        OSC_END
+        OSC_NODE(ListCompIfElse, ListCompIfElse)
+            d["condition"] = childToPy(x->condition);
+            d["true_expr"] = childToPy(x->trueExpr);
+            d["false_expr"] = childToPy(x->falseExpr);
+        OSC_END
+        // Also how a plain vector literal ([1,2,3]) is represented --
+        // elements mix comprehension clauses and bare expressions.
+        OSC_NODE(ListComprehension, ListComprehension) d["elements"] = listToPy(x->elements); OSC_END
+
+        // -- module instantiation ---------------------------------------
+        OSC_NODE(ModularCall, ModularCall)
+            d["name"] = childToPy(x->name);
+            d["arguments"] = listToPy(x->arguments);
+            d["children"] = listToPy(x->children);
+        OSC_END
+        OSC_NODE(ModularFor, ModularFor)
+            d["assignments"] = listToPy(x->assignments);
+            d["body"] = listToPy(x->body);
+        OSC_END
+        OSC_NODE(ModularIntersectionFor, ModularIntersectionFor)
+            d["assignments"] = listToPy(x->assignments);
+            d["body"] = listToPy(x->body);
+        OSC_END
+        OSC_NODE(ModularLet, ModularLet)
+            d["assignments"] = listToPy(x->assignments);
+            d["children"] = listToPy(x->children);
+        OSC_END
+        OSC_NODE(ModularEcho, ModularEcho)
+            d["arguments"] = listToPy(x->arguments);
+            d["children"] = listToPy(x->children);
+        OSC_END
+        OSC_NODE(ModularAssert, ModularAssert)
+            d["arguments"] = listToPy(x->arguments);
+            d["children"] = listToPy(x->children);
+        OSC_END
+        OSC_NODE(ModularIf, ModularIf)
+            d["condition"] = childToPy(x->condition);
+            d["true_branch"] = listToPy(x->trueBranch);
+        OSC_END
+        OSC_NODE(ModularIfElse, ModularIfElse)
+            d["condition"] = childToPy(x->condition);
+            d["true_branch"] = listToPy(x->trueBranch);
+            d["false_branch"] = listToPy(x->falseBranch);
+        OSC_END
+
+        // -- modifier wrappers (! # % *) --------------------------------
+#define OSC_MODIFIER(KindName) OSC_NODE(KindName, KindName) d["child"] = childToPy(x->child); OSC_END
+        OSC_MODIFIER(ModularModifierShowOnly)
+        OSC_MODIFIER(ModularModifierHighlight)
+        OSC_MODIFIER(ModularModifierBackground)
+        OSC_MODIFIER(ModularModifierDisable)
+#undef OSC_MODIFIER
+
+        // -- top-level declarations -------------------------------------
+        OSC_NODE(ModuleDeclaration, ModuleDeclaration)
+            d["name"] = childToPy(x->name);
+            d["parameters"] = listToPy(x->parameters);
+            d["children"] = listToPy(x->children);
+            d["pre_name_comments"] = listToPy(x->preNameComments);
+            d["post_name_comments"] = listToPy(x->postNameComments);
+            d["post_params_comments"] = listToPy(x->postParamsComments);
+        OSC_END
+        OSC_NODE(FunctionDeclaration, FunctionDeclaration)
+            d["name"] = childToPy(x->name);
+            d["parameters"] = listToPy(x->parameters);
+            d["expr"] = childToPy(x->expr);
+            d["pre_name_comments"] = listToPy(x->preNameComments);
+            d["post_name_comments"] = listToPy(x->postNameComments);
+            d["post_params_comments"] = listToPy(x->postParamsComments);
+        OSC_END
+        OSC_NODE(UseStatement, UseStatement) d["filepath"] = childToPy(x->filepath); OSC_END
+        OSC_NODE(IncludeStatement, IncludeStatement) d["filepath"] = childToPy(x->filepath); OSC_END
+    }
+
+#undef OSC_NODE
+#undef OSC_END
+
+    // No default: above -- the switch is exhaustive over NodeKind, so
+    // adding a node kind to the parser without handling it here is a
+    // compiler warning rather than a silently field-less dict.
+    return d;
+}
+
+} // namespace
+
+nb::list astToPy(const std::vector<std::unique_ptr<oscad::ASTNode>>& ast) {
+    nb::list out;
+    for (const std::unique_ptr<oscad::ASTNode>& n : ast) out.append(nodeToPy(n.get()));
+    return out;
+}
+
+nb::list parseAstFromFile(const std::string& path, bool includeComments) {
+    return astToPy(oscad::getASTFromFile(path, includeComments));
+}
+
+nb::list parseAstFromString(const std::string& code, bool includeComments) {
+    return astToPy(oscad::getASTFromString(code, includeComments));
+}
+
+} // namespace oscadbind

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/bindings/module.cpp

@@ -40,6 +40,14 @@
 
 namespace nb = nanobind;
 
+// Defined in ast_to_py.cpp -- snapshots the parser's AST into plain Python
+// dicts. Declared here rather than in a header since these two entry points
+// are the whole interface and only this file calls them.
+namespace oscadbind {
+nb::list parseAstFromFile(const std::string& path, bool includeComments);
+nb::list parseAstFromString(const std::string& code, bool includeComments);
+} // namespace oscadbind
+
 namespace {
 
 // Moves a std::vector's storage into a NumPy array that owns it via a
@@ -649,6 +657,12 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
+    m.def("parse_ast", &oscadbind::parseAstFromFile, nb::arg("path"), nb::arg("include_comments") = false,
+          "Parse a .scad file; return the AST as a list of plain nested dicts "
+          "(kind, position, plus that kind's own fields). A snapshot, not a view -- "
+          "safe to keep, share across threads, and outlive the parse.");
+    m.def("parse_ast_string", &oscadbind::parseAstFromString, nb::arg("code"), nb::arg("include_comments") = false,
+          "As parse_ast(), but parses a source string instead of a file.");
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
           nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -34,6 +34,22 @@ struct CSGNode {
     CSGParams params;                      // resolve step's plain-data output
     bool uncacheable = false;              // set by a later phase (ManifoldCache, Phase 8)
 
+    // The call site that entered this node's call chain from the top
+    // level, captured at RESOLVE time -- non-owning, AST-lifetime-bound
+    // like `node`. nullptr for a node resolved at top level.
+    //
+    // Needed because a GenerateFn runs long after resolve has unwound the
+    // call stack, so a warning raised there (an open polyhedron(), a
+    // non-manifold import()) has no stack left to walk and could only ever
+    // name the library's own line. One pointer per node, deliberately, so
+    // this stays affordable on a BOSL2-scale tree; the full frame list a
+    // TRACE would need is not worth the per-node cost.
+    //
+    // Not part of cacheKey() (an explicit allowlist of kind/isBuiltin/
+    // params/children), so two identical subtrees reached from different
+    // call sites still share a cache entry.
+    const oscad::Position* warnEntry = nullptr;
+
     // 1 + the deepest child's own treeDepth (1 for a leaf) -- set once,
     // at construction, by whichever csg_resolve.cpp site finalizes this
     // node's own `children` (buildTreeNode, evalModularCall's non-splice

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/include/openscad_cpp_evaluator/eval_error.hpp

@@ -117,4 +117,16 @@ std::string formatError(const std::string& msg, const oscad::Position* nodePosit
                          const std::vector<CallStackFrame>& callStack,
                          const std::string& innermostFrame = "");
 
+// "WARNING: {msg}{locSuffix(nodePosition)}, from {entry file}, line {N}"
+// followed by traceLines(). The "from" clause names the OUTERMOST frame's
+// call site -- the user's own line that entered the call chain -- because
+// a warning raised inside a library otherwise reports only the library's
+// own line, which the reader can neither act on nor trace back.
+//
+// Omitted when the stack is empty (a top-level warning, the common case,
+// which stays a single line) or when it would merely repeat the headline.
+// Deliberately richer than real OpenSCAD, which prints neither.
+std::string formatWarning(const std::string& msg, const oscad::Position* nodePosition,
+                           const std::vector<CallStackFrame>& callStack);
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -234,6 +234,24 @@ public:
     // GenerateFn is a free function, not a method -- it needs to call this
     // on the Evaluator& it's handed (see dispatch.hpp's GenerateFn doc
     // comment for why that reference exists at all).
+    // The call site that entered the current call chain from the top
+    // level (callStack_ is outermost-first), or nullptr at top level.
+    // Captured into each CSGNode at resolve time so a warning raised
+    // during generate -- after the stack has unwound -- can still name the
+    // user's own line. See CSGNode::warnEntry.
+    const oscad::Position* currentWarnEntry() const {
+        return callStack_.empty() ? nullptr : callStack_.front().callPosition;
+    }
+
+    // Set by generateTreeImpl() to the CSGNode currently being generated,
+    // so warn() can name the user's own call site during a phase where
+    // callStack_ is necessarily empty. Public for the same reason
+    // tagGenerated() is: a GenerateFn is a free function holding only an
+    // Evaluator&. Read only by warn(); a plain scoped save/restore rather
+    // than anything reentrancy-aware, since generateTreeImpl recurses
+    // depth-first on one thread.
+    const oscad::Position* generateWarnEntry = nullptr;
+
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
     // tagGenerated()'s counterpart for a mesh Manifold refused to build --

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/python/openscad_cpp_evaluator/__init__.py

@@ -18,7 +18,7 @@ from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal",
+    "FastContinueSignal", "parse_ast", "parse_ast_string",
 ]
 
 
@@ -256,6 +256,41 @@ def parse(path: str) -> RootScope:
     return RootScope(decls)
 
 
+def parse_ast(path: str, include_comments: bool = False) -> list:
+    """Parse a .scad file; return its AST as a list of plain nested dicts.
+
+    Each node is `{"kind": str, "position": {...}, **fields}`, where fields
+    are that kind's own (e.g. NumberLiteral has "val"; ModularCall has
+    "name"/"arguments"/"children"). Child nodes nest as dicts, child lists
+    as lists, and an absent optional child is None.
+
+    `position` carries `start_offset`/`end_offset`, which is the point of
+    this API: they let a caller slice the ORIGINAL source text of any
+    subexpression and reuse it verbatim, instead of re-serialising a parsed
+    value and losing how it was written (`1.500` -> `1.5`, `1e3` -> `1000`).
+
+    This is a SNAPSHOT, not a view of live parser memory: it is safe to
+    keep, mutate, share across threads, and outlive the parse. That costs
+    one walk per call, which is why it is a separate entry point rather
+    than something evaluate() always pays for.
+
+    Raises ParseError on a syntax error.
+    """
+    try:
+        return _ext.parse_ast(path, include_comments)
+    except Exception as e:
+        raise ParseError(str(e)) from e
+
+
+def parse_ast_string(code: str, include_comments: bool = False) -> list:
+    """As `parse_ast`, but parses a source string. `position.origin` is
+    "<string>" for every node. Raises ParseError on a syntax error."""
+    try:
+        return _ext.parse_ast_string(code, include_comments)
+    except Exception as e:
+        raise ParseError(str(e)) from e
+
+
 class _MeshShim:
     """Duck-types a manifold3d mesh: the four arrays the renderer reads."""
     __slots__ = ("vert_properties", "tri_verts", "run_original_id", "run_index", "num_prop")

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/src/bytecode_vm.cpp

@@ -1168,6 +1168,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     treeNode->kind = site.tagName;
                     treeNode->node = site.node;
                     treeNode->isBuiltin = true;
+                    treeNode->warnEntry = ev.currentWarnEntry();
                     treeNode->children = std::move(children);
                     treeNode->params = std::move(pending.params);
                     treeNode->uncacheable = uncacheable;
@@ -1244,6 +1245,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     treeNode->kind = site.op;
                     treeNode->node = site.node;
                     treeNode->isBuiltin = true;
+                    treeNode->warnEntry = ev.currentWarnEntry();
                     treeNode->children = std::move(children);
                     treeNode->params = std::move(params);
                     treeNode->uncacheable = uncacheable;

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/src/csg_generate.cpp

@@ -59,7 +59,14 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
 
             auto it = dispatch.find(node.kind);
             if (node.isBuiltin && it != dispatch.end()) {
+                // Resolve captured which user-level call reached this node;
+                // republish it so a warning raised inside the GenerateFn
+                // can name that line. Restored after (rather than left set)
+                // so a sibling generated at top level doesn't inherit it.
+                const oscad::Position* savedWarnEntry = generateWarnEntry;
+                generateWarnEntry = node.warnEntry;
                 node.bodies = it->second(*this, node.params, node.children, *node.node);
+                generateWarnEntry = savedWarnEntry;
             } else {
                 // No registered GenerateFn for this kind (a builtin with
                 // display-only semantics like render(), or a non-builtin

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/src/csg_resolve.cpp

@@ -66,6 +66,7 @@ void Evaluator::buildTreeNode(const std::string& kind, const oscad::ASTNode& nod
     treeNode->kind = kind;
     treeNode->node = &node;
     treeNode->isBuiltin = true;
+    treeNode->warnEntry = currentWarnEntry();
     treeNode->children = std::move(children);
     treeNode->params = std::move(params);
     treeNode->uncacheable = uncacheable;
@@ -135,6 +136,7 @@ void Evaluator::evalModularCall(const oscad::ModularCall& node, EvalContext& ctx
     treeNode->kind = name;
     treeNode->node = &node;
     treeNode->isBuiltin = true;
+    treeNode->warnEntry = currentWarnEntry();
     treeNode->uncacheable = uncacheable;
     treeNode->children = std::move(children);
     treeNode->params = std::move(params);
@@ -159,6 +161,7 @@ void Evaluator::spliceModuleChildren(std::vector<std::unique_ptr<CSGNode>> child
         unionNode->kind = "union";
         unionNode->node = &callNode;
         unionNode->isBuiltin = false;
+        unionNode->warnEntry = currentWarnEntry();
         unionNode->uncacheable = std::any_of(children.begin(), children.end(), [](const auto& c) { return c->uncacheable; });
         unionNode->children = std::move(children);
         setTreeDepthOrThrow(*unionNode, callNode);

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/src/eval_error.cpp

@@ -78,4 +78,48 @@ std::string formatError(const std::string& msg, const oscad::Position* nodePosit
     return full;
 }
 
+std::string formatWarning(const std::string& msg, const oscad::Position* nodePosition,
+                           const std::vector<CallStackFrame>& callStack) {
+    // The warning keeps its OWN location in the headline: that is where the
+    // problem actually is, and it's what you need in order to fix a genuine
+    // library bug. But on its own, a warning raised deep inside a library
+    // ("in file BOSL2/vnf.scad, line 1624") is close to useless -- the
+    // reader's next question is always "which line of MINE caused that?",
+    // and nothing in the message answered it.
+    //
+    // callStack is outermost-first, so front() is the call that entered
+    // this chain from the top level -- the user's own line, however deep
+    // the warning surfaced. Naming it inline makes the common case a
+    // one-line answer; the TRACE lines below carry the full chain for when
+    // an intermediate frame is the real culprit.
+    //
+    // Real OpenSCAD reports only the raising location and no trace at all
+    // (verified against 2022.08.22), so this is deliberately more than the
+    // reference gives: warnings there routinely point into library
+    // internals with no way back to the caller.
+    std::string full = "WARNING: " + msg + locSuffix(nodePosition);
+
+    if (!callStack.empty()) {
+        const oscad::Position* entry = callStack.front().callPosition;
+        // Skip the clause when it would only repeat the headline (a warning
+        // raised directly at the top-level call site), or when the entry
+        // frame recorded no call position.
+        const bool sameSpot = entry != nullptr && nodePosition != nullptr &&
+                               entry->origin == nodePosition->origin && entry->line == nodePosition->line;
+        if (entry != nullptr && !sameSpot) {
+            full += ", from " + entry->origin + ", line " + std::to_string(entry->line);
+        }
+    }
+
+    // Same shape and truncation as an error's trace, including the
+    // 10-frames-each-end bound for pathologically deep chains. A warning
+    // raised outside any call has an empty stack and stays a single line --
+    // the overwhelmingly common case, which keeps ordinary warnings from
+    // sprouting a trace nobody needs.
+    for (const std::string& line : traceLines(nodePosition, callStack, "")) {
+        full += "\n" + line;
+    }
+    return full;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/src/expr_eval.cpp

@@ -95,7 +95,25 @@ FontProvider& Evaluator::fontProvider() {
 }
 
 void Evaluator::warn(const std::string& message, const oscad::Position* position) {
-    if (echoFn_) echoFn_("WARNING: " + message + locSuffix(position));
+    if (!echoFn_) return;
+    // During generate the call stack has already unwound, so fall back to
+    // the entry position resolve captured onto the CSGNode being generated
+    // (see CSGNode::warnEntry). Passed as a synthetic single-frame stack so
+    // formatWarning needs no second code path -- the frame carries no name,
+    // which traceLines renders as a bare "called by ''" line, so it is
+    // deliberately NOT included there; only the headline's "from" clause
+    // uses it.
+    if (callStack_.empty() && generateWarnEntry != nullptr) {
+        std::string out = formatWarning(message, position, {});
+        const bool sameSpot = position != nullptr && generateWarnEntry->origin == position->origin &&
+                               generateWarnEntry->line == position->line;
+        if (!sameSpot) {
+            out += ", from " + generateWarnEntry->origin + ", line " + std::to_string(generateWarnEntry->line);
+        }
+        echoFn_(out);
+        return;
+    }
+    echoFn_(formatWarning(message, position, callStack_));
 }
 
 Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position* position, EvalContext& ctx,

{openscad_cpp_evaluator-0.15.0 → openscad_cpp_evaluator-0.17.0}/tests/test_bytecode_compiler.cpp

@@ -1623,9 +1623,17 @@ TEST(ModuleBodyCompiles, DollarArgPropagatesIntoCompiledHullWrapChildren) {
 // side effect to preserve).
 TEST(ModuleBodyCompiles, CompiledRoofUnknownMethodWarningStaysOrderedAfterChildrensOwnEcho) {
     ScopedVm vm(true);
-    EXPECT_EQ(runCapturingEcho("module m() { roof(method=\"bogus\") { echo(\"child\"); square(4, center=true); } }\n"
-                               "m();"),
-              "ECHO: \"child\"\nWARNING: Unknown roof method 'bogus'. Using 'voronoi'.");
+    const std::string out = runCapturingEcho(
+        "module m() { roof(method=\"bogus\") { echo(\"child\"); square(4, center=true); } }\n"
+        "m();");
+    // Asserted as an ordering rather than one exact string: the warning also
+    // carries call-site attribution (", from ... line N" plus TRACE lines,
+    // see formatWarning), which is orthogonal to what this test pins.
+    const size_t echoAt = out.find("ECHO: \"child\"");
+    const size_t warnAt = out.find("WARNING: Unknown roof method 'bogus'. Using 'voronoi'.");
+    ASSERT_NE(echoAt, std::string::npos) << out;
+    ASSERT_NE(warnAt, std::string::npos) << out;
+    EXPECT_LT(echoAt, warnAt) << out;
 }
 
 // -- intersection_for -- the TRUE last native-reentry gap, closed by -------