openscad-cpp-evaluator 1.49.2__tar.gz → 1.49.4__tar.gz

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.2
+Version: 1.49.4
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openscad_cpp_evaluator/function_builtins.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
@@ -756,6 +757,9 @@ struct CompiledChunk {
     // with how many: the Evaluator warns for them once, when the chunk is
     // compiled (it has the warning channel; the compiler does not).
     std::vector<std::pair<const oscad::StringLiteral*, int>> undefinedEscapeLiterals;
+    // Reassignments merged in the statement lists compiled into this chunk
+    // (see mergeReassignments), warned about the same way.
+    std::vector<Reassignment> reassignments;
     struct Param {
         std::string name;
         int slot = 0; // unused when isDyn is true -- $-params are never slot-addressed

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -592,8 +592,11 @@ public:
         return false;
     }
     std::unordered_set<const oscad::StringLiteral*> undefinedEscapesWarned_;
+    // Warnings a chunk's compile found, given once it is built: undefined
+    // string escapes, and reassignments its statement lists merged.
     void warnUndefinedEscapes(const CompiledChunk& chunk) {
         for (const auto& [lit, n] : chunk.undefinedEscapeLiterals) warnUndefinedEscapes(*lit, n);
+        for (const Reassignment& r : chunk.reassignments) warnReassignment(r);
     }
     // Hands one already-formatted warning line to echoFn_, recording it in
     // warnCapture first when one is active. Every warning path goes through
@@ -1393,6 +1396,19 @@ private:
     };
     std::unordered_map<std::pair<const oscad::ASTNode*, size_t>, std::optional<CompiledChunk>, ChildrenListKeyHash>
         childrenListChunkCache_;
+    // A statement list with its reassignments merged (see
+    // mergedStatementList), or nullopt when it has none -- the common
+    // case, which then costs one lookup. Same key, same clearing, same
+    // dangling-pointer reasoning as childrenListChunkCache_ above.
+    std::unordered_map<std::pair<const oscad::ASTNode*, size_t>, std::optional<std::vector<const oscad::ASTNode*>>,
+                       ChildrenListKeyHash>
+        mergedListCache_;
+    // "origin:line:name" of each reassignment already warned about, so a
+    // cleared mergedListCache_ never warns twice. Strings, not node
+    // pointers: these outlive the ASTs the cache is cleared for.
+    std::unordered_set<std::string> warnedReassignments_;
+    const std::vector<const oscad::ASTNode*>& mergedStatementList(const std::vector<const oscad::ASTNode*>& children);
+    void warnReassignment(const Reassignment& r);
 
     // See stmtExprChunkCache_'s own doc comment, immediately above, for why
     // this exists. Not a reentrancy guard (resolveTreeImpl is never called

