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

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

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

{openscad_cpp_evaluator-0.16.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.16.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.16.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.16.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.16.0"
+version = "0.17.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.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.16.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.16.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.16.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.16.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.16.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 -------

{openscad_cpp_evaluator-0.16.0 → openscad_cpp_evaluator-0.17.0}/tests/test_csg_tree.cpp

@@ -244,3 +244,73 @@ TEST(CsgTree, DeepNonTailChainErrorTraceStaysBoundedInsteadOfMegabytes) {
         EXPECT_LE(count, 41u); // 40 shown (20 each end, 2 lines/Module frame) + 1 marker
     }
 }
+
+// -- Warning call-site attribution ----------------------------------------
+
+// A warning raised inside a module reports where it happened AND which
+// top-level line reached it. Without the latter, a warning from library
+// code names only the library's own line, which the reader can neither act
+// on nor trace back to their own script.
+//
+// Deliberately richer than real OpenSCAD, which prints the raising location
+// alone and no trace (verified against 2022.08.22).
+TEST(WarningTrace, EvalTimeWarningNamesTheTopLevelCallSite) {
+    std::string warning;
+    evalSrc("function helper(n) = n + nope;\n"      // line 1: warning raised here
+            "module inner(v) { x = helper(v); cube(1); }\n"
+            "module outer(q) { inner(q); }\n"
+            "outer(2);\n",                           // line 4: the user's own line
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+
+    EXPECT_NE(warning.find("Ignoring unknown variable 'nope'"), std::string::npos) << warning;
+    EXPECT_NE(warning.find("line 1"), std::string::npos) << warning;      // where it happened
+    EXPECT_NE(warning.find("from <string>, line 4"), std::string::npos) << warning; // who caused it
+    // Full chain follows, same shape as an error's trace.
+    EXPECT_NE(warning.find("TRACE:"), std::string::npos) << warning;
+}
+
+// A GenerateFn runs after resolve has unwound the call stack, so this case
+// has no live frames to walk -- the entry position is captured onto the
+// CSGNode at resolve time instead (CSGNode::warnEntry). This is the case
+// that motivated the whole change: an open polyhedron() inside BOSL2 used
+// to report only "BOSL2/vnf.scad, line 1624".
+TEST(WarningTrace, GenerateTimeWarningNamesTheTopLevelCallSite) {
+    std::string warning;
+    evalSrc("module openbox() {\n"
+            "  polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+            "                     [0,0,10],[10,0,10],[10,10,10],[0,10,10]],\n"
+            "             faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3]]);\n"
+            "}\n"
+            "openbox();\n",                          // line 6: the user's own line
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+
+    EXPECT_NE(warning.find("mesh is not closed"), std::string::npos) << warning;
+    EXPECT_NE(warning.find("from <string>, line 6"), std::string::npos) << warning;
+}
+
+// A warning with nothing above it stays exactly one line. The overwhelmingly
+// common case, and the reason the "from" clause and TRACE are conditional --
+// ordinary warnings must not sprout a trace nobody needs.
+TEST(WarningTrace, TopLevelWarningStaysASingleLineWithNoTrace) {
+    std::string warning;
+    evalSrc("x = nope;\n", [&](const std::string& m) { if (warning.empty()) warning = m; });
+
+    EXPECT_NE(warning.find("Ignoring unknown variable 'nope'"), std::string::npos) << warning;
+    EXPECT_EQ(warning.find("TRACE:"), std::string::npos) << warning;
+    EXPECT_EQ(warning.find(", from "), std::string::npos) << warning;
+    EXPECT_EQ(warning.find('\n'), std::string::npos) << warning;
+}
+
+// The clause names the OUTERMOST frame, not the immediate caller: the
+// question being answered is "which line of mine started this", and the
+// intermediate frames are already in the TRACE below.
+TEST(WarningTrace, FromClauseNamesOutermostFrameNotImmediateCaller) {
+    std::string warning;
+    evalSrc("module a() { y = nope; cube(1); }\n"    // line 1: raised here
+            "module b() { a(); }\n"                   // line 2: immediate caller of a()
+            "b();\n",                                 // line 3: the top-level entry
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+
+    EXPECT_NE(warning.find("from <string>, line 3"), std::string::npos) << warning;
+    EXPECT_EQ(warning.find("from <string>, line 2"), std::string::npos) << warning;
+}