openscad-cpp-evaluator 0.16.0__tar.gz → 0.21.0__tar.gz

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/bindings/module.cpp

@@ -246,10 +246,34 @@ nb::object profileResultToPy(const std::optional<oscadeval::ProfileResult>& pr)
     if (!pr) return nb::none();
     nb::list sites;
     for (const oscadeval::CallSiteProfile& s : pr->callSites) {
-        sites.append(facadeAttr("CallSiteProfile")(s.kind, s.name, s.callerName, s.callOrigin, s.callLine, s.declOrigin,
-                                                     s.declLine, s.callCount, s.selfTime, s.cumulativeTime));
+        sites.append(facadeAttr("CallSiteProfile")(s.kind, s.name, s.callerName, s.callOrigin, s.callLine, s.callColumn,
+                                                     s.declOrigin, s.declLine, s.callCount, s.selfTime, s.cumulativeTime));
     }
-    return facadeAttr("ProfileResult")(sites, pr->resolveTime, pr->generateTime, pr->totalTime, pr->unattributedTime);
+    // The calling-context tree, as plain dicts. Parent/child INDICES, not
+    // nested objects: the C++ side is already a flat vector keyed that way,
+    // and a self-referential nesting would have to be rebuilt here for no
+    // gain -- a consumer walks it by index just as C++ does.
+    nb::list paths;
+    for (const oscadeval::ProfilePathNode& n : pr->paths) {
+        nb::dict d;
+        d["parent"] = n.parent;
+        nb::list kids;
+        for (int c : n.children) kids.append(c);
+        d["children"] = kids;
+        d["kind"] = n.kind;
+        d["name"] = n.name;
+        d["call_origin"] = n.callOrigin;
+        d["call_line"] = n.callLine;
+        d["call_column"] = n.callColumn;
+        d["decl_origin"] = n.declOrigin;
+        d["decl_line"] = n.declLine;
+        d["call_count"] = n.callCount;
+        d["self_time"] = n.selfTime;
+        d["cumulative_time"] = n.cumulativeTime;
+        paths.append(d);
+    }
+    return facadeAttr("ProfileResult")(sites, pr->resolveTime, pr->generateTime, pr->totalTime, pr->unattributedTime,
+                                        paths);
 }
 
 // ctx.dyn / ctx.dynExplicit -> (dict[str, Any], set[str]) -- every currently-

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -49,6 +49,18 @@ public:
     LexPos tokenEnd;
     std::string stringBuffer; // accumulates a STRING token's content while in the %x STR lexer state
 
+    // Where the opening quote of the STRING currently being lexed began.
+    //
+    // Needed because YY_USER_ACTION resets tokenStart on EVERY rule match,
+    // and a string is matched by several rules (opening quote, content
+    // runs, escapes, closing quote). currentTokenLoc() at the closing
+    // quote therefore describes just that one character, which made every
+    // StringLiteral's source span a single `"` -- and dragged the span of
+    // anything wrapping it (a PositionalArgument, a vector element) along
+    // with it. Recorded when the opening quote is matched and used by
+    // stringTokenLoc() below.
+    LexPos stringStart;
+
     Position toPosition(const OscadLocation& loc) const {
         return Position{origin_, loc.first_line, loc.first_column, loc.first_offset, loc.last_offset};
     }
@@ -58,6 +70,15 @@ public:
                               tokenEnd.column, tokenStart.offset, tokenEnd.offset};
     }
 
+    // As currentTokenLoc(), but spanning from the string's OPENING quote
+    // (stringStart) to the current token's end -- i.e. the whole literal
+    // including both quotes, which is what a caller slicing the source by
+    // this span expects to get back.
+    OscadLocation stringTokenLoc() const {
+        return OscadLocation{stringStart.line,  stringStart.column, tokenEnd.line,
+                              tokenEnd.column,  stringStart.offset, tokenEnd.offset};
+    }
+
     void reportError(const OscadLocation& loc, const std::string& message);
 };
 

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/external/openscad_cpp_parser/src/grammar/lexer.l