openscad_cpp_evaluator-1.49.4/include/openscad_cpp_evaluator/reassign.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "openscad_cpp_parser/ast/expression.hpp"
+#include "openscad_cpp_parser/position.hpp"
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace oscadeval {
+
+// One name assigned again in the same statement list.
+struct Reassignment {
+    std::string name;
+    const oscad::Position* first;   // where the variable is evaluated
+    const oscad::Position* here;    // the assignment whose value it takes
+};
+
+// OpenSCAD's handle_assignment (parser.y): a name assigned twice in one
+// statement list is ONE assignment, made where it was FIRST assigned but
+// with the LAST expression. `x = 1; y = x * 10; x = 2;` gives y = 20.
+// Running them in order gave 10 -- and with include<> spliced into the top
+// level, that broke the usual way of configuring a library (include it,
+// then override its defaults) for every value the library derives from one
+// (BelfrySCAD #809).
+//
+// Returns the merged list -- the last assignment's node in the first one's
+// place, later slots dropped -- or nullopt when nothing repeats. ASTs are
+// shared and never modified; only this list of pointers changes. Each merge
+// is appended to `found` for the caller to warn about.
+inline std::optional<std::vector<const oscad::ASTNode*>> mergeReassignments(
+    const std::vector<const oscad::ASTNode*>& stmts, std::vector<Reassignment>* found = nullptr) {
+    if (stmts.size() < 2) return std::nullopt;
+    std::vector<const oscad::ASTNode*> out;
+    out.reserve(stmts.size());
+    std::unordered_map<std::string, std::pair<size_t, const oscad::Position*>> seen;
+    bool merged = false;
+    for (const oscad::ASTNode* node : stmts) {
+        if (node->kind() != oscad::NodeKind::Assignment) {
+            out.push_back(node);
+            continue;
+        }
+        const auto& a = static_cast<const oscad::Assignment&>(*node);
+        const std::string& name = a.name->name;
+        auto it = seen.find(name);
+        if (it == seen.end()) {
+            seen.emplace(name, std::make_pair(out.size(), &a.position()));
+            out.push_back(node);
+            continue;
+        }
+        if (found) found->push_back({name, it->second.second, &a.position()});
+        out[it->second.first] = node;
+        merged = true;
+    }
+    if (!merged) return std::nullopt;
+    return out;
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/src/bytecode_compiler.cpp

@@ -1283,7 +1283,11 @@ public:
     // necessarily one this Compiler's own declaration owns) -- see
     // tryCompileChildrenList's own doc comment, below, for the entry point
     // that needs this shape directly.
-    void compileStatementList(const std::vector<const oscad::ASTNode*>& children, std::vector<Instruction>& out) {
+    void compileStatementList(const std::vector<const oscad::ASTNode*>& childrenIn, std::vector<Instruction>& out) {
+        // Reassignments merged first, as Evaluator::evalChildren does for the
+        // interpreted path: a list compiled inline here never reaches it.
+        const auto merged = mergeReassignments(childrenIn, &chunk_.reassignments);
+        const std::vector<const oscad::ASTNode*>& children = merged ? *merged : childrenIn;
         std::vector<const oscad::ASTNode*> assignments;
         std::vector<const oscad::ASTNode*> others;
         for (const oscad::ASTNode* c : children) {

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/src/csg_resolve.cpp

@@ -247,6 +247,7 @@ std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTreeImpl(const NodeList&
     stmtExprChunkCache_.clear();
     assignBlockChunkCache_.clear();
     childrenListChunkCache_.clear();
+    mergedListCache_.clear();
     ResolvePassGuard resolvePassGuard(inResolvePass_);
     evalChildren(nodes, ctx);
     std::vector<std::unique_ptr<CSGNode>> tree = std::move(treeStack_.back());

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/src/eval_use.cpp

@@ -1,7 +1,12 @@
 #include "openscad_cpp_evaluator/eval_use.hpp"
 
+#include "openscad_cpp_evaluator/eval_error.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 #include "openscad_cpp_parser/ast/declarations.hpp"
+#include "openscad_cpp_parser/ast/expression.hpp"
 
+#include <filesystem>
+#include <unordered_map>
 #include <utility>
 
 namespace oscadeval {
@@ -19,6 +24,55 @@ ResolvedUseScopes resolveUseScopes(const std::vector<std::unique_ptr<oscad::ASTN
 
 namespace {
 
+namespace fs = std::filesystem;
+
+std::string normalPath(const std::string& p) {
+    std::error_code ec;
+    fs::path abs = fs::absolute(fs::path(p), ec);
+    return (ec ? fs::path(p) : abs).lexically_normal().generic_string();
+}
+
+// Each file's top-level list, merged before any scope is built (see
+// mergeReassignments, reassign.hpp), so the interpreter, the compiled VM
+// and the scope tables all see one assignment per name. This is where an
+// include<>'d library's defaults meet the main file's overrides.
+//
+// Warnings follow parser.y's rules exactly. The deliberate silence is the
+// main file overriding an included file's variable: that is configuration,
+// not a mistake. Two different included files overriding each other are
+// silent too.
+std::vector<const oscad::ASTNode*> mergeTopLevel(const std::vector<const oscad::ASTNode*>& nodes,
+                                                 const std::string& mainFile,
+                                                 const std::function<void(const std::string&)>& logFn) {
+    std::vector<Reassignment> found;
+    auto merged = mergeReassignments(nodes, &found);
+    if (!merged) return nodes;
+    const std::string main = normalPath(mainFile);
+    for (const Reassignment& r : found) {
+        const std::string prevFile = normalPath(r.first->origin);
+        const std::string currFile = normalPath(r.here->origin);
+        std::string where;   // the file named in the message, if not the main one
+        bool warnIt = false;
+        if (prevFile == main && currFile == main) {
+            warnIt = true;
+        } else if (prevFile == currFile) {
+            warnIt = r.first->line != r.here->line;   // equal: one file included twice
+            where = prevFile;
+        } else if (prevFile == main) {
+            warnIt = true;   // the main file's value overwritten by an include
+            where = prevFile;
+        }
+        if (!warnIt || !logFn) continue;
+        std::string msg = r.name + " was assigned on line " + std::to_string(r.first->line);
+        if (!where.empty()) {
+            const fs::path rel = fs::path(where).lexically_relative(fs::path(main).parent_path());
+            msg += " of " + (rel.empty() ? where : rel.generic_string());
+        }
+        logFn(formatWarning(msg + " but was overwritten", r.here, {}));
+    }
+    return *merged;
+}
+
 // The recursion. `table` is threaded through every level rather than each
 // level building its own: `use <file>` gives each used file its own root
 // Scope, but one evaluation reads all of them back, so every node's scope
@@ -26,11 +80,13 @@ namespace {
 // could not see anything a nested resolution recorded -- every node of a
 // used file read back as having no scope, and `use` silently resolved to
 // undef. BelfrySCAD's own suite caught that; this repo's did not.
-ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>& ownNodes,
+ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>& ownNodesIn,
                                         const std::string& currentFile,
+                                        const std::string& mainFile,
                                         const std::function<void(const std::string&)>& logFn,
                                         oscad::ScopeTable& table) {
     ResolvedUseScopes result;
+    const std::vector<const oscad::ASTNode*> ownNodes = mergeTopLevel(ownNodesIn, mainFile, logFn);
 
     std::vector<const oscad::ASTNode*> injected;
     // Declarations pulled in from one used file, paired with that file's
@@ -70,7 +126,7 @@ ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>&
         std::vector<const oscad::ASTNode*> libBorrowed;
         libBorrowed.reserve(libAst.size());
         for (const auto& n : libAst) libBorrowed.push_back(n.get());
-        ResolvedUseScopes nested = resolveUseScopesInto(libBorrowed, lib.resolvedPath, logFn, table);
+        ResolvedUseScopes nested = resolveUseScopesInto(libBorrowed, lib.resolvedPath, mainFile, logFn, table);
 
         std::vector<const oscad::ASTNode*> libInjected;
         for (const oscad::ASTNode* n : nested.ownNodesFiltered) {
@@ -137,7 +193,7 @@ ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& own
     // One table for the whole resolution, handed to the root scope at the
     // end so it lives exactly as long as the scopes it points into.
     auto table = std::make_unique<oscad::ScopeTable>();
-    ResolvedUseScopes result = resolveUseScopesInto(ownNodes, currentFile, logFn, *table);
+    ResolvedUseScopes result = resolveUseScopesInto(ownNodes, currentFile, currentFile, logFn, *table);
     if (result.rootScope) result.rootScope->adoptTable(std::move(table));
     return result;
 }

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/src/stmt_eval.cpp

@@ -1,5 +1,6 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/format_closure.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 
@@ -325,7 +326,37 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
     }
 }
 
-void Evaluator::evalChildren(const std::vector<const oscad::ASTNode*>& children, EvalContext& ctx) {
+// A statement list inside a module body or a block, with its reassignments
+// merged (mergeReassignments, reassign.hpp). The top level of each file is
+// merged once before scopes are built (eval_use.cpp); these lists live in
+// shared, immutable ASTs, so they are merged here, as they are run, and
+// cached. The compiler merges the lists it compiles inline itself
+// (compileStatementList), so both paths agree.
+const std::vector<const oscad::ASTNode*>& Evaluator::mergedStatementList(
+    const std::vector<const oscad::ASTNode*>& children) {
+    if (children.size() < 2) return children;
+    const auto key = std::make_pair(children.front(), children.size());
+    auto it = mergedListCache_.find(key);
+    if (it == mergedListCache_.end()) {
+        std::vector<Reassignment> found;
+        it = mergedListCache_.emplace(key, mergeReassignments(children, &found)).first;
+        for (const Reassignment& r : found) warnReassignment(r);
+    }
+    return it->second ? *it->second : children;
+}
+
+void Evaluator::warnReassignment(const Reassignment& r) {
+    // A body is one file, so parser.y's rule reduces to: always warn (its
+    // same-line exemption is for one file included twice, which only the
+    // top level can see). Once per assignment however often its list is
+    // run or recompiled.
+    const std::string tag = r.here->origin + ":" + std::to_string(r.here->start_offset) + ":" + r.name;
+    if (!warnedReassignments_.insert(tag).second) return;
+    warn(r.name + " was assigned on line " + std::to_string(r.first->line) + " but was overwritten", r.here);
+}
+
+void Evaluator::evalChildren(const std::vector<const oscad::ASTNode*>& childrenIn, EvalContext& ctx) {
+    const std::vector<const oscad::ASTNode*>& children = mergedStatementList(childrenIn);
     // Whole-LIST compile first (see tryRunCompiledChildren's own doc
     // comment, evaluator.hpp) -- tries the FULL `children` as one chunk
     // before falling back to assignments-then-others below. This is what

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/src/user_calls.cpp

@@ -1043,9 +1043,12 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
     // subsequent body-index lookup, so the Nth statement is evaluated
     // directly instead.
     std::vector<const oscad::ASTNode*> geoNodes;
+    std::vector<const oscad::ASTNode*> assignments;
     for (const oscad::ASTNode* c : *ctx.childrenNodes) {
-        if (c->kind() != oscad::NodeKind::Assignment && c->kind() != oscad::NodeKind::ModuleDeclaration &&
-            c->kind() != oscad::NodeKind::FunctionDeclaration) {
+        if (c->kind() == oscad::NodeKind::Assignment) {
+            assignments.push_back(c);
+        } else if (c->kind() != oscad::NodeKind::ModuleDeclaration &&
+                   c->kind() != oscad::NodeKind::FunctionDeclaration) {
             geoNodes.push_back(c);
         }
     }
@@ -1112,6 +1115,14 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
         pickedIndices.push_back(static_cast<size_t>(idx));
     }
     if (picked.empty()) return std::nullopt;
+    // The picked statement runs in its block's scope, so the block's
+    // assignments must be in it: `m() { n = 2; for (i=[0:n]) ...; }` with
+    // `children(0)` in m() read n as unknown (#815, BOSL2's attachable()).
+    // evalChildren runs them into evalCtx's let_, which the picked
+    // statements' scopes share (withScope).
+    // ponytail: a children(i, separate=true) expansion prepares twice, so a
+    // side effect in one of these assignments (echo, rands) runs twice there.
+    if (!assignments.empty()) evalChildren(assignments, evalCtx);
     return ChildrenForward{std::move(evalCtx), std::move(picked), separate, std::move(pickedIndices)};
 }
 

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/tests/test_scoping.cpp

@@ -195,3 +195,35 @@ TEST(SpecialVariables, PreviewIsAlwaysFalse) {
     ASSERT_EQ(msgs.size(), 1u) << (msgs.empty() ? "" : msgs[0]);
     EXPECT_EQ(msgs[0], "ECHO: false, true, \"r\"");
 }
+
+// OpenSCAD evaluates a reassigned variable once, at its FIRST assignment,
+// with its LAST value (parser.y's handle_assignment) -- in a module body or
+// a block as at the top level. Checked against OpenSCAD 2026.02.01.
+TEST(Scoping, ReassignedVariableTakesItsLastValueAtItsFirstPosition) {
+    std::vector<std::string> out;
+    evaluateSrc("x = 1;\ny = x * 10;\nx = 2;\necho(y = y);\n"
+                "module m() {\n  u = 1;\n  v = u * 10;\n  u = 2;\n  echo(v = v);\n}\nm();\n"
+                "if (true) { a = 1; b = a + 1; a = 5; echo(b = b); }\n",
+                [&](const std::string& m) { out.push_back(m); });
+    EXPECT_TRUE(anyContains(out, "ECHO: y = 20"));
+    EXPECT_TRUE(anyContains(out, "ECHO: v = 20"));
+    EXPECT_TRUE(anyContains(out, "ECHO: b = 6"));
+    size_t warnings = 0;
+    for (const auto& m : out) warnings += m.find("but was overwritten") != std::string::npos;
+    EXPECT_EQ(warnings, 3u) << "one per reassignment, even though m() could run again";
+}
+
+// #815: BOSL2's attachable() runs its children by index, and children(N)
+// used to skip the child block's assignments, so `last` was unknown.
+TEST(Scoping, IndexedChildrenSeeTheirBlocksAssignments) {
+    std::vector<std::string> out;
+    evaluateSrc("module one() children(0);\n"
+                "module both() { children(1); children([0:1]); }\n"
+                "one() { n = 2; for (i = [0:n]) echo(a = i); }\n"
+                "both() { k = 3; echo(b = k); echo(c = k + 1); }\n",
+                [&](const std::string& m) { out.push_back(m); });
+    EXPECT_TRUE(anyContains(out, "ECHO: a = 2"));
+    EXPECT_TRUE(anyContains(out, "ECHO: b = 3"));
+    EXPECT_TRUE(anyContains(out, "ECHO: c = 4"));
+    EXPECT_FALSE(anyContains(out, "unknown variable"));
+}

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/tests/test_use.cpp

@@ -173,3 +173,34 @@ TEST(UseStatement, MainFileGlobalReadFromFunctionIsStable) {
     EXPECT_EQ(echoed[2], "ECHO: undef");
     std::filesystem::remove(main);
 }
+
+// BelfrySCAD #809: OpenSCAD evaluates a reassigned variable at its FIRST
+// assignment with its LAST value, so a main file overriding an included
+// library's default changes everything the library derives from it -- the
+// standard way to configure a library. And it says nothing: overriding an
+// included file's variable is configuration, not a mistake. Expected values
+// and warnings checked against OpenSCAD 2026.02.01.
+TEST(IncludeReassignment, MainFileOverrideReachesValuesTheLibraryDerives) {
+    auto lib = writeFile("reassign_lib.scad", "x = 1;\ny = x * 10;\no = object(k = 5);\np = o.k;\n");
+    auto main = writeFile("reassign_main.scad", "include <" + lib.string() + ">\n"
+                                                 "x = 2;\no = object(k = 7);\necho(y = y, p = p);\n");
+    std::vector<std::string> out;
+    evalFile(main, [&](const std::string& m) { out.push_back(m); });
+    ASSERT_EQ(out.size(), 1u) << "no warnings: overriding an include is configuration";
+    EXPECT_EQ(out[0], "ECHO: y = 20, p = 7");
+    std::filesystem::remove(lib);
+    std::filesystem::remove(main);
+}
+
+TEST(IncludeReassignment, IncludeOverwritingTheMainFileWarnsNamingIt) {
+    auto lib = writeFile("reassign_lib2.scad", "a = 1;\n");
+    auto main = writeFile("reassign_main2.scad", "a = 2;\ninclude <" + lib.string() + ">\necho(a = a);\n");
+    std::vector<std::string> out;
+    evalFile(main, [&](const std::string& m) { out.push_back(m); });
+    ASSERT_EQ(out.size(), 2u);
+    EXPECT_EQ(out[0], "WARNING: a was assigned on line 1 of " + main.filename().string() +
+                          " but was overwritten in file " + lib.string() + ", line 1");
+    EXPECT_EQ(out[1], "ECHO: a = 1");
+    std::filesystem::remove(lib);
+    std::filesystem::remove(main);
+}

{openscad_cpp_evaluator-1.49.2 → openscad_cpp_evaluator-1.49.4}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.49.2"
+version = "1.49.4"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },