openscad-cpp-evaluator 1.44.0__tar.gz → 1.45.1__tar.gz

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/PKG-INFO

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

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -505,7 +505,7 @@ enum class Op {
     // anything compileStatementList doesn't give its own real bytecode.
     // (Assignment/ModularEcho/ModularAssert/ModularLet used to fall here
     // too; they now have their own real bytecode -- Op::StoreModuleVar/
-    // Op::Echo/Op::AssertStatement/Op::OpenLetScope+StoreLetVar -- purely
+    // Op::Echo/Op::AssertPass+AssertFail/Op::OpenLetScope+StoreLetVar -- purely
     // a throughput change, since none of these were ever the recursion-
     // depth risk this compiler targets. `#`/`%`/`!` modifiers and
     // translate/rotate/scale/mirror/multmatrix/resize/color used to fall
@@ -634,14 +634,9 @@ enum class Op {
     // the position recorded into dynPositions).
     StoreModuleVar,
 
-    // ModularEcho/ModularAssert's own statement form share Op::Echo/a
-    // dedicated AssertStatement op (below) for the "pop N already-compiled
-    // argument values" mechanics -- see those ops' own doc comments
-    // (Op::Echo, above; Op::AssertStatement, below) for why the
-    // EXPRESSION-form opcodes are directly reusable (statement-shaped
-    // already: no value pushed, straight fall-through) while assert's
-    // needs its own op (named-argument support + eager-not-lazy message
-    // evaluation, both genuinely different from AssertOp's own contract).
+    // ModularEcho/ModularAssert's own statement form share Op::Echo and
+    // Op::AssertPass/AssertFail (below) with the expression forms: both are
+    // statement-shaped already (no value pushed, straight fall-through).
 
     // Isolates ONE inline-compiled sub-expression's own `$`-writes from the
     // rest of this chunk's shared, long-lived ctx -- pushes ctx.
@@ -697,12 +692,15 @@ enum class Op {
     // the handler itself, kept for consistency/future debugging only).
     StoreLetVar,
 
-    // a = index into CompiledChunk::assertSites. Pops site.argCount values
-    // (every argument of an assert() statement or expression, pushed in
-    // source order) and hands them to Evaluator::checkAssert; a statement
-    // then runs any chained children natively (rare; not worth its own
-    // compiled path).
-    AssertStatement,
+    // assert(): the condition is compiled first, then JumpIfFalse to the
+    // failure path; the passing path never evaluates any other argument
+    // (see Evaluator::evalAssert). a = index into CompiledChunk::assertSites.
+    // AssertPass prints the site's unexpected-argument warnings and runs a
+    // statement's chained children; it is emitted only when the site has
+    // either. AssertFail pops every non-condition argument (source order)
+    // and throws via Evaluator::failAssert.
+    AssertPass,
+    AssertFail,
     // a = nativeStatements index of the AST node whose arm this is. Emitted
     // only when the Evaluator was built with coverage on (compile-time
     // flag, and chunks are per-Evaluator): Evaluator::coverHit(node), nothing
@@ -711,6 +709,17 @@ enum class Op {
     Cover,
 };
 
+// Which of an assert() call's arguments are its condition and message, and
+// whether the call has any unexpected argument to warn about -- all fixed by
+// the call's shape, so worked out once per call site (assertLayout,
+// stmt_eval.cpp). -1 = not given.
+struct AssertLayout {
+    int cond = -1;
+    int msg = -1;
+    bool warns = false;
+};
+AssertLayout assertLayout(const std::vector<std::unique_ptr<oscad::Argument>>& arguments);
+
 struct Instruction {
     Op op;
     int a = 0;
@@ -1014,10 +1023,10 @@ struct CompiledChunk {
         const oscad::ASTNode* node = nullptr;
     };
 
-    // One Op::AssertStatement site. `statement` is null for the expression
-    // form, which has no children.
+    // One Op::AssertPass/AssertFail site. `statement` is null for the
+    // expression form, which has no children.
     struct AssertSite {
-        int argCount = 0;
+        AssertLayout layout;
         const std::vector<std::unique_ptr<oscad::Argument>>* arguments = nullptr;
         const oscad::ASTNode* node = nullptr;
         const oscad::ModularAssert* statement = nullptr;

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -565,13 +565,20 @@ public:
     void warnUndefinedEscapes(const oscad::StringLiteral& lit, int count);
     // let() keeps the FIRST binding of a repeated name: OpenSCAD evaluates
     // the later right-hand side, warns with its value, and discards it.
-    // OpenSCAD's Assert::performAssert, given every argument's value in
-    // source order -- it evaluates them all, pass or fail, so a passing
-    // `assert(true, nosuch)` still warns. Warns about unexpected arguments;
-    // throws via error() when the condition is false or missing (`assert()`
-    // fails). The message prints as echo() would print it.
-    void checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const std::vector<Value>& values,
-                     const oscad::ASTNode& node);
+    // assert(), interpreted: the condition first, and only on failure the
+    // message and any other argument -- see the definition (stmt_eval.cpp)
+    // for why this deliberately diverges from OpenSCAD. `maybeCompiled`
+    // picks evalExprMaybeCompiled (statement form) over evalExpr.
+    void evalAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                    EvalContext& ctx, bool maybeCompiled);
+    // The unexpected-argument warnings, which a passing assert still prints.
+    void warnAssertArgs(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const AssertLayout& layout);
+    // A failed (or condition-less) assert, once every non-condition argument
+    // has been evaluated: warns about unexpected arguments, then throws via
+    // error(). `message` is null when none was given; it prints as echo()
+    // would print it.
+    [[noreturn]] void failAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                                 const AssertLayout& layout, const Value* message, const oscad::ASTNode& node);
     void warnDuplicateLet(const std::string& name, const Value& v, const oscad::Position* position);
     template <typename Assignments>
     static bool repeatsEarlierLetName(const Assignments& assignments, size_t i) {

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/builtins/function_builtins.cpp

@@ -1242,9 +1242,12 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
     // was 0, concat(a=[1], b=[2]) was [], rands(seed_value=) went unseeded.
     // (textmetrics/fontmetrics -- with declaredParams -- and dxf_dim/
     // dxf_cross bind by name in OpenSCAD too.)
+    // The common all-positional call goes straight through, with no
+    // reordered copy built (or destroyed) on its way.
     const bool byName = declaredParams || id == BuiltinFnId::DxfDim || id == BuiltinFnId::DxfCross;
+    if (byName || args.named.empty()) return evalBuiltinFunctionInOrder(ev, id, name, args, node);
     CallArgs ordered;
-    if (!byName && node.kind() == oscad::NodeKind::PrimaryCall && !args.named.empty()) {
+    if (node.kind() == oscad::NodeKind::PrimaryCall) {
         int k = 0, out = 0;
         for (const auto& a : static_cast<const oscad::PrimaryCall&>(node).arguments) {
             const Value* v = nullptr;
@@ -1258,8 +1261,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
             ordered.setPositional(out++, v ? *v : Value{});
         }
     }
-    const CallArgs& argsInOrder = (!byName && !args.named.empty()) ? ordered : args;
-    return evalBuiltinFunctionInOrder(ev, id, name, argsInOrder, node);
+    return evalBuiltinFunctionInOrder(ev, id, name, ordered, node);
 }
 
 Value evalBuiltinFunctionInOrder(Evaluator& ev, BuiltinFnId id, const std::string& name, const CallArgs& args,

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/builtins/roof.cpp

@@ -114,10 +114,35 @@ class RoofMesh {
         }
     }
 
+    // A vertex no triangle uses -- the far end of an unbounded Voronoi edge
+    // outside the outline can lie 10^12 away -- would stretch the bounding
+    // box Manifold sizes its tolerance by, and its cleanup would then
+    // collapse the whole roof; such vertices are left out. (Only when one
+    // lies well beyond the rest: renumbering reorders the output, and one
+    // nearer changes the tolerance by no more than a few times.)
     manifold::Manifold build() {
         mesh_.numProp = 3;
+        const size_t n = mesh_.vertProperties.size() / 3;
+        std::vector<bool> used(n, false);
         for (const auto& t : triangles_) {
-            for (int i : t) mesh_.triVerts.push_back(static_cast<uint64_t>(i));
+            for (int i : t) used[i] = true;
+        }
+        manifold::Box box;
+        for (size_t i = 0; i < n; ++i) {
+            if (used[i]) box.Union(manifold::vec3(mesh_.vertProperties[3 * i], mesh_.vertProperties[3 * i + 1], mesh_.vertProperties[3 * i + 2]));
+        }
+        std::vector<uint64_t> to(n);
+        std::vector<double> kept;
+        bool stray = false;
+        for (size_t i = 0; i < n; ++i) {
+            const manifold::vec3 p(mesh_.vertProperties[3 * i], mesh_.vertProperties[3 * i + 1], mesh_.vertProperties[3 * i + 2]);
+            stray = stray || (!used[i] && la::maxelem(la::abs(p)) > 16 * box.Scale());
+            to[i] = kept.size() / 3;
+            if (used[i]) kept.insert(kept.end(), {p.x, p.y, p.z});
+        }
+        if (stray) mesh_.vertProperties = std::move(kept);
+        for (const auto& t : triangles_) {
+            for (int i : t) mesh_.triVerts.push_back(stray ? to[i] : static_cast<uint64_t>(i));
         }
         manifold::Manifold body(mesh_);
         if (body.Status() == manifold::Manifold::Error::NoError) return body;
@@ -991,16 +1016,17 @@ void dropSpikes(std::vector<Vec2>& c) {
     }
 }
 
-// The outline of `cs` snapped to a grid of 2^30 steps across its largest
-// coordinate, with repeated and straight corners dropped. Sets `toGrid`.
-std::vector<std::vector<Vec2>> gridContours(const manifold::CrossSection& cs, double& toGrid) {
+// The outline of `cs` snapped to a grid of 2^(bits+1) steps across its
+// largest coordinate, with repeated and straight corners dropped. Sets
+// `toGrid`.
+std::vector<std::vector<Vec2>> gridContours(const manifold::CrossSection& cs, double& toGrid, int bits = 29) {
     const manifold::Polygons polys = cs.ToPolygons();
     double extent = 0;
     for (const auto& poly : polys) {
         for (Vec2 p : poly) extent = std::max({extent, std::abs(p.x), std::abs(p.y)});
     }
     if (!(extent > 0) || !std::isfinite(extent)) return {};
-    toGrid = std::ldexp(1.0, 29 - std::ilogb(extent));
+    toGrid = std::ldexp(1.0, bits - std::ilogb(extent));
 
     std::vector<std::vector<Vec2>> contours;
     for (const auto& poly : polys) {
@@ -1016,17 +1042,6 @@ std::vector<std::vector<Vec2>> gridContours(const manifold::CrossSection& cs, do
     return contours;
 }
 
-// The roof solid over `cs` (its floor at z = 0), discretizing curved parts
-// by `fa`/`fs`.
-manifold::Manifold voronoiRoof(const manifold::CrossSection& cs, double fa, double fs) {
-    double toGrid = 1;
-    std::vector<std::vector<Vec2>> contours = gridContours(cs, toGrid);
-    if (contours.empty()) return manifold::Manifold();
-    // $fa/$fs below 0.01 would ask for unbounded detail (computeRoofParams
-    // has already clamped them, warning).
-    return RoofBuilder(std::move(contours), 1 / toGrid, std::max(fa, 0.01), std::max(fs, 0.01)).build();
-}
-
 // The outline welded where it touches itself: a union can leave pieces
 // that share an edge, or a hole against the outline, as outlines a hairline
 // apart, crossing at nothing Clipper can see. Each corner within kWeld of
@@ -1062,8 +1077,11 @@ std::vector<std::vector<Vec2>> weldContours(std::vector<std::vector<Vec2>> conto
             }
         }
     }
-    // ponytail: every corner against every edge, O(n^2); a grid of edges
-    // when outlines of tens of thousands of corners matter.
+    // Each edge looks only at the corners in its x range.
+    // ponytail: still O(n^2) for an outline of long edges all spanning one
+    // x range; a grid of edges if that ever matters.
+    const auto byX = [](Vec2 p, Vec2 q) { return p.x != q.x ? p.x < q.x : p.y < q.y; };
+    std::sort(corners.begin(), corners.end(), byX);
     Clipper2Lib::Paths64 paths;
     for (const auto& c : contours) {
         Clipper2Lib::Path64 path;
@@ -1074,8 +1092,10 @@ std::vector<std::vector<Vec2>> weldContours(std::vector<std::vector<Vec2>> conto
             if (len == 0) continue;
             const Vec2 lo = la::min(a, b) - kWeld, hi = la::max(a, b) + kWeld;
             std::vector<std::pair<double, Vec2>> on;
-            for (Vec2 q : corners) {
-                if (q.x < lo.x || q.y < lo.y || q.x > hi.x || q.y > hi.y || q == a || q == b) continue;
+            for (auto it = std::lower_bound(corners.begin(), corners.end(), Vec2{lo.x, -std::numeric_limits<double>::infinity()}, byX);
+                 it != corners.end() && it->x <= hi.x; ++it) {
+                const Vec2 q = *it;
+                if (q.y < lo.y || q.y > hi.y || q == a || q == b) continue;
                 const double t = la::dot(q - a, d) / len;
                 if (t > 0 && t < len && std::abs(cross2(d, q - a)) / len <= kWeld) on.push_back({t, q});
             }
@@ -1095,6 +1115,47 @@ std::vector<std::vector<Vec2>> weldContours(std::vector<std::vector<Vec2>> conto
     return welded;
 }
 
+// Each contour rotated to start at its least corner, and the contours sorted:
+// equal for two outlines that differ only in where Clipper starts them.
+std::vector<std::vector<Vec2>> canonical(std::vector<std::vector<Vec2>> contours) {
+    const auto less = [](Vec2 a, Vec2 b) { return a.x != b.x ? a.x < b.x : a.y < b.y; };
+    for (auto& c : contours) std::rotate(c.begin(), std::min_element(c.begin(), c.end(), less), c.end());
+    std::sort(contours.begin(), contours.end(), [&](const auto& a, const auto& b) { return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), less); });
+    return contours;
+}
+
+// The roof solid over `cs` (its floor at z = 0), discretizing curved parts
+// by `fa`/`fs`.
+//
+// Boost's Voronoi builder needs segments that meet only at their ends. A
+// union's pieces sharing an edge come back as outlines a hairline apart,
+// which on the grid overlap or cross: the diagram comes out wrong, or the
+// builder never finishes, allocating without bound. So the outline is
+// welded first, as for the straight skeleton.
+//
+// Even on valid input the builder occasionally gets a near-degenerate
+// configuration wrong -- a cell left with no finite edges, where four sites
+// are all but equidistant once the outline is rounded to the grid -- and the
+// facets built from it do not close. Rounding to a coarser grid perturbs
+// the outline differently, so the roof is retried there.
+manifold::Manifold voronoiRoof(const manifold::CrossSection& cs, double fa, double fs) {
+    manifold::Manifold body;
+    for (int bits = 29; bits >= 25; --bits) {
+        double toGrid = 1;
+        std::vector<std::vector<Vec2>> contours = gridContours(cs, toGrid, bits);
+        std::vector<std::vector<Vec2>> welded = weldContours(contours);
+        // An outline welding leaves as it was keeps its own order, so its
+        // roof is the same, vertex for vertex, as without welding.
+        if (canonical(welded) != canonical(contours)) contours = std::move(welded);
+        if (contours.empty()) return manifold::Manifold();
+        // $fa/$fs below 0.01 would ask for unbounded detail
+        // (computeRoofParams has already clamped them, warning).
+        body = RoofBuilder(std::move(contours), 1 / toGrid, std::max(fa, 0.01), std::max(fs, 0.01)).build();
+        if (body.Status() == manifold::Manifold::Error::NoError && !body.IsEmpty()) break;
+    }
+    return body;
+}
+
 manifold::Manifold straightRoof(const manifold::CrossSection& cs) {
     double toGrid = 1;
     std::vector<std::vector<Vec2>> contours = weldContours(gridContours(cs, toGrid));

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/bytecode_compiler.cpp

@@ -913,17 +913,10 @@ public:
             }
 
             case NodeKind::AssertOp: {
-                // Every argument is evaluated, pass or fail, as OpenSCAD
-                // does -- see Evaluator::checkAssert.
+                // Only the condition unless it fails -- see Evaluator::evalAssert.
                 auto& n = static_cast<const oscad::AssertOp&>(node);
-                CompiledChunk::AssertSite site;
-                site.node = &n;
-                site.arguments = &n.arguments;
-                site.argCount = static_cast<int>(n.arguments.size());
-                for (const auto& arg : n.arguments) compileExpr(*argExpr(*arg), out, scope); // never tail
-                int siteIdx = static_cast<int>(chunk_.assertSites.size());
-                chunk_.assertSites.push_back(std::move(site));
-                out.push_back({Op::AssertStatement, siteIdx, 0, &n.position()});
+                compileAssert(n.arguments, n, nullptr, out,
+                              [&](const oscad::Expression& e) { compileExpr(e, out, scope); }); // never tail
                 compileExpr(*n.body, out, scope, tail);
                 return;
             }
@@ -1313,6 +1306,40 @@ public:
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
     }
 
+    // assert(), either form, mirroring Evaluator::evalAssert:
+    //     <condition> JumpIfFalse fail [AssertPass] Jump end
+    //   fail: <every other argument, source order> AssertFail
+    //   end:
+    // AssertPass only when there is something for it to do; with no
+    // condition at all, straight to the failure path.
+    template <typename CompileArg>
+    void compileAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                       const oscad::ModularAssert* statement, std::vector<Instruction>& out, CompileArg compileArg) {
+        CompiledChunk::AssertSite site;
+        site.layout = assertLayout(arguments);
+        site.node = &node;
+        site.statement = statement;
+        site.arguments = &arguments;
+        const int siteIdx = static_cast<int>(chunk_.assertSites.size());
+        chunk_.assertSites.push_back(site);
+        const int cond = site.layout.cond;
+        std::optional<size_t> jumpEnd;
+        if (cond >= 0) {
+            compileArg(*argExpr(*arguments[static_cast<size_t>(cond)]));
+            const size_t jumpFail = out.size();
+            out.push_back({Op::JumpIfFalse, 0, 0, nullptr});
+            if (site.layout.warns || (statement && !statement->children.empty()))
+                out.push_back({Op::AssertPass, siteIdx, 0, &node.position()});
+            jumpEnd = out.size();
+            out.push_back({Op::Jump, 0, 0, nullptr});
+            out[jumpFail].a = static_cast<int>(out.size());
+        }
+        for (size_t i = 0; i < arguments.size(); ++i)
+            if (static_cast<int>(i) != cond) compileArg(*argExpr(*arguments[i]));
+        out.push_back({Op::AssertFail, siteIdx, 0, &node.position()});
+        if (jumpEnd) out[*jumpEnd].a = static_cast<int>(out.size());
+    }
+
     // Shared by ModularCall's Transform/Color-kind branch and the 3 real
     // modifier cases (ModularModifierHighlight/Background/ShowOnly),
     // below -- emits one Op::PushBuiltinWrap/PopBuiltinWrap bracket around
@@ -1544,7 +1571,7 @@ public:
                 return;
             // Assignment/ModularEcho/ModularAssert: real bytecode instead
             // of Op::NativeStatement -- a throughput improvement (see
-            // CheckDebugStatement/StoreModuleVar/AssertStatement's own doc
+            // CheckDebugStatement/StoreModuleVar/AssertPass+AssertFail's own doc
             // comments, bytecode.hpp), NOT a recursion-safety one (these
             // were never the risk Stage 2 targeted -- see NativeStatement's
             // own doc comment). Assignment specifically closes a real
@@ -1602,16 +1629,9 @@ public:
                 // Like AssertOp's compiled form, plus chained children.
                 auto& n = static_cast<const oscad::ModularAssert&>(stmt);
                 out.push_back({Op::CheckDebugStatement, internNativeStatement(&stmt), 0, nullptr});
-                CompiledChunk::AssertSite site;
-                site.node = &n;
-                site.statement = &n;
-                site.arguments = &n.arguments;
-                site.argCount = static_cast<int>(n.arguments.size());
                 CompileScope exprScope;
-                for (const auto& arg : n.arguments) compileIsolatedExpr(*argExpr(*arg), out, exprScope);
-                int siteIdx = static_cast<int>(chunk_.assertSites.size());
-                chunk_.assertSites.push_back(std::move(site));
-                out.push_back({Op::AssertStatement, siteIdx, 0, &n.position()});
+                compileAssert(n.arguments, n, &n, out,
+                              [&](const oscad::Expression& e) { compileIsolatedExpr(e, out, exprScope); });
                 return;
             }
             case NodeKind::ModularLet: {

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/bytecode_vm.cpp

@@ -1105,7 +1105,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ev.emitEcho(pairs);
                     // The STATEMENT form can carry children and the
                     // reference renders them; same tail as
-                    // Op::AssertStatement below. Null node = the expression
+                    // Op::AssertPass below. Null node = the expression
                     // form (`echo(...) 1+1`), which has none.
                     if (site.node && !site.node->children.empty())
                         ev.evalChildren(site.node->children, ctx);
@@ -1567,14 +1567,9 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
-                case Op::AssertStatement: {
+                case Op::AssertPass: {
                     const CompiledChunk::AssertSite& site = f.chunk->assertSites[static_cast<size_t>(ins.a)];
-                    std::vector<Value> args(static_cast<size_t>(site.argCount));
-                    for (int i = site.argCount - 1; i >= 0; --i) {
-                        args[static_cast<size_t>(i)] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
-                    ev.checkAssert(*site.arguments, args, *site.node);
+                    ev.warnAssertArgs(*site.arguments, site.layout);
                     // Rare (assert(...) translate(...) children();-shaped) --
                     // not worth its own compiled path; evalChildren already
                     // tries ITS OWN compiled fast path internally regardless.
@@ -1583,6 +1578,19 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
+                case Op::AssertFail: {
+                    // Every argument but the condition is on the stack, in
+                    // source order; only the message's value is wanted.
+                    const CompiledChunk::AssertSite& site = f.chunk->assertSites[static_cast<size_t>(ins.a)];
+                    const AssertLayout& layout = site.layout;
+                    Value message;
+                    for (int i = static_cast<int>(site.arguments->size()) - 1; i >= 0; --i) {
+                        if (i == layout.cond) continue;
+                        if (i == layout.msg) message = std::move(f.stack.back());
+                        f.stack.pop_back();
+                    }
+                    ev.failAssert(*site.arguments, layout, layout.msg >= 0 ? &message : nullptr, *site.node);
+                }
                 case Op::NativeCondJumpIfFalse: {
                     const oscad::Expression* cond = f.chunk->nativeExprs[static_cast<size_t>(ins.a)];
                     const bool truthyVal = truthy(ev.evalExprMaybeCompiled(*cond, ctx));

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/expr_eval.cpp

@@ -492,9 +492,7 @@ Value Evaluator::evalProfileTimeExpr(const oscad::ProfileTimeOp& node, EvalConte
 
 Value Evaluator::evalAssertExpr(const oscad::AssertOp& node, EvalContext& ctx) {
     checkDebug(node, ctx); // _expr_assert, before the condition is evaluated
-    std::vector<Value> values;
-    for (const auto& arg : node.arguments) values.push_back(evalExpr(*argExpr(*arg), ctx));
-    checkAssert(node.arguments, values, node);
+    evalAssert(node.arguments, node, ctx, /*maybeCompiled=*/false);
     return evalExpr(*node.body, ctx);
 }
 

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/stmt_eval.cpp

@@ -74,41 +74,79 @@ void Evaluator::doEcho(const std::vector<std::unique_ptr<oscad::Argument>>& argu
     emitEcho(pairs);
 }
 
-void Evaluator::checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
-                            const std::vector<Value>& values, const oscad::ASTNode& node) {
-    static const std::vector<std::string> kParams{"condition", "message"};
-    warnUnexpectedArgs(*this, kParams, arguments);
+namespace {
+const std::vector<std::string> kAssertParams{"condition", "message"};
+}
+
+AssertLayout assertLayout(const std::vector<std::unique_ptr<oscad::Argument>>& arguments) {
     // A named argument wins; positional 0/1 fill whichever is left.
-    std::optional<size_t> cond, msg;
+    AssertLayout layout;
     for (size_t i = 0; i < arguments.size(); ++i) {
         if (arguments[i]->kind() != oscad::NodeKind::NamedArgument) continue;
         const std::string& name = static_cast<const oscad::NamedArgument&>(*arguments[i]).name->name;
-        if (name == "condition" && !cond) cond = i;
-        else if (name == "message" && !msg) msg = i;
+        if (name == "condition" && layout.cond < 0) layout.cond = static_cast<int>(i);
+        else if (name == "message" && layout.msg < 0) layout.msg = static_cast<int>(i);
+        else if (name != "condition" && name != "message" && !isConfigVariable(name)) layout.warns = true;
     }
-    size_t positional = 0;
+    int positional = 0;
     for (size_t i = 0; i < arguments.size(); ++i) {
         if (arguments[i]->kind() == oscad::NodeKind::NamedArgument) continue;
-        if (positional == 0 && !cond) cond = i;
-        else if (positional == 1 && !msg) msg = i;
-        ++positional;
+        if (positional == 0 && layout.cond < 0) layout.cond = static_cast<int>(i);
+        else if (positional == 1 && layout.msg < 0) layout.msg = static_cast<int>(i);
+        if (++positional > static_cast<int>(kAssertParams.size())) layout.warns = true;
     }
-    if (cond && truthy(values[*cond])) return;
+    return layout;
+}
+
+void Evaluator::warnAssertArgs(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                               const AssertLayout& layout) {
+    if (layout.warns) warnUnexpectedArgs(*this, kAssertParams, arguments);
+}
+
+void Evaluator::failAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                           const AssertLayout& layout, const Value* message, const oscad::ASTNode& node) {
+    warnAssertArgs(arguments, layout);
     std::string err = "Assertion";
-    if (cond) err += " '" + formatExpression(*argExpr(*arguments[*cond])) + "'";
+    if (layout.cond >= 0) err += " '" + formatExpression(*argExpr(*arguments[static_cast<size_t>(layout.cond)])) + "'";
     err += " failed";
-    if (msg) err += ": " + fmtValue(values[*msg]);
+    if (message) err += ": " + fmtValue(*message);
     error(err, node, "assert");
 }
 
+// DELIBERATE DIVERGENCE FROM OPENSCAD: a passing assert() evaluates its
+// condition and nothing else, the way `||` skips its right operand.
+// OpenSCAD's Assert::performAssert evaluates every argument first, so there
+// a passing `assert(true, echo("e") "m")` echoes, `assert(true, nosuch)`
+// warns, and a message calling a user function runs it; here none of them
+// does. BOSL2 validates nearly every call with `assert(cond, str(...))`,
+// and building those never-shown messages was ~4% of its evaluation time.
+// A failing (or condition-less) assert evaluates every other argument, in
+// source order, after the condition, so its output is unchanged; the
+// unexpected-argument warnings depend only on the call's shape and still
+// print on every call. The compiled form (Op::AssertPass/AssertFail) does
+// the same.
+void Evaluator::evalAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                           EvalContext& ctx, bool maybeCompiled) {
+    const AssertLayout layout = assertLayout(arguments);
+    auto eval = [&](size_t i) {
+        const oscad::Expression& e = *argExpr(*arguments[i]);
+        return maybeCompiled ? evalExprMaybeCompiled(e, ctx) : evalExpr(e, ctx);
+    };
+    if (layout.cond >= 0 && truthy(eval(static_cast<size_t>(layout.cond)))) {
+        warnAssertArgs(arguments, layout);
+        return;
+    }
+    Value message;
+    for (size_t i = 0; i < arguments.size(); ++i) {
+        if (static_cast<int>(i) == layout.cond) continue;
+        Value v = eval(i);
+        if (static_cast<int>(i) == layout.msg) message = std::move(v);
+    }
+    failAssert(arguments, layout, layout.msg >= 0 ? &message : nullptr, node);
+}
+
 void Evaluator::evalAssertStatement(const oscad::ModularAssert& node, EvalContext& ctx) {
-    // The statement form supports named arguments (assert(condition=...,
-    // message=...)), unlike the expression form's raw positional indexing
-    // -- see evalAssertExpr. Mirrors _eval_statement_impl's ModularAssert
-    // branch exactly.
-    std::vector<Value> values;
-    for (const auto& arg : node.arguments) values.push_back(evalExprMaybeCompiled(*argExpr(*arg), ctx));
-    checkAssert(node.arguments, values, node);
+    evalAssert(node.arguments, node, ctx, /*maybeCompiled=*/true);
     // Assertion passed -- propagate any chained child geometry (e.g.
     // `assert(...) translate(...) children();`).
     if (!node.children.empty()) evalChildren(node.children, ctx);

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.1}/src/user_calls.cpp

@@ -532,9 +532,7 @@ std::variant<Value, Evaluator::TailStep, Evaluator::NotTailStep> Evaluator::simp
             // Mirrors evalAssertExpr.
             auto& n = static_cast<const oscad::AssertOp&>(node);
             checkDebug(n, ctx);
-            std::vector<Value> values;
-            for (const auto& arg : n.arguments) values.push_back(evalExpr(*argExpr(*arg), ctx));
-            checkAssert(n.arguments, values, n);
+            evalAssert(n.arguments, n, ctx, /*maybeCompiled=*/false);
             TailStep step;
             step.nextExpr = n.body.get();
             step.ctx = ctx;