@@ -93,13 +93,17 @@ NUMLIT  0[xX][0-9A-Fa-f]+|[0-9]+([.][0-9]*)?([eE][+-]?[0-9]+)?|[.][0-9]+([eE][+-
 
 \" {
     driver.stringBuffer.clear();
+    // YY_USER_ACTION has just set tokenStart to this opening quote; keep
+    // it, because the rules that follow will overwrite it (see
+    // ParserDriver::stringStart).
+    driver.stringStart = driver.tokenStart;
     BEGIN(STR);
 }
 <STR>\\. { driver.stringBuffer.append(yytext, yyleng); }
 <STR>[^"\\]+ { driver.stringBuffer.append(yytext, yyleng); }
 <STR>\" {
     BEGIN(INITIAL);
-    return yy::parser::make_STRING(driver.stringBuffer, driver.currentTokenLoc());
+    return yy::parser::make_STRING(driver.stringBuffer, driver.stringTokenLoc());
 }
 
 <INCFILE>[ \t\r\n]+       { /* skip whitespace before < */ }

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/external/openscad_cpp_parser/tests/test_lexical.cpp

@@ -363,3 +363,76 @@ TEST(LexicalIdentifiers, IdentifierStr) {
     std::vector<std::unique_ptr<ASTNode>> ast;
     EXPECT_EQ(exprSrc("foo", ast)->toString(), "foo");
 }
+
+// -- Source spans ---------------------------------------------------------
+
+namespace {
+// The source text a node's own position spans -- what a consumer slicing
+// by start/end_offset actually gets back.
+std::string spanned(const std::string& src, const oscad::ASTNode& n) {
+    const auto& p = n.position();
+    return src.substr(static_cast<size_t>(p.start_offset),
+                       static_cast<size_t>(p.end_offset - p.start_offset));
+}
+} // namespace
+
+// A string is matched by SEVERAL lexer rules (opening quote, content runs,
+// escapes, closing quote), and YY_USER_ACTION resets tokenStart on every
+// one of them -- so building the token's location from currentTokenLoc() at
+// the closing quote described just that one character. Every StringLiteral
+// spanned a bare `"`, and so did anything wrapping it, which silently
+// corrupted a downstream consumer that sliced source by those offsets.
+TEST(SourceSpans, StringLiteralSpansTheWholeLiteral) {
+    struct Case { std::string src; std::string want; };
+    const Case cases[] = {
+        {"a = \"txt\";", "\"txt\""},
+        {"a = \"\";", "\"\""},                                  // empty
+        {"a = \"with \\\"quote\\\" in it\";", "\"with \\\"quote\\\" in it\""},
+        {"a = \"esc \\n seq\";", "\"esc \\n seq\""},
+        {"a = \"comma,inside\";", "\"comma,inside\""},
+    };
+    for (const Case& c : cases) {
+        auto ast = oscad::parseSrc(c.src);
+        ASSERT_EQ(ast.size(), 1u) << c.src;
+        auto* assign = dynamic_cast<oscad::Assignment*>(ast[0].get());
+        ASSERT_NE(assign, nullptr) << c.src;
+        EXPECT_EQ(spanned(c.src, *assign->expr), c.want) << c.src;
+    }
+}
+
+// The enclosing node's span has to be right too -- that is how the bug
+// actually did damage, by dragging an argument's end_offset into the
+// middle of the string.
+TEST(SourceSpans, NodesWrappingAStringSpanCorrectly) {
+    const std::string src = "f(\"x,y\", b);";
+    auto ast = oscad::parseSrc(src);
+    auto* call = dynamic_cast<oscad::ModularCall*>(ast[0].get());
+    ASSERT_NE(call, nullptr);
+    ASSERT_EQ(call->arguments.size(), 2u);
+    EXPECT_EQ(spanned(src, *call->arguments[0]), "\"x,y\"");
+    EXPECT_EQ(spanned(src, *call->arguments[1]), "b");
+}
+
+TEST(SourceSpans, StringsInAVectorSpanCorrectly) {
+    const std::string src = "x = [\"a,b\",\"c\"];";
+    auto ast = oscad::parseSrc(src);
+    auto* assign = dynamic_cast<oscad::Assignment*>(ast[0].get());
+    ASSERT_NE(assign, nullptr);
+    auto* vec = dynamic_cast<oscad::ListComprehension*>(assign->expr.get());
+    ASSERT_NE(vec, nullptr);
+    ASSERT_EQ(vec->elements.size(), 2u);
+    EXPECT_EQ(spanned(src, *vec->elements[0]), "\"a,b\"");
+    EXPECT_EQ(spanned(src, *vec->elements[1]), "\"c\"");
+}
+
+// Multi-line strings must still report the OPENING quote's line/column, not
+// the closing one's.
+TEST(SourceSpans, MultiLineStringReportsItsStartingLine) {
+    const std::string src = "a = 1;\nb = \"one\ntwo\";\n";
+    auto ast = oscad::parseSrc(src);
+    ASSERT_EQ(ast.size(), 2u);
+    auto* assign = dynamic_cast<oscad::Assignment*>(ast[1].get());
+    ASSERT_NE(assign, nullptr);
+    EXPECT_EQ(assign->expr->position().line, 2);
+    EXPECT_EQ(spanned(src, *assign->expr), "\"one\ntwo\"");
+}

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.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.16.0 → openscad_cpp_evaluator-0.21.0}/include/openscad_cpp_evaluator/eval_context.hpp

