openscad-cpp-evaluator 1.23.1__tar.gz → 1.24.0__tar.gz

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -398,6 +398,14 @@ public:
     // than anything reentrancy-aware, since generateTreeImpl recurses
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
+    // Non-null while generateTreeImpl() is generating a subtree whose result
+    // it intends to cache: warn() appends each formatted line here as well as
+    // emitting it, so the entry can replay them on a later hit. Saved and
+    // restored around each node rather than left set, and the inner vector is
+    // merged into the outer one on the way out, so a parent's entry carries
+    // everything its whole subtree said -- which is what a parent-level hit
+    // has to reproduce, since it skips all of it. See ManifoldCache.
+    std::vector<std::string>* warnCapture = nullptr;
     // The same republish for CSGNode::callChain, read by tagGenerated to
     // fill idToCallChain.
     uint32_t generateCallChain = kNoCallChain;
@@ -530,6 +538,10 @@ public:
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
+    // Hands one already-formatted warning line to echoFn_, recording it in
+    // warnCapture first when one is active. Every warning path goes through
+    // here, including a ManifoldCache hit replaying a cached line.
+    void emitWarning(const std::string& formatted);
 
     // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
     // before its GenerateFn runs -- see csg_generate.cpp.

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/include/openscad_cpp_evaluator/manifold_cache.hpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/csg_node.hpp"
 
 #include <mutex>
+#include <vector>
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -22,15 +23,28 @@ namespace oscadeval {
 // threading.Lock -- a host may run renders/evaluates on a background
 // thread while another operation reads/clears the same cache). Mirrors
 // the reference's ManifoldCache class.
+// What one cache entry holds. The warnings matter as much as the bodies:
+// a hit skips the whole subtree's GenerateFn, and every generate-time
+// diagnostic is raised *inside* one of those (polyhedron's "mesh is not
+// closed", import()'s failures, the dimension rules). Cached without them,
+// a second render of unchanged source silently dropped every warning the
+// first one raised, so a real defect looked intermittent and the author
+// went hunting for a phantom. A cache has to be transparent; that includes
+// what it says, not only what it draws. See BelfrySCAD issue #521.
+struct CachedSubtree {
+    std::vector<ColoredBody> bodies;
+    std::vector<std::string> warnings;  // already formatted, replayed verbatim
+};
+
 class ManifoldCache {
 public:
-    std::optional<std::vector<ColoredBody>> get(const std::string& key) const;
-    void put(std::string key, std::vector<ColoredBody> bodies);
+    std::optional<CachedSubtree> get(const std::string& key) const;
+    void put(std::string key, std::vector<ColoredBody> bodies, std::vector<std::string> warnings);
     void clear();
 
 private:
     mutable std::mutex mutex_;
-    std::unordered_map<std::string, std::vector<ColoredBody>> entries_;
+    std::unordered_map<std::string, CachedSubtree> entries_;
 };
 
 // Structural content-hash key for `node`, used by generateTree()'s

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/CMakeLists.txt

@@ -69,3 +69,37 @@ target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz
 target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )
+
+# -Wall -Wextra above is about OUR code, but two TUs pull a vendored header
+# in wholesale and inherit its warnings: 27 from Boost.Polygon's voronoi
+# headers and 9 from stb_image_write's implementation, against 5 that were
+# real. Silenced per source file, per warning.
+#
+# Deliberately NOT -isystem, which looks like the tidier fix and is a trap:
+# clang searches -isystem AFTER /usr/local/include, so a Homebrew Boost
+# 1.90 silently won over the pinned 1.86 (measured, not assumed). Keeping
+# -I keeps the fetched copy winning.
+include(CheckCXXCompilerFlag)
+foreach(_w deprecated-enum-float-conversion missing-field-initializers deprecated-declarations)
+  check_cxx_compiler_flag("-Wno-${_w}" OSCAD_HAS_WNO_${_w})
+endforeach()
+
+if(OSCAD_HAS_WNO_deprecated-enum-float-conversion)
+  # <boost/polygon/voronoi.hpp> does floating-point arithmetic on an
+  # unnamed enum, deprecated in C++20.
+  set_source_files_properties(builtins/roof.cpp PROPERTIES
+    COMPILE_OPTIONS "-Wno-deprecated-enum-float-conversion")
+endif()
+
+# zip_stored.cpp defines STB_IMAGE_WRITE_IMPLEMENTATION, so stb's C compiles
+# as ours: `= { 0 }` partial initializers, and one sprintf().
+set(_stb_quiet "")
+if(OSCAD_HAS_WNO_missing-field-initializers)
+  list(APPEND _stb_quiet "-Wno-missing-field-initializers")
+endif()
+if(OSCAD_HAS_WNO_deprecated-declarations)
+  list(APPEND _stb_quiet "-Wno-deprecated-declarations")
+endif()
+if(_stb_quiet)
+  set_source_files_properties(zip_stored.cpp PROPERTIES COMPILE_OPTIONS "${_stb_quiet}")
+endif()

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/builtins/function_builtins.cpp

