openscad-cpp-evaluator 1.20.0__tar.gz → 1.20.2__tar.gz

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/PKG-INFO

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

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/pyproject.toml

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

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/src/user_calls.cpp

@@ -691,6 +691,14 @@ void Evaluator::recordTailCallHop(const std::string& calleeName, const oscad::AS
     // and never see the NEW one at all.
     noteActiveDeclExit(frame.declNode);
     noteActiveDeclEnter(&calleeDecl);
+    // Body coverage: this declaration was entered, exactly as in
+    // enterUserCall. A hop is the ONLY way into a tail-called body, so
+    // without this a function reached only in tail position reports its
+    // body as never run while its own branch arms report hits -- which
+    // reads as "the condition was not covered but the branches were".
+    // BOSL2's _str_split_recurse is the shape that shows it: recursion
+    // through a ternary arm is a tail call every time.
+    coverHit(calleeDecl);
     frame.name = calleeName;
     frame.declNode = &calleeDecl;
     frame.declPosition = &calleeDecl.position();

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/src/value.cpp

@@ -410,24 +410,28 @@ std::string encodeEscapedCodePoint(std::uint32_t cp) {
 std::string unescapeStringLiteral(const std::string& raw) {
     // Most strings need no work at all, and this runs on every evaluation
     // of a literal on the tree-walking path -- so don't build a second copy
-    // unless there is something to change. A bare newline counts as
-    // something to change (see the loop), so it has to open the scan too.
-    const size_t first = raw.find_first_of("\\\n");
+    // unless there is something to change. A bare line ending counts as
+    // something to change (see the loop), so CR and LF open the scan too.
+    const size_t first = raw.find_first_of("\\\n\r");
     if (first == std::string::npos) return raw;
 
     std::string out;
     out.reserve(raw.size());
     out.append(raw, 0, first);
     for (size_t i = first; i < raw.size(); ++i) {
-        // A raw LF inside a string literal contributes NOTHING -- writing a
-        // string across two source lines joins them, keeping the second
-        // line's indentation:
+        // A raw line ending inside a string literal contributes NOTHING --
+        // writing a string across two source lines joins them, keeping the
+        // second line's indentation:
         //     s = "abcd
         //         efgh";      // -> "abcd    efgh", 12 characters
-        // A raw CR is not special and stands for itself, so a CRLF file
-        // leaves the CR behind (len 3 for "x<CR><LF>y"). Both verified on
-        // 2026.02.01.
-        if (raw[i] == '\n') continue;
+        // CR counts as a line ending too, which the reference does not do:
+        // it drops only the LF, so every string wrapped in a file written
+        // on Windows keeps a stray CR (len 3 for "x<CR><LF>y" there, 2
+        // here). A raw CR in source is a line ending in every real file --
+        // CRLF on Windows, a lone CR on a pre-OSX Mac -- and a string that
+        // wants a real CR in it writes \r. Same reasoning as the backslash
+        // continuation below.
+        if (raw[i] == '\n' || raw[i] == '\r') continue;
         if (raw[i] != '\\' || i + 1 >= raw.size()) {
             out.push_back(raw[i]);  // a trailing lone backslash stands for itself
             continue;
@@ -467,18 +471,10 @@ std::string unescapeStringLiteral(const std::string& raw) {
                 ++i;
                 break;
             }
-            case '\n': ++i; break;  // backslash + LF: both go
-            case '\r':
-                // A backslash before CRLF takes the whole line ending.
-                // Deliberately unlike the reference, which treats the
-                // backslash as an undefined escape and keeps the CR --
-                // leaving a stray control character in any string wrapped
-                // in a file written on Windows. See this suite's
-                // BackslashNewlineContributesNothing.
-                if (i + 2 < raw.size() && raw[i + 2] == '\n') { i += 2; break; }
-                out.push_back('\r');
-                ++i;
-                break;
+            // A backslash before a line ending takes the whole thing; any
+            // LF after a CR is dropped by the loop itself.
+            case '\n':
+            case '\r': ++i; break;
             default: out.push_back(next); ++i; break;  // \\ and \" land here too
         }
     }

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/tests/test_coverage.cpp

@@ -168,6 +168,33 @@ TEST(Coverage, VmAndInterpreterAgree) {
     }
 }
 
+// A tail call hops the frame instead of pushing one, so it never reaches
+// enterUserCall -- where the body hit is recorded. A function reached ONLY
+// in tail position therefore reported its body as never run while its own
+// ternary arms reported hits, which reads on screen as "the condition is
+// uncovered but both branches are covered". BOSL2's _str_split_recurse is
+// the shape that shows it: recursion through a ternary arm is a tail call
+// every time.
+TEST(Coverage, TailCalledBodyIsCounted) {
+    const std::string code =
+        "function inner(i) = i == 0 ? \"done\" : inner(i-1);\n"
+        "function tail_caller(i) = inner(i);\n"
+        "echo(tail_caller(2));\n";
+    for (bool useVm : {true, false}) {
+        ScopedVm vm(useVm);
+        const CoverageResult r = cover(code);
+        std::uint32_t innerBody = 0, arms = 0;
+        for (const CoverageSpan& s : r.spans) {
+            if (s.kind == CoverageKind::Body && s.line == 1) innerBody = s.hits;
+            if (s.kind == CoverageKind::Branch && s.line == 1) arms += s.hits;
+        }
+        EXPECT_GT(innerBody, 0u) << (useVm ? "VM" : "interpreter")
+                                 << ": a body reached only by tail calls still ran";
+        EXPECT_EQ(innerBody, arms) << (useVm ? "VM" : "interpreter")
+                                   << ": every entry takes exactly one arm";
+    }
+}
+
 TEST(Coverage, PerFilePercentages) {
     const CoverageResult r = cover(
         "function f(x) = x > 0 ? 1 : 2;\n"   // body hit; arms: 1 of 2

{openscad_cpp_evaluator-1.20.0 → openscad_cpp_evaluator-1.20.2}/tests/test_value.cpp

@@ -470,8 +470,8 @@ TEST(StringEscapes, BackslashNewlineContributesNothing) {
     // Deliberately unlike the reference implementation, which drops only
     // the LF and leaves the CR in the value -- a stray control character
     // in any string continued in a file written on Windows.
-    EXPECT_EQ(unescapeStringLiteral("a \\\rb"), "a \rb")
-        << "a lone CR is an ordinary escaped character, not a line ending";
+    EXPECT_EQ(unescapeStringLiteral("a \\\rb"), "a b")
+        << "a lone CR is a line ending too (pre-OSX Mac)";
 }
 
 // Both evaluation paths build the Value, and only one of them was reached
@@ -583,11 +583,16 @@ TEST(StringEscapes, ARawNewlineInsideALiteralContributesNothing) {
     EXPECT_EQ(unescapeStringLiteral("x\n  \n  y"), "x    y");
 }
 
-TEST(StringEscapes, ARawCarriageReturnStandsForItself) {
-    // Only the LF is special. A CRLF file therefore leaves the CR in the
-    // string: "x<CR><LF>y" is three characters, not two.
-    EXPECT_EQ(unescapeStringLiteral("x\ry"), "x\ry");
-    EXPECT_EQ(unescapeStringLiteral("x\r\ny"), "x\ry");
+TEST(StringEscapes, ARawCarriageReturnIsALineEndingToo) {
+    // The reference treats only the LF as special, so a string wrapped in
+    // a CRLF file keeps a stray CR there ("x<CR><LF>y" is three characters
+    // on 2026.02.01). Deliberately not reproduced: a raw CR in source is a
+    // line ending in every real file -- CRLF on Windows, a lone CR on a
+    // pre-OSX Mac -- and a script wanting a real CR writes \r.
+    EXPECT_EQ(unescapeStringLiteral("x\r\ny"), "xy");
+    EXPECT_EQ(unescapeStringLiteral("x\ry"), "xy");
+    EXPECT_EQ(unescapeStringLiteral("x\r\n  y"), "x  y") << "indentation is kept";
+    EXPECT_EQ(unescapeStringLiteral("x\\ry"), "x\ry") << "an escaped CR still works";
 }
 
 TEST(StringEscapes, ABackslashBeforeANewlineTakesTheWholeLineEnding) {
@@ -600,5 +605,5 @@ TEST(StringEscapes, ABackslashBeforeANewlineTakesTheWholeLineEnding) {
     // BackslashNewlineContributesNothing above.
     EXPECT_EQ(unescapeStringLiteral("x\\\ny"), "xy");
     EXPECT_EQ(unescapeStringLiteral("x\\\r\ny"), "xy");   // reference keeps the CR
-    EXPECT_EQ(unescapeStringLiteral("x\\\ry"), "x\ry");
+    EXPECT_EQ(unescapeStringLiteral("x\\\ry"), "xy");
 }