@@ -59,6 +59,21 @@ struct EvalContext {
     std::shared_ptr<const ChildrenNodeList> childrenNodes;
     const EvalContext* childrenCallerCtx = nullptr;
 
+    // True while evaluating statements that a children() forwarded, so a
+    // module call reached this way profiles as kind "child" rather than
+    // "module". `foo() foo();` and `module foo() { foo(); }` both produce a
+    // foo->foo edge, but only the second is recursion, and a profile that
+    // cannot tell them apart is misleading.
+    //
+    // Propagates through withScope/childCtx (a forwarded `translate()
+    // foo()` is still child-passing) but NOT through callCtx, which resets
+    // it by omission -- entering a body ends the forwarding. The one
+    // deliberate exception is buildModuleChildCtx, which copies the
+    // caller's flag onto the body ctx so enterUserCall can read it there;
+    // enterUserCall then clears it, so the call it describes is the only
+    // one that sees it.
+    bool viaChildren = false;
+
     // The one genuinely fresh construction: seeds `dyn` with OpenSCAD's
     // built-in $-variable defaults ($fn=0, $fa=12, $fs=2, $t=0,
     // $parent_modules=0). Every other EvalContext in a run is derived

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.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.16.0 → openscad_cpp_evaluator-0.21.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 --
@@ -1216,12 +1234,16 @@ private:
 
     // -- Profiling (Phase 9) --------------------------------------------
 
-    // (kind, name, callOrigin, callLine) -- the exact call-site identity a
+    // (kind, name, callOrigin, callLine, callColumn) -- the exact call-site
+    // identity a
     // CallSiteProfile aggregates by. std::map (not unordered_map): a plain
     // tuple of comparable fields already gets a free operator< from the
     // standard library, so this needs no custom hash function for a table
     // that's never more than a few thousand entries even on a large script.
-    using ProfileSiteKey = std::tuple<std::string, std::string, std::string, int>;
+    // Column is part of the key, not decoration: `foo() foo();` and
+    // `f(g(x))` put two distinct call sites on one line, and without it
+    // they aggregate into one entry whose times belong to neither.
+    using ProfileSiteKey = std::tuple<std::string, std::string, std::string, int, int>;
 
     // Pushes profiling state for a user module/function call about to
     // start -- shared by evalUserModule/evalUserFunction/
@@ -1234,6 +1256,13 @@ private:
         ProfileSiteKey key;
         bool recursiveReentry;
         std::chrono::steady_clock::time_point start;
+        // Node this call occupies in the calling-context tree, and the one
+        // to restore on exit. `pathRecursive` is the per-PATH equivalent of
+        // recursiveReentry: true when this entry folded back onto a node
+        // already on the path, so only the outermost entry adds cumulative
+        // time -- the same rule callSites uses, applied per node.
+        int pathNode = -1;
+        int pathPrev = -1;
     };
     std::optional<ProfileHandle> profileEnter(const std::string& kind, const std::string& name,
                                                const oscad::Position* callPos, const oscad::Position* declPos);