@@ -837,38 +837,6 @@ Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     });
 }
 
-// Take only scalar numbers, mapped to how many leading positional
-// arguments must each actually BE a number. Anything else there (undef, a
-// string, a list, a bool, an object) is a type error yielding undef, and
-// so is supplying fewer arguments than the arity -- matching the
-// reference, which rejects the call outright rather than coercing.
-//
-// This has to be checked up front rather than left to each case below:
-// toDoubleLenient() silently turns undef/string/list into 0.0, which
-// would make `cos(misspelled_var)` quietly 1 instead of undef, and a
-// typo'd variable then produces plausible-looking geometry instead of an
-// obvious failure. Arity is deliberately a floor, not an exact match --
-// the reference also rejects EXTRA arguments, but tightening that too
-// risks breaking working library code for no correctness gain here.
-const std::unordered_map<std::string, size_t>& scalarNumericArity() {
-    static const std::unordered_map<std::string, size_t> arity = {
-        {"abs", 1}, {"sign", 1}, {"ceil", 1}, {"floor", 1}, {"round", 1}, {"sqrt", 1},
-        {"ln", 1}, {"log", 1}, {"exp", 1}, {"sin", 1}, {"cos", 1}, {"tan", 1},
-        {"asin", 1}, {"acos", 1}, {"atan", 1}, {"atan2", 2}, {"pow", 2}, {"rands", 3},
-    };
-    return arity;
-}
-
-// Numeric functions that legitimately take a LIST argument, so the
-// all-arguments-must-be-numbers rule above can't apply -- each validates
-// its own operands, and only needs the bool case caught here (Value's
-// bool and double are distinct alternatives, but the reference rejects
-// `max(true, 1)` as a type error rather than treating true as 1).
-const std::unordered_set<std::string>& numericOnlyNames() {
-    static const std::unordered_set<std::string> names = {"max", "min", "norm", "cross"};
-    return names;
-}
-
 } // namespace
 
 bool isBuiltinFunctionName(const std::string& name) {

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/builtins/primitives_3d.cpp

@@ -11,7 +11,10 @@
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <optional>
 #include <set>
+#include <string>
+#include <utility>
 
 namespace oscadeval {
 
@@ -42,8 +45,18 @@ bool isDrawableFailure(const manifold::Manifold& body, const M& mesh) {
                         [](float v) { return std::isfinite(v); });
 }
 
+struct BoundaryEdges {
+    size_t count = 0;
+    // Vertex indices of one representative open edge, or nullopt when the
+    // mesh is closed. A count alone is enough on a hand-written face list,
+    // where you can just read it; it is useless on generated geometry --
+    // three bad edges in a few thousand triangles cannot be found by eye,
+    // which is what happened in BelfrySCAD #521 / issue #187.
+    std::optional<std::pair<uint32_t, uint32_t>> first;
+};
+
 template <typename M>
-size_t countBoundaryEdges(const M& mesh) {
+BoundaryEdges findBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
         const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
@@ -54,11 +67,34 @@ size_t countBoundaryEdges(const M& mesh) {
             ++uses[{std::min(a, b), std::max(a, b)}];
         }
     }
-    size_t open = 0;
+    BoundaryEdges out;
+    // std::map iterates in vertex-index order, which is arbitrary from the
+    // author's point of view but DETERMINISTIC: the same mesh names the same
+    // edge on every run. That matters more than which edge gets picked --
+    // an identifier that moves between renders is worse than no identifier.
+    // A cluster of open edges is nearly always one hole, so the first is
+    // usually representative of the rest.
     for (const auto& [edge, count] : uses) {
-        if (count % 2 != 0) ++open;
+        if (count % 2 == 0) continue;
+        ++out.count;
+        if (!out.first) out.first = edge;
     }
-    return open;
+    return out;
+}
+
+// "[1, 2.5, 0] - [1, 3, 0]" for one edge, using the same number formatting
+// echo() uses, so a coordinate can be pasted straight back into a script.
+template <typename M>
+std::string describeEdge(const M& mesh, std::pair<uint32_t, uint32_t> edge) {
+    const size_t stride = mesh.numProp > 0 ? static_cast<size_t>(mesh.numProp) : 3;
+    auto point = [&](uint32_t v) {
+        const size_t base = static_cast<size_t>(v) * stride;
+        if (base + 2 >= mesh.vertProperties.size()) return std::string("?");
+        return "[" + formatNumber(static_cast<double>(mesh.vertProperties[base])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 1])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 2])) + "]";
+    };
+    return point(edge.first) + " - " + point(edge.second);
 }
 } // namespace
 
