openscad-cpp-evaluator 0.46.0__tar.gz → 0.47.0__tar.gz

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/CLAUDE.md

@@ -45,9 +45,13 @@ comprehension clause kinds, user function calls (recursion, defaults, `FunctionL
 user module calls (`children()`/`children(N)`, closure detection via `callCtxFor`), list
 indexing/swizzle member access; the full math/string/list/type-check builtin *function* dispatch
 (`sin`/`cos`/`pow`/`search`/`lookup`/`chr`/`ord`/`is_*`/`object`/`has_key`/etc, ~43 names — a
-completely separate namespace/precedence rule from the builtin *modules* in `registry.cpp`: a
-builtin function name always wins over a same-named user function, checked *before* the
-user-function lookup), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
+same precedence rule as the builtin *modules* in `registry.cpp`: a user-defined function
+**shadows** a same-named builtin, looked up *before* the builtin table. This was backwards until
+0.47.0 — the port copied the old Python evaluator's `_eval_function_call` order, which had it
+wrong; OpenSCAD 2026.02.01 echoes 999 for `function abs(x)=999; abs(-3)` and we echoed 3. Fixing
+it needs **both** resolution sites: `evalFunctionCall` (`user_calls.cpp`) and the compiler's
+call-site resolution (`bytecode_compiler.cpp`), which bakes builtin-vs-user in at compile time,
+plus gating the silent `is_undef` probe on the call actually resolving to the builtin), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
 (VNF/JSON) contexts, and 3MF read/write; (Phase 6) `hull()`/`minkowski()` (transparent-splice
 CSG-tree shape like union/difference/intersection, role-split via the shared `splitByRole`),
 `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`, and `roof()`; and (Phase 7) `offset()`,

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/src/bytecode_compiler.cpp

@@ -567,6 +567,19 @@ public:
                         // evalBuiltinFunction when isImport is set.
                         site.isImport = true;
                         isStatic = true;
+                    } else if (const oscad::ASTNode* userFn =
+                                   scope_ ? scope_->lookupFunction(calleeName) : nullptr;
+                               userFn && userFn->kind() == NodeKind::FunctionDeclaration) {
+                        // A user-defined function SHADOWS a same-named
+                        // builtin, so this lookup runs BEFORE the builtin
+                        // table -- the same reordering as
+                        // evalFunctionCall's (user_calls.cpp), and it has
+                        // to happen here too: this decision is baked in at
+                        // COMPILE time, so leaving the builtin test first
+                        // would keep the bug on the default engine no
+                        // matter what the interpreter does.
+                        site.decl = static_cast<const oscad::FunctionDeclaration*>(userFn);
+                        isStatic = true;
                     } else if (isBuiltinFunctionName(calleeName)) {
                         // object() is already in this table -- it gets
                         // isBuiltin=true here like any other builtin, and
@@ -578,13 +591,10 @@ public:
                         // split positional/named CallArgs shape).
                         site.isBuiltin = true;
                         isStatic = true;
-                    } else {
-                        const oscad::ASTNode* found = scope_ ? scope_->lookupFunction(calleeName) : nullptr;
-                        if (found && found->kind() == NodeKind::FunctionDeclaration) {
-                            site.decl = static_cast<const oscad::FunctionDeclaration*>(found);
-                            isStatic = true;
-                        }
                     }
+                    // Anything else stays dynamic: a function-literal value,
+                    // or a name that is simply unknown. Op::CallDynamic
+                    // resolves it (and warns) at runtime.
                 }
 
                 if (!isStatic) {
@@ -626,7 +636,17 @@ public:
                 // 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)) {
+                //
+                // Only when the call resolves to the BUILTIN, though. A
+                // user function named is_undef shadows it (site resolution
+                // above) and evaluates its argument the ordinary way,
+                // warnings included -- which is what OpenSCAD does. The
+                // interpreter gets this for free by testing the probe
+                // inside its builtin branch; here the two are separate, so
+                // the condition has to be spelled out.
+                const oscad::Identifier* undefProbe =
+                    site.isBuiltin ? Evaluator::undefProbeTarget(n) : nullptr;
+                if (undefProbe) {
                     compileIdentifierLoad(undefProbe->name, undefProbe->position(), out, scope,
                                           /*warnIfUndef=*/false);
                     site.argNames.push_back(std::nullopt);

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/src/user_calls.cpp

@@ -876,11 +876,32 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
             CallArgs args = resolveArgs(*this, node.arguments, ctx);
             return importAsValue(*this, args, node);
         }
-        // A builtin function name always wins over a same-named user
-        // function -- checked *before* the user-function lookup, not
-        // after, matching the reference's _eval_function_call precedence
-        // exactly (name in _BUILTIN_FN_NAMES gates which branch runs at
-        // all).
+        // A user-defined function SHADOWS a same-named builtin, so the
+        // user lookup runs FIRST. Verified against OpenSCAD 2026.02.01:
+        // `function norm(x) = 999; echo(norm([3,4]));` echoes 999 there,
+        // and 5 here until this was fixed.
+        //
+        // The comment this replaces asserted the opposite order matched
+        // "the reference's _eval_function_call precedence exactly" -- but
+        // _eval_function_call / _BUILTIN_FN_NAMES are the old PYTHON
+        // evaluator, not OpenSCAD, and that prototype had it backwards.
+        // The C++ port inherited the mistake. Modules were always right
+        // (a user `module sphere()` does override the builtin); only
+        // functions resolved the wrong way round.
+        //
+        // bytecode_compiler.cpp's Op::CallFn site resolution has the same
+        // ordering and is fixed with it -- the VM is the default engine,
+        // so fixing only this one would leave the bug in place.
+        const oscad::ASTNode* decl = ctx.scope->lookupFunction(leftId->name);
+        if (decl && decl->kind() == oscad::NodeKind::FunctionDeclaration) {
+            // Call-site stop, in the CALLER's context, before descending
+            // into the callee (whose own body-entry stop comes later, from
+            // evalUserFunctionCore). Builtins deliberately get none --
+            // only the user-function and function-literal branches stop.
+            checkDebug(node, ctx, /*forced=*/false, /*exprLevel=*/false, /*callSite=*/true);
+            return evalUserFunction(leftId->name, static_cast<const oscad::FunctionDeclaration&>(*decl), node.arguments,
+                                     ctx, &node);
+        }
         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
@@ -901,17 +922,6 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
             CallArgs args = resolveArgs(*this, node.arguments, ctx);
             return evalBuiltinFunction(*this, leftId->name, args, node);
         }
-        const oscad::ASTNode* decl = ctx.scope->lookupFunction(leftId->name);
-        if (decl && decl->kind() == oscad::NodeKind::FunctionDeclaration) {
-            // Call-site stop, in the CALLER's context, before descending
-            // into the callee (whose own body-entry stop comes later, from
-            // evalUserFunctionCore). Builtins deliberately get none --
-            // mirrors _eval_function_call, where only the user-function and
-            // function-literal branches call _check_debug.
-            checkDebug(node, ctx, /*forced=*/false, /*exprLevel=*/false, /*callSite=*/true);
-            return evalUserFunction(leftId->name, static_cast<const oscad::FunctionDeclaration&>(*decl), node.arguments,
-                                     ctx, &node);
-        }
     }
 
     // Not a builtin or user function -- check whether the callee expression

{openscad_cpp_evaluator-0.46.0 → openscad_cpp_evaluator-0.47.0}/tests/test_function_builtins.cpp

@@ -508,18 +508,99 @@ TEST(ObjectBuiltin, PositionalNonObjectNonListArgumentIsUndef) {
     EXPECT_TRUE(isUndef(evalSrc("object(5)", ev)));
 }
 
-// -- Precedence: a builtin function name always wins over a same-named --
-// user function, unlike modules (where a user module CAN shadow a builtin).
+// -- Precedence: a user function SHADOWS a same-named builtin ------------
+//
+// Same rule as modules, which always got this right. It used to be
+// backwards for functions: the builtin won, because the port copied the old
+// Python evaluator's _eval_function_call order rather than OpenSCAD's.
+//
+// Read off OpenSCAD 2026.02.01:
+//   function abs(x) = 999;  echo(abs(-3));            -> 999
+//   function is_undef(x) = "mine"; echo(is_undef(q)); -> "mine", and it
+//       WARNS about the unknown variable q, because a user function
+//       evaluates its arguments normally -- only the builtin probe is
+//       silent.
+//
+// Every case runs under both engines: the VM decides builtin-vs-user at
+// COMPILE time (bytecode_compiler.cpp), so it needs its own fix and its
+// own coverage.
 
-TEST(FunctionBuiltinPrecedence, BuiltinWinsOverSameNamedUserFunction) {
-    Evaluator ev;
-    auto ast = parseSrc("function abs(x) = 999;\nresult = abs(-3);");
-    auto scope = oscad::buildScopes(ast);
-    auto* assign = dynamic_cast<oscad::Assignment*>(ast[1].get());
-    ASSERT_NE(assign, nullptr);
-    EvalContext ctx = EvalContext::makeRoot(scope.get());
-    Value v = ev.evalExpr(*assign->expr, ctx);
-    EXPECT_DOUBLE_EQ(asNum(v), 3.0); // builtin abs(), not the user's abs()
+namespace {
+
+class ScopedVm {
+public:
+    explicit ScopedVm(bool enabled) { Evaluator::setBytecodeVmEnabledForTesting(enabled); }
+    ~ScopedVm() { Evaluator::setBytecodeVmEnabledForTesting(std::nullopt); }
+};
+
+std::vector<std::string> echoesOf(const std::string& src) {
+    std::vector<std::string> out;
+    oscadeval::test::evalSrc(src, [&](const std::string& m) { out.push_back(m); });
+    return out;
+}
+
+} // namespace
+
+TEST(FunctionBuiltinPrecedence, UserFunctionShadowsSameNamedBuiltin) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("function abs(x) = 999;\necho(abs(-3));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("999"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, TheBuiltinStillWinsWhenNobodyRedefinesIt) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("echo(abs(-3));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("3"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+        EXPECT_EQ(e[0].find("999"), std::string::npos) << "vm=" << vm;
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, ShadowingHoldsInsideAUserFunctionBody) {
+    // The call is inside another function, so on the VM path it is reached
+    // through a COMPILED chunk rather than the interpreter -- this is the
+    // case a compiler-side fix is needed for.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e =
+            echoesOf("function abs(x) = 999;\nfunction outer() = abs(-3);\necho(outer());");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("999"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, AUserDefinedIsUndefShadowsTheProbe) {
+    // is_undef() is the one builtin with argument handling of its own (it
+    // must not warn about the name it is probing). A user's own is_undef
+    // takes over completely, arguments evaluated the ordinary way -- so the
+    // unknown-variable warning the probe suppresses DOES appear, exactly as
+    // upstream.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        std::vector<std::string> msgs;
+        oscadeval::test::evalSrc("function is_undef(x) = \"mine\";\necho(is_undef(nothing));",
+                                  [&](const std::string& m) { msgs.push_back(m); });
+        bool sawMine = false, sawWarning = false;
+        for (const std::string& m : msgs) {
+            if (m.find("mine") != std::string::npos) sawMine = true;
+            if (m.find("nothing") != std::string::npos) sawWarning = true;
+        }
+        EXPECT_TRUE(sawMine) << "vm=" << vm;
+        EXPECT_TRUE(sawWarning) << "vm=" << vm << ": a user function evaluates its argument normally";
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, TheIsUndefProbeIsStillSilentWhenNotRedefined) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("echo(is_undef(nothing));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm << ": probing must not warn";
+        EXPECT_NE(e[0].find("true"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
 }
 
 // -- Builtin argument diagnostics (reference parity) ---------------------