@@ -1694,6 +1723,34 @@ private:
     std::map<ProfileSiteKey, CallSiteProfile> profileSites_;
     std::set<ProfileSiteKey> profileActive_; // site keys with a call currently on callStack_
     std::vector<double> profileChildTime_;   // parallel aux stack to callStack_
+
+    // Calling-context tree (see ProfilePathNode). profilePaths_[0] is the
+    // <toplevel> root, created lazily on the first profiled call;
+    // profileCurrentPath_ is the node the running call belongs to, so a
+    // profileEnter knows which parent to hang its node off.
+    std::vector<ProfilePathNode> profilePaths_;
+    int profileCurrentPath_ = -1;
+
+    // Safety valve. The tree is bounded by distinct ACYCLIC paths (see
+    // ProfilePathNode on recursion folding), which is finite but can still
+    // be large for a deeply-layered library. Past this, no new nodes are
+    // created and further calls fold onto their parent -- the report stays
+    // truthful about totals and simply stops subdividing, rather than the
+    // profiler becoming the thing that runs out of memory.
+    static constexpr size_t kMaxProfilePathNodes = 200000;
+
+    // Finds-or-creates the child of profileCurrentPath_ for this call site
+    // and returns its index. Sets `folded` when the returned node was
+    // already on the current path (recursion, or the node cap) rather than
+    // a fresh or sibling child -- the caller must then skip cumulative
+    // time for this entry, exactly as recursiveReentry does for callSites.
+    int profilePathEnter(const std::string& kind, const std::string& name, const std::string& callOrigin,
+                          int callLine, int callColumn, const oscad::Position* declPos, bool& folded);
+
+    // Fills in every node's cumulativeTime as selfTime + the cumulative of
+    // its children, bottom-up. See profileExit for why this is derived
+    // rather than measured.
+    void finalizeProfilePaths();
 };
 
 } // namespace oscadeval

openscad_cpp_evaluator-0.21.0/include/openscad_cpp_evaluator/profile.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// Aggregated profiling data for one *call site* -- a specific source
+// location that calls a specific user module/function, not one
+// declaration. Two different calls to the same function get separate
+// entries; the same call expression re-executed many times (a loop body,
+// recursion) aggregates into one entry with callCount > 1, since the AST
+// node (and thus its position) is identical across those invocations.
+// Mirrors the reference's CallSiteProfile.
+struct CallSiteProfile {
+    std::string kind; // "module" | "child" (forwarded via children()) | "function"
+    std::string name;
+    std::string callerName; // enclosing module/function's own name, or "<toplevel>"
+    std::string callOrigin;
+    int callLine = 0;
+    int callColumn = 0; // distinguishes two calls sharing one line
+    std::string declOrigin;
+    int declLine = 0;
+    int callCount = 0;
+    double selfTime = 0.0;       // seconds, own code only, never double-counted
+    double cumulativeTime = 0.0; // seconds, includes children; recursion-guarded
+};
+
+// One node of the calling-context tree: a call site reached by ONE
+// specific path from <toplevel>. Where CallSiteProfile aggregates a site
+// over every path that reached it, this keeps them separate -- so
+// `cuboid` called from `bracket` and `cuboid` called from `rail` are two
+// nodes with their own times, and a consumer can show what a particular
+// path actually cost rather than a total across all callers.
+//
+// Flat vector with parent/child indices rather than pointers: it survives
+// the vector reallocating as nodes are appended, and crosses the Python
+// binding as plain data with no ownership question.
+//
+// Recursion is folded rather than unrolled. Re-entering a call site
+// already on the current path reuses that node instead of appending a new
+// child, so `fib` calling itself 400 deep is one node with callCount 400,
+// not a 400-node chain. That bounds the tree by distinct ACYCLIC paths and
+// keeps the recursion-guarded cumulative-time rule (only the outermost
+// entry contributes) meaningful per node.
+struct ProfilePathNode {
+    int parent = -1;              // index into ProfileResult::paths; -1 for the root
+    std::vector<int> children;    // indices, in first-call order
+    std::string kind;             // "module" | "child" | "function"; empty for the root
+    std::string name;             // callee; "<toplevel>" for the root
+    std::string callOrigin;
+    int callLine = 0;
+    int callColumn = 0;           // distinguishes two calls sharing one line
+    std::string declOrigin;
+    int declLine = 0;
+    int callCount = 0;
+    double selfTime = 0.0;        // seconds, this node's own code on this path
+    double cumulativeTime = 0.0;  // seconds, this node and everything under it
+};
+
+// Whole-evaluate() profiling summary, built when Evaluator is constructed
+// with profiling=true. unattributedTime covers top-level script code and
+// anything else not inside a user module/function call (native builtins'
+// own resolve work, mostly) -- resolveTime always equals
+// sum(s.selfTime for callSites) + unattributedTime, so a UI can show
+// percentages that honestly add to 100%. Mirrors the reference's
+// ProfileResult.
+struct ProfileResult {
+    std::vector<CallSiteProfile> callSites;
+    // The calling-context tree; paths[0] is always the <toplevel> root.
+    // Empty only if profiling was off. callSites stays exactly as it was --
+    // the flat per-site view is still the right answer to "what is
+    // expensive overall", and is cheaper to scan than walking this.
+    std::vector<ProfilePathNode> paths;
+    double resolveTime = 0.0;
+    double generateTime = 0.0;
+    double totalTime = 0.0;
+    double unattributedTime = 0.0;
+};
+
+} // namespace oscadeval

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.0}/python/openscad_cpp_evaluator/__init__.py

