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

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

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

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -1234,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/
@@ -1252,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);
@@ -1712,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.22.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.17.0 → openscad_cpp_evaluator-0.22.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.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.17.0 → openscad_cpp_evaluator-0.22.0}/src/csg_resolve.cpp

@@ -269,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),
         };
     }
 

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.0}/src/debug_profile.cpp

@@ -116,12 +116,87 @@ void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool fo
     if (action.stop) throw EvalError(kDebuggingStoppedMessage);
 }
 
+int Evaluator::profilePathEnter(const std::string& kind, const std::string& name, const std::string& callOrigin,
+                                 int callLine, int callColumn, const oscad::Position* declPos, bool& folded) {
+    folded = false;
+    if (profilePaths_.empty()) {
+        ProfilePathNode root;
+        root.name = "<toplevel>";
+        profilePaths_.push_back(std::move(root));
+        profileCurrentPath_ = 0;
+    }
+    const int parent = profileCurrentPath_ < 0 ? 0 : profileCurrentPath_;
+
+    // Immediate self-recursion folds onto the parent rather than growing a
+    // chain per level (see ProfilePathNode).
+    //
+    // Only the parent, never a deeper ancestor. Folding across intervening
+    // nodes credits the whole re-entered subtree to the ancestor, and every
+    // node between it and here loses that time -- cumulative is derived
+    // bottom-up, so it can only count what is actually below. A BOSL2
+    // attachment chain showed restore() at 226ms in the flat view and 2.5ms
+    // in the tree for the same call site, because its callees re-entered a
+    // multmatrix already open further up and took 223ms with them.
+    //
+    // A cycle through other call sites therefore gets a real node. That is
+    // what makes the tree's numbers agree with the flat view's; the cost is
+    // more nodes on mutually-recursive chains, which kMaxProfilePathNodes
+    // still bounds.
+    if (parent > 0) {
+        const ProfilePathNode& n = profilePaths_[static_cast<size_t>(parent)];
+        if (n.name == name && n.callOrigin == callOrigin && n.callLine == callLine &&
+            n.callColumn == callColumn && n.kind == kind) {
+            folded = true;   // direct recursion: this site called itself
+            return parent;
+        }
+    }
+    for (int childIdx : profilePaths_[static_cast<size_t>(parent)].children) {
+        const ProfilePathNode& n = profilePaths_[static_cast<size_t>(childIdx)];
+        if (n.name == name && n.callOrigin == callOrigin && n.callLine == callLine &&
+            n.callColumn == callColumn && n.kind == kind) {
+            return childIdx;
+        }
+    }
+    if (profilePaths_.size() >= kMaxProfilePathNodes) {
+        folded = true;       // cap reached: stop subdividing, keep totals honest
+        return parent;
+    }
+
+    ProfilePathNode node;
+    node.parent = parent;
+    node.kind = kind;
+    node.name = name;
+    node.callOrigin = callOrigin;
+    node.callLine = callLine;
+    node.callColumn = callColumn;
+    node.declOrigin = declPos ? declPos->origin : "";
+    node.declLine = declPos ? declPos->line : 0;
+    const int idx = static_cast<int>(profilePaths_.size());
+    profilePaths_.push_back(std::move(node));
+    profilePaths_[static_cast<size_t>(parent)].children.push_back(idx);
+    return idx;
+}
+
+void Evaluator::finalizeProfilePaths() {
+    // Children always have a higher index than their parent (a node is
+    // appended when first reached, and folding never creates an edge back
+    // to an ancestor), so one reverse sweep resolves the whole tree with
+    // no recursion and no risk of an unbounded native stack.
+    for (size_t i = profilePaths_.size(); i-- > 0;) {
+        ProfilePathNode& n = profilePaths_[i];
+        double total = n.selfTime;
+        for (int c : n.children) total += profilePaths_[static_cast<size_t>(c)].cumulativeTime;
+        n.cumulativeTime = total;
+    }
+}
+
 std::optional<Evaluator::ProfileHandle> Evaluator::profileEnter(const std::string& kind, const std::string& name,
                                                                   const oscad::Position* callPos, const oscad::Position* declPos) {
     if (!profiling_) return std::nullopt;
     const std::string callOrigin = callPos ? callPos->origin : "";
     const int callLine = callPos ? callPos->line : 0;
-    const ProfileSiteKey key{kind, name, callOrigin, callLine};
+    const int callColumn = callPos ? callPos->column : 0;
+    const ProfileSiteKey key{kind, name, callOrigin, callLine, callColumn};
 
     auto it = profileSites_.find(key);
     if (it == profileSites_.end()) {
@@ -137,6 +212,7 @@ std::optional<Evaluator::ProfileHandle> Evaluator::profileEnter(const std::strin
         site.callerName = callStack_.empty() ? "<toplevel>" : callStack_.back().name;
         site.callOrigin = callOrigin;
         site.callLine = callLine;
+        site.callColumn = callColumn;
         site.declOrigin = declPos ? declPos->origin : "";
         site.declLine = declPos ? declPos->line : 0;
         it = profileSites_.emplace(key, std::move(site)).first;
@@ -146,7 +222,17 @@ std::optional<Evaluator::ProfileHandle> Evaluator::profileEnter(const std::strin
     const bool recursiveReentry = profileActive_.count(key) > 0;
     if (!recursiveReentry) profileActive_.insert(key);
     profileChildTime_.push_back(0.0);
-    return ProfileHandle{key, recursiveReentry, std::chrono::steady_clock::now()};
+
+    const int prevPath = profileCurrentPath_;
+    bool folded = false;   // only affects node reuse now, not accounting
+    const int pathNode = profilePathEnter(kind, name, callOrigin, callLine, callColumn, declPos, folded);
+    profilePaths_[static_cast<size_t>(pathNode)].callCount += 1;
+    profileCurrentPath_ = pathNode;
+
+    ProfileHandle handle{key, recursiveReentry, std::chrono::steady_clock::now()};
+    handle.pathNode = pathNode;
+    handle.pathPrev = prevPath;
+    return handle;
 }
 
 void Evaluator::profileRecordTailHop(const std::string& kind, const std::string& name, const oscad::Position* callPos,
@@ -154,7 +240,8 @@ void Evaluator::profileRecordTailHop(const std::string& kind, const std::string&
     if (!profiling_) return;
     const std::string callOrigin = callPos ? callPos->origin : "";
     const int callLine = callPos ? callPos->line : 0;
-    const ProfileSiteKey key{kind, name, callOrigin, callLine};
+    const int callColumn = callPos ? callPos->column : 0;
+    const ProfileSiteKey key{kind, name, callOrigin, callLine, callColumn};
 
     auto it = profileSites_.find(key);
     if (it == profileSites_.end()) {
@@ -174,6 +261,7 @@ void Evaluator::profileRecordTailHop(const std::string& kind, const std::string&
         site.callerName = callStack_.empty() ? "<toplevel>" : callStack_.back().name;
         site.callOrigin = callOrigin;
         site.callLine = callLine;
+        site.callColumn = callColumn;
         site.declOrigin = declPos ? declPos->origin : "";
         site.declLine = declPos ? declPos->line : 0;
         it = profileSites_.emplace(key, std::move(site)).first;
@@ -199,6 +287,31 @@ void Evaluator::profileExit(const ProfileHandle& handle) {
         site.cumulativeTime += elapsed;
         profileActive_.erase(handle.key);
     }
+
+    // Same accounting, but attributed to this call's own node in the
+    // calling-context tree rather than to the site aggregated over every
+    // path that reached it.
+    if (handle.pathNode >= 0 && static_cast<size_t>(handle.pathNode) < profilePaths_.size()) {
+        // Self time only. Cumulative is DERIVED from the subtree once the
+        // run finishes (finalizeProfilePaths), not measured here.
+        //
+        // Measuring it per entry is wrong at a fold point: when a site
+        // recurses, every level lands on the same node, but only the
+        // outermost entry may add its elapsed (or nested time double-
+        // counts) -- while the calls made from every level still attach as
+        // that node's children. The node then reads smaller than the
+        // children under it. Found on a real model: a `_translate` entered
+        // 7 times via recursion showed 22.85ms with 90.09ms of children.
+        //
+        // Self time has no such problem: it is disjoint by construction
+        // (the child-time stack subtracts nested work), so summing it
+        // across every entry is exactly this node's own cost on this path,
+        // and cumulative built from it can never contradict the subtree.
+        ProfilePathNode& node = profilePaths_[static_cast<size_t>(handle.pathNode)];
+        node.selfTime += elapsed - childTime;
+        profileCurrentPath_ = handle.pathPrev;
+    }
+
     if (!profileChildTime_.empty()) profileChildTime_.back() += elapsed;
 }
 

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.0}/src/eval_context.cpp

@@ -41,6 +41,7 @@ EvalContext EvalContext::childCtx(const oscad::Scope* newScope, std::optional<st
     result.color = newColor.has_value() ? newColor : color;
     result.childrenNodes = newChildrenNodes ? newChildrenNodes : childrenNodes;
     result.childrenCallerCtx = newChildrenCallerCtx ? newChildrenCallerCtx : childrenCallerCtx;
+    result.viaChildren = viaChildren;
     return result;
 }
 

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.0}/src/user_calls.cpp

@@ -337,6 +337,9 @@ EvalContext Evaluator::buildModuleChildCtx(const oscad::ModuleDeclaration& decl,
     for (const auto& c : call.children) childrenNodes->push_back(c.get());
 
     EvalContext childCtx = callCtxFor(decl, ctx, childScope, childrenNodes, &ctx);
+    // callCtx reset this to false; carry the CALLER's value across so
+    // enterUserCall can tell a forwarded child from a recursive call.
+    childCtx.viaChildren = ctx.viaChildren;
 
     // $children counts module-instantiation child *statements* passed in
     // `{}`, not the number of geometries they produce -- e.g. children()
@@ -712,7 +715,12 @@ Evaluator::UserCallHandle Evaluator::enterUserCall(const std::string& name, cons
         ++nativeUserCallDepth_;
         h.countedTowardNativeDepth = true;
     }
-    h.prof = profileEnter(isModule ? "module" : "function", name, callPos, &declNode.position());
+    // Consumed, not just read: the body's own statements run in this same
+    // ctx, and a plain call among them is not itself a forwarded child.
+    const bool viaChildren = childCtx.viaChildren;
+    childCtx.viaChildren = false;
+    h.prof = profileEnter(isModule ? (viaChildren ? "child" : "module") : "function", name, callPos,
+                          &declNode.position());
     callStack_.push_back(CallStackFrame{kind, name, callPos, &declNode.position(), &declNode, nullptr, upvalueParent});
     callStack_.back().bodyCtx = &childCtx; // per-frame locals for the debugger
     if (isModule) ++moduleCallDepth_;
@@ -920,6 +928,11 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
     // A children() forwarding chain's own dyn/let_/etc. must alias the
     // *caller's* (not this ctx's) -- see EvalContext::withScope's rationale.
     EvalContext evalCtx = callerCtx->childCtx(nullptr, std::nullopt, callerCtx->childrenNodes, callerCtx->childrenCallerCtx);
+    // Everything evaluated from this context is a forwarded child, so a
+    // module call reached through it profiles as "child" not "module".
+    // Set here rather than at the returns: there are two of them (bare
+    // children() and indexed children(i)).
+    evalCtx.viaChildren = true;
     // `ctx` here is the post-resolveCallArgs effCtx, deliberately: a
     // `children($fn=12)`-style named-$ override lives only at effCtx's own
     // trail level, and TrailView::items() is ancestry-visible, so reading

{openscad_cpp_evaluator-0.17.0 → openscad_cpp_evaluator-0.22.0}/tests/test_cli.cpp

@@ -222,7 +222,7 @@ TEST(CliProfile, CsvFormatWritesHeaderAndCommaSeparatedRows) {
               0);
     const std::string text = readFile(report);
     EXPECT_NE(text.find("# total_time,"), std::string::npos);
-    EXPECT_NE(text.find("kind,name,caller,call_origin,call_line,call_count,self_time,cumulative_time\n"), std::string::npos);
+    EXPECT_NE(text.find("kind,name,caller,call_origin,call_line,call_column,call_count,self_time,cumulative_time\n"), std::string::npos);
     EXPECT_NE(text.find("function,fib,"), std::string::npos);
     std::filesystem::remove(src);
     std::filesystem::remove(out);