@@ -810,8 +846,15 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
         if (!ev.insideHull) {
-            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                        " boundary edge(s); drawing it as a surface. hull() can still "
+            const BoundaryEdges open = findBoundaryEdges(mesh);
+            // Name one of them. Where the hole IS is the only part of this
+            // message an author can act on; the count alone just says to go
+            // looking, across the whole mesh.
+            const std::string where =
+                open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string();
+            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(open.count) +
+                        " boundary edge(s)" + where +
+                        "; drawing it as a surface. hull() can still "
                         "use its points, but it cannot take part in union/difference/intersection",
                     &node.position());
         }

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/builtins/topology.cpp

@@ -621,18 +621,6 @@ double bandDistance(double v, double lo, double hi, bool invert) {
     return invert ? -d : d;
 }
 
-std::optional<std::array<double, 3>> readVec3(const Value& v) {
-    const ListPtr* l = std::get_if<ListPtr>(&v);
-    if (!l || !*l || (*l)->items.size() != 3) return std::nullopt;
-    std::array<double, 3> out{};
-    for (size_t i = 0; i < 3; ++i) {
-        const double* d = std::get_if<double>(&(*l)->items[i]);
-        if (!d || !std::isfinite(*d)) return std::nullopt;
-        out[i] = *d;
-    }
-    return out;
-}
-
 } // namespace
 
 // -- 2D: marching squares --------------------------------------------------

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/csg_generate.cpp

@@ -58,9 +58,16 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // skipped. See CSGNode::keyHasClosure.
             if (node.keyHasClosure) key.reset();
         }
-        std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
+        std::optional<CachedSubtree> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
-            node.bodies = std::move(*cached);
+            node.bodies = std::move(cached->bodies);
+            // Replay what generating this subtree said the first time. A hit
+            // runs none of it again, so without this the diagnostics simply
+            // disappear on every render after the first -- which is how a
+            // permanently-open polyhedron came to look like an intermittent
+            // one (BelfrySCAD #521). Goes through emitWarning so an enclosing
+            // capture records them too, exactly as a fresh generate would.
+            for (const std::string& w : cached->warnings) emitWarning(w);
             // Skipped entirely while measuring: restampCachedIds writes
             // idToNode/idToColor, and geometry that is about to be discarded
             // has no click-to-source identity worth recording. See
@@ -83,6 +90,23 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // inside this hull.
             const bool savedInsideHull = insideHull;
             if (node.isBuiltin && node.kind == "hull") insideHull = true;