@@ -9,7 +9,7 @@ like a manifold3d body (`.is_empty()` / `.to_mesh()`), so the renderer reads
 `cb.body.to_mesh().vert_properties/tri_verts/run_original_id/run_index`
 exactly as before -- no cross-module Manifold objects are ever exchanged.
 """
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 from . import _openscad_cpp_evaluator as _ext
@@ -142,11 +142,12 @@ class _CSGNode:
 class CallSiteProfile:
     """Aggregated profiling data for one call site. Mirrors the reference's
     CallSiteProfile -- see ProfileResult's own docstring."""
-    kind: str            # "module" | "function"
+    kind: str            # "module" | "child" | "function"
     name: str
     caller_name: str
     call_origin: str
     call_line: int
+    call_column: int
     decl_origin: str
     decl_line: int
     call_count: int = 0
@@ -165,6 +166,23 @@ class ProfileResult:
     generate_time: float
     total_time: float
     unattributed_time: float
+    # Calling-context tree: a flat list of dicts, paths[0] the <toplevel>
+    # root, linked by `parent`/`children` INDICES into this same list.
+    #
+    # Where call_sites aggregates a site over every path that reached it,
+    # each node here is one call site on ONE path -- so `cuboid` called
+    # from `bracket` and from `rail` are separate nodes with their own
+    # times, and a report can say what a particular path cost rather than
+    # only what a name cost in total.
+    #
+    # Keys: parent, children, kind, name, call_origin, call_line,
+    # decl_origin, decl_line, call_count, self_time, cumulative_time.
+    #
+    # Recursion is folded: re-entering a site already on the path reuses
+    # that node (call_count rises) instead of unrolling a node per level.
+    # Defaults to empty so a ProfileResult built by older code still
+    # constructs.
+    paths: list = field(default_factory=list)
 
 
 def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.21.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.16.0 → openscad_cpp_evaluator-0.21.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.16.0 → openscad_cpp_evaluator-0.21.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);
@@ -266,8 +269,10 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
             selfSum += site.selfTime;
             sites.push_back(site);
         }
+        finalizeProfilePaths();
         profileResult = ProfileResult{
-            std::move(sites), resolveTime, generateTime, resolveTime + generateTime, std::max(0.0, resolveTime - selfSum),
+            std::move(sites), profilePaths_, resolveTime, generateTime, resolveTime + generateTime,
+            std::max(0.0, resolveTime - selfSum),
         };
     }