openscad-cpp-evaluator 0.43.0__tar.gz → 0.45.0__tar.gz

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/CLAUDE.md

@@ -441,6 +441,21 @@ handling in arithmetic, the closure-detection rule for `call_ctx` vs `child_ctx`
 verbatim port, not an independent design. Deliberate divergences are called out in code comments —
 grep for `ponytail:`.
 
+- **Feature detection** — `$_SUPPORTED_FEATURE` (just `true`; names the CAPABILITY rather than the
+  vendor, so any evaluator adding `supported_feature()` is meant to set it, and checking it first
+  solves the bootstrapping problem of calling a function you don't know exists. Written
+  `!is_undef($_SUPPORTED_FEATURE) && supported_feature(...)` the guard is **silent** in OpenSCAD --
+  `is_undef()` is the one way to read an unknown variable there without a warning, and `&&`
+  short-circuits past the unknown call; verified against the reference), `$_BELFRYSCAD` (seeded in `EvalContext::makeRoot`, `src/eval_context.cpp`, as
+  `[major, minor, patch]` from `OSCAD_EVAL_VERSION_*` compile definitions that the top-level
+  `CMakeLists.txt` parses out of `pyproject.toml`, so wheel and local builds cannot disagree and a
+  bump needs one edit) and `supported_feature("name")` (`featureLevels()` in
+  `src/builtins/function_builtins.cpp`, returning a LEVEL so a feature whose semantics change can
+  be told from its earlier self; 0 for unknown names and non-string arguments, deliberately
+  silent so probing for a future feature is safe). Both exist because OpenSCAD **silently ignores**
+  unknown arguments -- `children(separate=true)` renders the wrong shape there with no warning --
+  and both read as `undef` in OpenSCAD, so a guard written against them works in both.
+
 - `include/openscad_cpp_evaluator/value.hpp`, `src/value.cpp` — the `Value` variant (OpenSCAD's
   dynamic value type) and its free-function arithmetic/comparison helpers. See the plan's §1 for
   the type-mapping table and why there's no numpy-equivalent library.

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/CMakeLists.txt

@@ -1,5 +1,17 @@
 cmake_minimum_required(VERSION 3.24)
-project(openscad_cpp_evaluator CXX)
+
+# Read the version straight out of pyproject.toml rather than repeating it
+# here. It reaches C++ as OSCAD_EVAL_VERSION_{MAJOR,MINOR,PATCH} (see
+# src/CMakeLists.txt), which is what seeds $_BELFRYSCAD -- so a released
+# wheel and a local `cmake --build` always report the same numbers, and a
+# version bump needs one edit, not three.
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/pyproject.toml" _oscad_pyproject)
+if(NOT _oscad_pyproject MATCHES "\nversion = \"([0-9]+)\.([0-9]+)\.([0-9]+)\"")
+    message(FATAL_ERROR "could not read version = \"X.Y.Z\" from pyproject.toml")
+endif()
+set(OSCAD_EVAL_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
+
+project(openscad_cpp_evaluator VERSION ${OSCAD_EVAL_VERSION} LANGUAGES CXX)
 
 # On Apple Silicon, warn (don't fail -- a universal or intentionally-x86_64
 # build is legitimate) if the effective target architecture is x86_64 while

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -372,6 +372,13 @@ public:
     // One synthetic `children(index)` statement, owned by syntheticNodes_.
     const oscad::ASTNode* makeChildrenIndexCall(const oscad::ModularCall& origin, size_t index);
 
+    // The sole argument of `is_undef(x)` when x is a bare identifier, else
+    // nullptr. That call is a PROBE -- asking whether a name is defined must
+    // not itself complain that it isn't -- so the name is read with
+    // warnIfUndef=false. Static and syntactic so the bytecode compiler can
+    // ask at compile time and emit LoadFreeNoWarn.
+    static const oscad::Identifier* undefProbeTarget(const oscad::PrimaryCall& call);
+
     // Syntactic gate: is this statement a `children(..., separate=true)`?
     // Cheap and side-effect-free, so the bytecode compiler can ask it at
     // COMPILE time to decide which opcode to emit, long before the flag's

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/CMakeLists.txt

@@ -46,6 +46,14 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/surface.cpp
 )
 