+            // Collect everything this subtree warns about, so put() below can
+            // store it with the bodies. Only worth doing when the result is
+            // actually cacheable -- an uncacheable node (rands() taint, a
+            // closure in the key) regenerates every time and warns every time
+            // by itself.
+            std::vector<std::string> subtreeWarnings;
+            // RAII, unlike the plain save/restore insideHull and
+            // generateWarnEntry use above: those restore a value, this one
+            // restores a POINTER to a stack vector. An EvalError thrown out
+            // of a GenerateFn would otherwise leave warnCapture dangling at
+            // a destroyed vector for any warning raised afterwards.
+            struct CaptureGuard {
+                Evaluator& ev;
+                std::vector<std::string>* saved;
+                ~CaptureGuard() { ev.warnCapture = saved; }
+            } captureGuard{*this, warnCapture};
+            if (key) warnCapture = &subtreeWarnings;
             generateTreeImpl(childPtrs);
             insideHull = savedInsideHull;
 
@@ -111,12 +135,18 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 node.bodies = flattenCsgTree(node.children);
             }
             if (key) {
+                warnCapture = captureGuard.saved;
+                // Merge inward-out: an ancestor still capturing must end up
+                // holding this subtree's lines too, since a hit at ITS level
+                // skips everything down here.
+                if (warnCapture != nullptr)
+                    warnCapture->insert(warnCapture->end(), subtreeWarnings.begin(), subtreeWarnings.end());
                 // The geometry itself is still cached while measuring --
                 // cacheKey is content-addressed, so the real render can
                 // legitimately reuse it. Only the PRODUCER attribution is
                 // suppressed: a node that gets discarded must never be
                 // recorded as the origin of geometry a later render draws.
-                manifoldCache_->put(*key, node.bodies);
+                manifoldCache_->put(*key, node.bodies, std::move(subtreeWarnings));
                 if (!measuring_) cacheProducer_[*key] = node.node;
             }
                 // The children's bodies have been consumed (by the dispatch above,

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/expr_eval.cpp

@@ -19,7 +19,6 @@ namespace oscadeval {
 namespace {
 
 bool isNumber(const Value& v) { return std::holds_alternative<double>(v); }
-bool isBoolValue(const Value& v) { return std::holds_alternative<bool>(v); }
 
 // Converts a Value to the truncated-to-int64 form real OpenSCAD's own
 // Value::toInt64() uses for bitwise operations (Value.cc, PR #4833:
@@ -102,10 +101,15 @@ void Evaluator::warn(const std::string& message, const oscad::Position* position
         if (!sameSpot) {
             out += ", from " + generateWarnEntry->origin + ", line " + std::to_string(generateWarnEntry->line);
         }
-        echoFn_(out);
+        emitWarning(out);
         return;
     }
-    echoFn_(formatWarning(message, position, callStack_));
+    emitWarning(formatWarning(message, position, callStack_));
+}
+
+void Evaluator::emitWarning(const std::string& formatted) {
+    if (warnCapture != nullptr) warnCapture->push_back(formatted);
+    if (echoFn_) echoFn_(formatted);
 }
 
 const oscad::Identifier* Evaluator::undefProbeTarget(const oscad::PrimaryCall& call) {

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/manifold_cache.cpp

@@ -7,16 +7,16 @@
 
 namespace oscadeval {
 
-std::optional<std::vector<ColoredBody>> ManifoldCache::get(const std::string& key) const {
+std::optional<CachedSubtree> ManifoldCache::get(const std::string& key) const {
     std::lock_guard<std::mutex> lock(mutex_);
     auto it = entries_.find(key);
     if (it == entries_.end()) return std::nullopt;
     return it->second;
 }
 
-void ManifoldCache::put(std::string key, std::vector<ColoredBody> bodies) {
+void ManifoldCache::put(std::string key, std::vector<ColoredBody> bodies, std::vector<std::string> warnings) {
     std::lock_guard<std::mutex> lock(mutex_);
-    entries_[std::move(key)] = std::move(bodies);
+    entries_[std::move(key)] = CachedSubtree{std::move(bodies), std::move(warnings)};
 }
 
 void ManifoldCache::clear() {

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/src/value.cpp

@@ -13,36 +13,6 @@ namespace oscadeval {
 
 namespace {
 
-std::optional<std::vector<double>> asFlatNumericVector(const ValueList& list) {
-    std::vector<double> out;
-    out.reserve(list.items.size());
-    for (const Value& v : list.items) {
-        const double* d = std::get_if<double>(&v);
-        if (!d) return std::nullopt;
-        out.push_back(*d);
-    }
-    return out;
-}
-
-// nullopt unless `list` is a non-ragged list of flat-numeric rows.
-std::optional<std::vector<std::vector<double>>> asNumericMatrix(const ValueList& list) {
-    std::vector<std::vector<double>> rows;
-    rows.reserve(list.items.size());
-    for (const Value& rowValue : list.items) {
-        const ListPtr* rowList = std::get_if<ListPtr>(&rowValue);
-        if (!rowList || !*rowList) return std::nullopt;
-        auto row = asFlatNumericVector(**rowList);
-        if (!row) return std::nullopt;
-        rows.push_back(std::move(*row));
-    }
-    if (rows.empty()) return rows;
-    const size_t width = rows.front().size();
-    for (const auto& row : rows) {
-        if (row.size() != width) return std::nullopt;
-    }
-    return rows;
-}
-
 Value makeList(std::vector<Value> items) {
     return Value{std::make_shared<const ValueList>(ValueList{std::move(items)})};
 }

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/tests/CMakeLists.txt

@@ -43,7 +43,10 @@ add_executable(oscad_eval_tests
   test_unexpected_args.cpp
   test_cli.cpp
 )
-target_link_libraries(oscad_eval_tests PRIVATE openscad_cpp_evaluator oscad_cli_lib GTest::gtest_main)
+# oscad_cli_lib PUBLIC-links openscad_cpp_evaluator, so naming it here too
+# put the archive on the link line twice ("ld: warning: ignoring duplicate
+# libraries").
+target_link_libraries(oscad_eval_tests PRIVATE oscad_cli_lib GTest::gtest_main)
 # stb_image_write.h, used only by this test binary to generate a PNG
 # fixture for ToRenderableBodies/surface() image-loading tests.
 target_include_directories(oscad_eval_tests PRIVATE ${stb_SOURCE_DIR})

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/tests/test_csg_tree.cpp

@@ -392,3 +392,52 @@ TEST(HullOpenMesh, ASiblingAfterAHullStillWarns) {
             [&](const std::string& m) { if (warning.empty()) warning = m; });
     EXPECT_NE(warning.find("mesh is not closed"), std::string::npos) << warning;
 }
+
+// A count alone is actionable on a hand-written face list and useless on
+// generated geometry: three bad edges in a few thousand triangles cannot be
+// found by eye. The message names one of them. Issue #187, from BelfrySCAD
+// #521, where the author searched the render, hunted for magenta backfaces
+// and opened the model in OpenSCAD without ever locating the hole.
+TEST(OpenMeshWarning, NamesACoordinateOfOneBoundaryEdge) {
+    std::string warning;
+    // The lid is missing, so the four top edges are open. Every one of them
+    // has z=10, whichever the map happens to name first.
+    evalSrc("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],[0,4,5,1],[1,5,6,2],[2,6,7,3],[3,7,4,0]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+
+    EXPECT_NE(warning.find("4 boundary edge(s)"), std::string::npos) << warning;
+    EXPECT_NE(warning.find("first at ["), std::string::npos) << warning;
+    EXPECT_NE(warning.find(" - ["), std::string::npos) << warning;
+    // Both endpoints of an open edge here lie on the missing lid.
+    // Vertices 4..7 are the missing lid's corners, so the open edges are
+    // (4,5) (5,6) (6,7) (4,7); std::map names (4,5) first.
+    EXPECT_NE(warning.find("first at [0, 0, 10] - [10, 0, 10]"), std::string::npos)
+        << "expected the lowest-indexed open edge, deterministically: " << warning;
+}
+
+// The named edge must not move between runs. An identifier that changes
+// render to render is worse than none -- it sends the author somewhere new
+// each time they look.
+TEST(OpenMeshWarning, TheNamedEdgeIsStableAcrossRuns) {
+    const char* src = "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],[0,4,5,1],[1,5,6,2],[2,6,7,3],[3,7,4,0]]);\n";
+    std::string first, second;
+    evalSrc(src, [&](const std::string& m) { if (first.empty()) first = m; });
+    evalSrc(src, [&](const std::string& m) { if (second.empty()) second = m; });
+    EXPECT_EQ(first, second);
+}
+
+// A closed mesh says nothing at all: the coordinate clause must not appear,
+// and no warning should be raised to carry it.
+TEST(OpenMeshWarning, AClosedMeshStaysSilent) {
+    std::string warning;
+    evalSrc("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],\n"
+            "                  [2,6,7,3],[3,7,4,0]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "");
+}

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.24.0}/tests/test_manifold_cache.cpp

@@ -433,3 +433,66 @@ TEST(ManifoldCache, ClearRemovesEntriesForcingRegeneration) {
     Evaluated second = evalSrcWithCache("cube(5);", cache);
     EXPECT_FALSE(second.ev.idToNode.empty()); // no longer a cache hit after clear()
 }
+
+// An open polyhedron warns every time it is drawn, not only the first time.
+// A cache hit runs no GenerateFn, so before warnings were stored in the entry
+// the second render of unchanged source went silent and a permanently-broken
+// mesh looked intermittent -- BelfrySCAD issue #521, where the author lost an
+// afternoon to it and could not find the "sometimes" in their own code.
+TEST(ManifoldCache, AHitReplaysTheWarningsGeneratingItRaised) {
+    // A cube missing one face: five quads, so the mesh has boundary edges.
+    const std::string src = R"(
+        polyhedron(
+          points=[[-1,-1,-1],[1,-1,-1],[1,1,-1],[-1,1,-1],
+                  [-1,-1, 1],[1,-1, 1],[1,1, 1],[-1,1, 1]],
+          faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3]]);
+    )";
+    auto cache = std::make_shared<ManifoldCache>();
+    auto countWarnings = [&] {
+        int n = 0;
+        evalSrcWithCache(src, cache, [&](const std::string& line) {
+            if (line.find("mesh is not closed") != std::string::npos) ++n;
+        });
+        return n;
+    };
+    EXPECT_EQ(countWarnings(), 1) << "cold cache: the generate pass runs and warns";
+    EXPECT_EQ(countWarnings(), 1) << "cache hit must replay, not swallow";
+    EXPECT_EQ(countWarnings(), 1) << "and keep replaying";
+    cache->clear();
+    EXPECT_EQ(countWarnings(), 1) << "after clear, generated afresh";
+}
+
+// The replay must survive a hit ABOVE the node that warned: a parent entry
+// skips its whole subtree, so it has to carry what the subtree said.
+TEST(ManifoldCache, AHitOnAnAncestorStillReplaysADescendantsWarning) {
+    const std::string src = R"(
+        translate([1,0,0]) polyhedron(
+          points=[[-1,-1,-1],[1,-1,-1],[1,1,-1],[-1,1,-1],
+                  [-1,-1, 1],[1,-1, 1],[1,1, 1],[-1,1, 1]],
+          faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3]]);
+    )";
+    auto cache = std::make_shared<ManifoldCache>();
+    auto countWarnings = [&] {
+        int n = 0;
+        evalSrcWithCache(src, cache, [&](const std::string& line) {
+            if (line.find("mesh is not closed") != std::string::npos) ++n;
+        });
+        return n;
+    };
+    EXPECT_EQ(countWarnings(), 1);
+    EXPECT_EQ(countWarnings(), 1) << "the translate() hit must replay its child's warning";
+}
+
+// A clean script stays clean: replay must not invent warnings, and a hit on
+// a node that said nothing must say nothing.
+TEST(ManifoldCache, AHitOnAQuietSubtreeStaysQuiet) {
+    auto cache = std::make_shared<ManifoldCache>();
+    auto countLines = [&] {
+        int n = 0;
+        evalSrcWithCache("difference() { cube(10, center=true); sphere(6); }", cache,
+                         [&](const std::string&) { ++n; });
+        return n;
+    };
+    EXPECT_EQ(countLines(), 0);
+    EXPECT_EQ(countLines(), 0);
+}