+# Seeds $_BELFRYSCAD (eval_context.cpp). Parsed from pyproject.toml by the
+# top-level CMakeLists so there is one source of truth for the version.
+target_compile_definitions(openscad_cpp_evaluator PRIVATE
+  OSCAD_EVAL_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}
+  OSCAD_EVAL_VERSION_MINOR=${PROJECT_VERSION_MINOR}
+  OSCAD_EVAL_VERSION_PATCH=${PROJECT_VERSION_PATCH}
+)
+
 target_include_directories(openscad_cpp_evaluator PUBLIC
   $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/builtins/function_builtins.cpp

@@ -449,7 +449,7 @@ bool isBuiltinFunctionName(const std::string& name) {
         "acos", "atan", "atan2", "max", "min", "pow", "norm", "cross", "rands", "concat", "len", "str",
         "chr", "ord", "is_undef", "is_num", "is_bool", "is_string", "is_list", "is_function", "is_object",
         "search", "lookup", "has_key", "version", "version_num", "parent_module",
-        "object", "textmetrics", "fontmetrics", "dxf_dim", "dxf_cross",
+        "object", "textmetrics", "fontmetrics", "dxf_dim", "dxf_cross", "supported_feature",
     };
     return names.count(name) > 0;
 }
@@ -591,9 +591,39 @@ enum class BuiltinFnId {
     TextMetrics, FontMetrics, Abs, Sign, Ceil, Floor, Round, Sqrt, Ln, Log, Exp, Sin, Cos, Tan,
     Asin, Acos, Atan, Atan2, Max, Min, Pow, Norm, Cross, Rands, Concat, Len, Str, Chr, Ord,
     IsUndef, IsNum, IsBool, IsString, IsList, IsFunction, IsObject, Search, Lookup, HasKey,
-    Version, VersionNum, ParentModule, DxfDim, DxfCross,
+    Version, VersionNum, ParentModule, DxfDim, DxfCross, SupportedFeature,
 };
 
+// supported_feature("name") -> the level at which this build implements that
+// feature, or 0 for one it does not implement (and for a name it has never
+// heard of, which is deliberate: probing for a feature from a future release
+// is supposed to be safe).
+//
+// A LEVEL rather than a boolean so a feature whose semantics change later
+// can be told apart from its earlier self. Everything here is 1 today;
+// nothing has changed since this function existed, and a script cannot
+// observe what a build without supported_feature() did anyway.
+//
+// This is the answer to a real hazard: OpenSCAD does not reject arguments or
+// names it doesn't know -- children(separate=true) is silently ignored there
+// -- so a script using an extension runs and quietly renders something else.
+// Guarding on supported_feature() is how a script says so out loud.
+const std::unordered_map<std::string, double>& featureLevels() {
+    static const std::unordered_map<std::string, double> levels = {
+        {"render-expr", 1.0},        // render() in expression position
+        {"polyhedron-vnf", 1.0},     // polyhedron(vnf) / polyhedron(object)
+        {"separate-children", 1.0},  // children(..., separate=true)
+        {"minkowski-diff", 1.0},     // minkowski_difference()
+        {"sphere-styles", 1.0},      // sphere(style=)
+        {"export-name", 1.0},        // $export_name
+        {"simplify-op", 1.0},        // simplify()
+        {"expr-import", 1.0},        // import() in expression position
+        {"object-function", 1.0},    // object(), unconditional here
+        {"roof-op", 1.0},            // roof(), method="voronoi" only
+    };
+    return levels;
+}
+
 const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
     static const std::unordered_map<std::string, BuiltinFnId> ids = {
         {"textmetrics", BuiltinFnId::TextMetrics}, {"fontmetrics", BuiltinFnId::FontMetrics},
@@ -614,6 +644,7 @@ const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
         {"version", BuiltinFnId::Version}, {"version_num", BuiltinFnId::VersionNum},
         {"parent_module", BuiltinFnId::ParentModule},
         {"dxf_dim", BuiltinFnId::DxfDim}, {"dxf_cross", BuiltinFnId::DxfCross},
+        {"supported_feature", BuiltinFnId::SupportedFeature},
     };
     return ids;
 }
@@ -694,6 +725,7 @@ const std::unordered_map<int, BuiltinCheck>& builtinChecks() {
         // warning, so only the too-many case is an arity error.
         add(BuiltinFnId::ParentModule, {0, 1, "1", {kNum}});
         add(BuiltinFnId::HasKey, {-1, -1, nullptr, {{TObj, "object"}, {TStr, "string"}}});
+        add(BuiltinFnId::SupportedFeature, {1, 1, "1", {}});
         for (BuiltinFnId id : {BuiltinFnId::IsUndef, BuiltinFnId::IsNum, BuiltinFnId::IsBool,
                                 BuiltinFnId::IsString, BuiltinFnId::IsList, BuiltinFnId::IsFunction,
                                 BuiltinFnId::IsObject}) {
@@ -1008,6 +1040,17 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         // The OpenSCAD release we track. version_num() is that same
         // year/month/day folded as y * 10000 + m * 100 + d, exactly like the
         // reference's own builtin_version_num (builtin_functions.cc).
+        case BuiltinFnId::SupportedFeature: {
+            const Value name = getArg(args, 0, "feature", Value{});
+            const std::string* s = std::get_if<std::string>(&name);
+            // A non-string is 0 rather than an error, same as an unknown
+            // name: the whole point of this function is that asking is
+            // always safe.
+            if (!s) return Value{0.0};
+            const auto& levels = featureLevels();
+            const auto it = levels.find(*s);
+            return Value{it == levels.end() ? 0.0 : it->second};
+        }
         case BuiltinFnId::Version: return numList({2026.0, 1.0, 1.0});
         case BuiltinFnId::VersionNum: {
             // The optional vector argument the reference also accepts: with

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/bytecode_compiler.cpp

@@ -262,7 +262,10 @@ public:
     void compileIdentifierLoad(const std::string& name, const oscad::Position& pos, std::vector<Instruction>& out,
                                 CompileScope& scope, bool warnIfUndef) {
         if (!name.empty() && name[0] == '$') {
-            out.push_back({Op::LoadDyn, internName(name), 0, &pos});
+            // `b` is the warn flag -- a $-name reached through the
+            // is_undef() probe must stay quiet, same as LoadFreeNoWarn does
+            // for a plain one.
+            out.push_back({Op::LoadDyn, internName(name), warnIfUndef ? 1 : 0, &pos});
         } else if (auto slot = scope.resolve(name)) {
             out.push_back({Op::LoadLocal, *slot, 0, &pos});
         } else if (auto upvalSlot = resolveEnclosing(name)) {
@@ -620,15 +623,24 @@ public:
                     }
                 }
 
-                for (const auto& argPtr : n.arguments) {
-                    if (argPtr->kind() == NodeKind::NamedArgument) {
-                        auto& a = static_cast<const oscad::NamedArgument&>(*argPtr);
-                        compileExpr(*a.expr, out, scope); // an argument is never tail
-                        site.argNames.push_back(a.name->name);
-                    } else {
-                        auto& a = static_cast<const oscad::PositionalArgument&>(*argPtr);
-                        compileExpr(*a.expr, out, scope);
-                        site.argNames.push_back(std::nullopt);
+                // is_undef(name) probes rather than reads -- the same quiet
+                // load the interpreter uses (Evaluator::undefProbeTarget),
+                // so the two engines agree on which reads warn.
+                if (const oscad::Identifier* undefProbe = Evaluator::undefProbeTarget(n)) {
+                    compileIdentifierLoad(undefProbe->name, undefProbe->position(), out, scope,
+                                          /*warnIfUndef=*/false);
+                    site.argNames.push_back(std::nullopt);
+                } else {
+                    for (const auto& argPtr : n.arguments) {
+                        if (argPtr->kind() == NodeKind::NamedArgument) {
+                            auto& a = static_cast<const oscad::NamedArgument&>(*argPtr);
+                            compileExpr(*a.expr, out, scope); // an argument is never tail
+                            site.argNames.push_back(a.name->name);
+                        } else {
+                            auto& a = static_cast<const oscad::PositionalArgument&>(*argPtr);
+                            compileExpr(*a.expr, out, scope);
+                            site.argNames.push_back(std::nullopt);
+                        }
                     }
                 }
                 int siteIdx = static_cast<int>(chunk_.callSites.size());

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/bytecode_vm.cpp

@@ -562,6 +562,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     } else if (const Value* v = ctx.dyn->find(name)) {
                         f.stack.push_back(*v);
                     } else {
+                        // ins.b = warn flag; see compileIdentifierLoad.
+                        if (ins.b) ev.warn("Ignoring unknown variable '" + name + "'", ins.pos);
                         f.stack.push_back(Value{});
                     }
                     ++f.pc;

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/eval_context.cpp

@@ -21,6 +21,34 @@ EvalContext EvalContext::makeRoot(const oscad::Scope* rootScope) {
     // see undef, take the falsy branch by accident rather than by rule, and
     // warn about an unknown variable while doing it.
     ctx.dyn->set("$preview", Value{false});
+    // $_BELFRYSCAD -- present only here, so a script can tell which
+    // evaluator it is running under. OpenSCAD leaves it undef, which is the
+    // whole point: `if ($_BELFRYSCAD == undef)` is the portable test, and it
+    // works because an unknown $-variable is undef rather than an error.
+    //
+    // Shaped like OpenSCAD's own version() -- a [major, minor, patch] list
+    // rather than a string -- so comparisons need no string splitting.
+    // Which FEATURES exist is a separate question with a better answer:
+    // supported_feature() (function_builtins.cpp).
+    // $_SUPPORTED_FEATURE -- "supported_feature() is callable here". Set by
+    // any implementation that provides the function, not just this one, so a
+    // script can check for the FUNCTION rather than for a vendor:
+    //
+    //     if (!is_undef($_SUPPORTED_FEATURE) && supported_feature("sep..."))
+    //
+    // Solves the bootstrapping problem -- you cannot safely call
+    // supported_feature() without first knowing it exists -- and in that
+    // exact form it is SILENT in OpenSCAD: is_undef() is the one way to
+    // read an unknown variable there without a warning, and && short-
+    // circuits so the unknown function is never reached. Verified against
+    // the reference binary: no warning, correct branch.
+    // If OpenSCAD ever adds supported_feature(), it sets this too and the
+    // same script starts working there with no edit.
+    ctx.dyn->set("$_SUPPORTED_FEATURE", Value{true});
+    ctx.dyn->set("$_BELFRYSCAD",
+                 Value{std::make_shared<const ValueList>(ValueList{{Value{double{OSCAD_EVAL_VERSION_MAJOR}},
+                                                                    Value{double{OSCAD_EVAL_VERSION_MINOR}},
+                                                                    Value{double{OSCAD_EVAL_VERSION_PATCH}}}})});
     ctx.let_ = TrailView<Value>::makeRoot();
     ctx.dynPositions = TrailView<const oscad::Position*>::makeRoot();
     ctx.childrenNodes = std::make_shared<const ChildrenNodeList>();

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/expr_eval.cpp

@@ -107,6 +107,16 @@ void Evaluator::warn(const std::string& message, const oscad::Position* position
     echoFn_(formatWarning(message, position, callStack_));
 }
 
+const oscad::Identifier* Evaluator::undefProbeTarget(const oscad::PrimaryCall& call) {
+    if (call.left->kind() != oscad::NodeKind::Identifier) return nullptr;
+    if (static_cast<const oscad::Identifier&>(*call.left).name != "is_undef") return nullptr;
+    if (call.arguments.size() != 1) return nullptr;
+    if (call.arguments[0]->kind() != oscad::NodeKind::PositionalArgument) return nullptr;
+    const auto& arg = static_cast<const oscad::PositionalArgument&>(*call.arguments[0]);
+    if (arg.expr->kind() != oscad::NodeKind::Identifier) return nullptr;
+    return static_cast<const oscad::Identifier*>(arg.expr.get());
+}
+
 Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position* position, EvalContext& ctx,
                                  bool warnIfUndef) {
     if (const Value* v = ctx.let_->find(name)) return *v;
@@ -128,7 +138,19 @@ Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position*
         // $-name anyway (dynamic variables aren't scope-declarable) and
         // exists only for plain identifiers.
         const Value* v = ctx.dyn->find(name);
-        return v ? *v : Value{};
+        if (v) return *v;
+        // Warns like any other unknown name. This used to return silently
+        // for EVERY $-read, on the strength of BOSL2's get_slop() --
+        // `is_undef($slop) ? 0 : $slop` with $slop never assigned -- being
+        // silent in the reference. It is, but for two narrower reasons: the
+        // probe does not warn about its own argument (undefProbeTarget), and
+        // the else branch never runs when is_undef() is true. A plain
+        // `echo($nope)` DOES warn there, in every context checked --
+        // assignment, function body, module body, comparison. Real BOSL2
+        // (gears, threading, rounded_prism, diff/attach, path_sweep) emits
+        // none of these, because it guards its own $-reads.
+        if (warnIfUndef) warn("Ignoring unknown variable '" + name + "'", position);
+        return Value{};
     }
 
     if (name == "PI") return Value{std::numbers::pi};

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/src/user_calls.cpp

@@ -882,6 +882,16 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
         // exactly (name in _BUILTIN_FN_NAMES gates which branch runs at
         // all).
         if (isBuiltinFunctionName(leftId->name)) {
+            // is_undef(name) is a probe: asking whether a name is defined
+            // must not itself warn that it isn't. The $-branch of
+            // evalIdentifier is already silent for any name, but a PLAIN
+            // identifier warned -- so `is_undef(some_flag)` was noisy here
+            // and silent in the reference. Verified against OpenSCAD:
+            // no warning for either spelling inside is_undef().
+            if (const oscad::Identifier* probe = undefProbeTarget(node)) {
+                return Value{std::holds_alternative<std::monostate>(
+                    evalIdentifier(probe->name, &probe->position(), ctx, /*warnIfUndef=*/false))};
+            }
             // object() needs the raw argument list, not a pre-resolved
             // CallArgs, to merge positional/named arguments in their exact
             // call-site interleaved order (see builtinObject's own

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/tests/CMakeLists.txt

@@ -21,6 +21,7 @@ add_executable(oscad_eval_tests
   test_render_expr.cpp
   test_booleans.cpp
   test_children_separate.cpp
+  test_feature_detection.cpp
   test_control_flow.cpp
   test_tail_calls.cpp
   test_function_builtins.cpp

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/tests/test_bytecode_compiler.cpp

@@ -162,13 +162,13 @@ TEST(BytecodeCompiler, SelfReferentialParameterDefaultResolvesToUndef) {
     ScopedVm vm(true);
     // Referencing "x" inside its own default falls all the way through to
     // Scope::lookupVariable finding nothing usable there (a
-    // ParameterDeclaration), producing the same "Ignoring unknown
-    // variable" WARNING the plain interpreter does today (verified against
-    // the unmodified CLI directly, not assumed) -- this test's own point is
-    // that the compiled path reproduces that exactly, warning included, not
-    // that the warning is otherwise desirable.
-    EXPECT_EQ(runCapturingEcho("function foo(x = is_undef(x) ? 5 : x) = x;\necho(foo());"),
-              "WARNING: Ignoring unknown variable 'x' in file <string>, line 1\nECHO: 5");
+    // ParameterDeclaration) -- undef, so the ternary takes the 5. Silent:
+    // is_undef() is a probe and does not warn about the name it asks about,
+    // matching the reference, which is silent for this exact script. This
+    // test's own point is that the compiled path reproduces the interpreter
+    // exactly; it used to assert a warning both engines emitted and the
+    // reference did not.
+    EXPECT_EQ(runCapturingEcho("function foo(x = is_undef(x) ? 5 : x) = x;\necho(foo());"), "ECHO: 5");
     // Caller-supplied value: default expression never runs at all, so no
     // warning either.
     EXPECT_EQ(runCapturingEcho("function foo(x = is_undef(x) ? 5 : x) = x;\necho(foo(10));"), "ECHO: 10");

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/tests/test_expr_eval.cpp

@@ -52,21 +52,34 @@ TEST(ExprEvalIdentifiers, UnknownVariableWarnsAndIsUndef) {
     EXPECT_NE(lastWarning.find("Ignoring unknown variable 'nope'"), std::string::npos);
 }
 
-TEST(ExprEvalIdentifiers, UndefinedDollarVariableIsUndefWithNoWarning) {
-    // Found via BOSL2's constants.scad: `function get_slop() = is_undef($slop)
-    // ? 0 : $slop;` with $slop never assigned anywhere in the script. Real
-    // OpenSCAD.app produces no warning at all -- $-prefixed names are a
-    // separate, always-implicitly-available namespace, never requiring a
-    // scope declaration the way a bare identifier does. This port's
-    // bytecode VM (Op::LoadDyn, bytecode_vm.cpp) already got this right by
-    // construction; the plain interpreter incorrectly fell through to the
-    // same "Ignoring unknown variable" path a genuinely undeclared bare
-    // identifier hits.
+TEST(ExprEvalIdentifiers, UndefinedDollarVariableIsUndefAndWarns) {
+    // A never-assigned $-name reads as undef and warns, exactly like a
+    // never-declared bare identifier.
+    //
+    // This test used to assert the opposite, on the strength of BOSL2's
+    // constants.scad -- `function get_slop() = is_undef($slop) ? 0 : $slop;`
+    // with $slop never assigned -- being silent in real OpenSCAD. It is,
+    // but not because $-reads are exempt: is_undef() does not warn about the
+    // name it probes, and the else branch never runs while is_undef() is
+    // true. Measured against the reference, a PLAIN read warns in every
+    // context tried -- echo, assignment, function body, module body,
+    // comparison -- so the old blanket exemption was over-generalised from
+    // one guarded expression.
     std::string lastWarning;
     Evaluator ev([&](const std::string& msg) { lastWarning = msg; });
     Value v = evalSrc("$slop", ev);
     EXPECT_TRUE(std::holds_alternative<std::monostate>(v));
-    EXPECT_TRUE(lastWarning.empty());
+    EXPECT_NE(lastWarning.find("Ignoring unknown variable '$slop'"), std::string::npos) << lastWarning;
+}
+
+TEST(ExprEvalIdentifiers, TheBoslGetSlopIdiomStaysSilent) {
+    // The case the old exemption existed for, kept as a test in its own
+    // right: it must remain silent through the is_undef() probe alone.
+    std::string lastWarning;
+    Evaluator ev([&](const std::string& msg) { lastWarning = msg; });
+    Value v = evalSrc("is_undef($slop) ? 0 : $slop", ev);
+    EXPECT_TRUE(lastWarning.empty()) << lastWarning;
+    EXPECT_EQ(std::get<double>(v), 0.0);
 }
 
 TEST(ExprEvalIdentifiers, ResolvesViaScopeFallbackWhenNotEagerlyBound) {

openscad_cpp_evaluator-0.45.0/tests/test_feature_detection.cpp

@@ -0,0 +1,162 @@
+// $_BELFRYSCAD and supported_feature() -- how a script asks which evaluator
+// it is running under, and what that evaluator can actually do.
+//
+// The hazard they exist for: OpenSCAD does not reject arguments or names it
+// has never heard of. `children(separate=true)` is silently ignored there,
+// so a script using an extension runs and quietly renders something else.
+// Both of these are readable from OpenSCAD too -- an unknown $-variable and
+// an unknown function are undef (with a warning), not errors -- so a guard
+// written against them works in both.
+
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscadeval;
+using namespace oscadeval::test;
+
+namespace {
+
+class ScopedVm {
+public:
+    explicit ScopedVm(bool enabled) { Evaluator::setBytecodeVmEnabledForTesting(enabled); }
+    ~ScopedVm() { Evaluator::setBytecodeVmEnabledForTesting(std::nullopt); }
+};
+
+std::vector<std::string> echoesFrom(const std::string& src) {
+    std::vector<std::string> out;
+    evalSrc(src, [&](const std::string& m) { out.push_back(m); });
+    return out;
+}
+
+// Every feature name the docs promise. A typo in either direction -- here or
+// in featureLevels() -- shows up as a 0.
+const char* kFeatures[] = {"separate-children", "minkowski-diff", "sphere-styles",   "export-name",
+                            "simplify-op",       "expr-import",    "object-function", "roof-op",
+                            "render-expr",       "polyhedron-vnf"};
+
+} // namespace
+
+TEST(FeatureDetection, BelfryscadVariableIsTheEvaluatorVersion) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        // Shaped like OpenSCAD's own version(): [major, minor, patch], so a
+        // comparison needs no string splitting. Read from pyproject.toml at
+        // configure time, so this cannot drift from the released version.
+        const std::vector<std::string> e = echoesFrom("echo(is_list($_BELFRYSCAD), len($_BELFRYSCAD));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("true"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+        EXPECT_NE(e[0].find("3"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FeatureDetection, BelfryscadVariableHoldsThreeNumbers) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesFrom(
+            "echo(is_num($_BELFRYSCAD[0]), is_num($_BELFRYSCAD[1]), is_num($_BELFRYSCAD[2]));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_EQ(e[0].find("false"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FeatureDetection, EveryDocumentedFeatureReportsALevel) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        for (const char* f : kFeatures) {
+            const std::vector<std::string> e =
+                echoesFrom(std::string("echo(supported_feature(\"") + f + "\"));");
+            ASSERT_EQ(e.size(), 1u) << f << ", vm=" << vm;
+            EXPECT_NE(e[0].find("1"), std::string::npos) << f << ", vm=" << vm << ", got " << e[0];
+            EXPECT_EQ(e[0].find("0"), std::string::npos) << f << " reported unsupported, vm=" << vm;
+        }
+    }
+}
+
+TEST(FeatureDetection, AnUnknownFeatureIsZeroAndSilent) {
+    // Probing for a feature from a future release has to be safe -- that is
+    // the whole point of asking. No warning, no error, just 0.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesFrom("echo(supported_feature(\"time-travel\"));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm << " (unexpected warning?)";
+        EXPECT_NE(e[0].find("0"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FeatureDetection, ANonStringArgumentIsZeroRatherThanAnError) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        for (const char* arg : {"42", "undef", "[1,2]"}) {
+            const std::vector<std::string> e =
+                echoesFrom(std::string("echo(supported_feature(") + arg + "));");
+            ASSERT_EQ(e.size(), 1u) << arg << ", vm=" << vm;
+            EXPECT_NE(e[0].find("0"), std::string::npos) << arg << ", vm=" << vm << ", got " << e[0];
+        }
+    }
+}
+
+TEST(FeatureDetection, SupportedFeatureMarkerIsSet) {
+    // Vendor-neutral: it says "supported_feature() is callable", not "this is
+    // BelfrySCAD". Any implementation adding the function is meant to set it,
+    // so a script guards on the capability rather than on who is running it.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesFrom("echo($_SUPPORTED_FEATURE);");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("true"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FeatureDetection, TheMarkerGuardsTheCallItself) {
+    // The bootstrapping shape: you cannot safely CALL supported_feature()
+    // without first knowing it exists. Checking the marker first solves that,
+    // and because && short-circuits, an evaluator lacking both warns once
+    // rather than twice -- verified against the reference binary, which
+    // reports exactly one warning for this source and takes the else branch.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesFrom(
+            "if (!is_undef($_SUPPORTED_FEATURE) && supported_feature(\"separate-children\"))\n"
+            "    echo(\"extended\");\n"
+            "else echo(\"portable\");\n");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("extended"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FeatureDetection, IsUndefDoesNotWarnAboutTheNameItProbes) {
+    // Asking whether a name is defined must not itself complain that it
+    // isn't -- otherwise the portable guard is noisy here while being
+    // silent in OpenSCAD. Both spellings, since only the $-prefixed one
+    // used to be quiet.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        for (const char* name : {"$_NO_SUCH_DOLLAR", "no_such_plain"}) {
+            const std::vector<std::string> e = echoesFrom(std::string("echo(is_undef(") + name + "));");
+            ASSERT_EQ(e.size(), 1u) << name << ", vm=" << vm << " (warned?)";
+            EXPECT_NE(e[0].find("true"), std::string::npos) << name << ", vm=" << vm << ", got " << e[0];
+        }
+        // A plain read of an unknown name still warns -- only the probe is
+        // exempt, and only for its own argument.
+        const std::vector<std::string> e = echoesFrom("echo(no_such_plain);");
+        ASSERT_EQ(e.size(), 2u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("Ignoring unknown variable"), std::string::npos) << "vm=" << vm;
+    }
+}
+
+TEST(FeatureDetection, TheGuardIdiomReadsTrueHere) {
+    // What a script actually writes. In OpenSCAD $_BELFRYSCAD is undef and
+    // supported_feature() is an unknown function returning undef -- both
+    // falsy -- so the same source takes the other branch there.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesFrom(
+            "if ($_BELFRYSCAD == undef) echo(\"portable\");\n"
+            "else if (supported_feature(\"separate-children\")) echo(\"extended\");\n");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("extended"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}

{openscad_cpp_evaluator-0.43.0 → openscad_cpp_evaluator-0.45.0}/tests/test_use.cpp

@@ -52,11 +52,14 @@ TEST(UseStatement, InjectsFunctionAndModuleButNotVariables) {
     std::vector<std::string> echoed;
     UseEvaluated e = evalFile(main, [&](const std::string& m) { echoed.push_back(m); });
 
-    ASSERT_EQ(echoed.size(), 3u);
+    // Two, not three: is_undef() is a probe and does not warn about the name
+    // it is asking about -- matching the reference, which is silent for this
+    // exact script. `ECHO: true` is what proves lib_var wasn't injected; the
+    // warning this used to also assert was our own divergence, not the point.
+    ASSERT_EQ(echoed.size(), 2u);
     EXPECT_EQ(echoed[0], "ECHO: 103"); // 1 + 2 + lib_var(100) -- proves lib_add's body resolves
                                         // lib_var from *its own* file's scope (reanchoring)
-    EXPECT_NE(echoed[1].find("WARNING: Ignoring unknown variable 'lib_var'"), std::string::npos); // NOT injected
-    EXPECT_EQ(echoed[2], "ECHO: true"); // is_undef(lib_var) in main's own scope
+    EXPECT_EQ(echoed[1], "ECHO: true"); // is_undef(lib_var) in main's own scope -- NOT injected
     EXPECT_EQ(e.bodies.size(), 1u);     // lib_cube(5) still produced geometry
     std::filesystem::remove(lib);
     std::filesystem::remove(main);