c-next 0.2.16 → 0.2.18

package/src/transpiler/logic/analysis/__tests__/MixedTypeCategoryAnalyzer.test.ts

@@ -0,0 +1,346 @@
+/**
+ * Unit tests for MixedTypeCategoryAnalyzer
+ * Tests detection of binary operators combining mixed essential type categories
+ * (MISRA C:2012 Rule 10.4, ADR-024 / Issue #1091).
+ */
+import { describe, it, expect } from "vitest";
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { CNextLexer } from "../../parser/grammar/CNextLexer";
+import { CNextParser } from "../../parser/grammar/CNextParser";
+import MixedTypeCategoryAnalyzer from "../MixedTypeCategoryAnalyzer";
+
+function parse(source: string) {
+  const charStream = CharStream.fromString(source);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+  return parser.program();
+}
+
+function analyze(source: string) {
+  return new MixedTypeCategoryAnalyzer().analyze(parse(source));
+}
+
+describe("MixedTypeCategoryAnalyzer", () => {
+  describe("mixed-category operands (rejected)", () => {
+    it("rejects unsigned + signed (u32 + i32)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          i32 b <- 2;
+          u32 c <- a + b;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0810");
+      expect(errors[0].message).toContain("essential type categories");
+    });
+
+    it("rejects signed + unsigned (i32 + u32), order-independent", () => {
+      const errors = analyze(`
+        void main() {
+          i32 a <- 1;
+          u32 b <- 2;
+          i32 c <- a + b;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("rejects a mixed comparison (u32 = i32)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          i32 b <- 2;
+          bool c <- (a = b);
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("rejects a mixed multiplication (u16 * i16)", () => {
+      const errors = analyze(`
+        void main() {
+          u16 a <- 1;
+          i16 b <- 2;
+          u16 c <- a * b;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("rejects a mixed bitwise-or (u8 | i8)", () => {
+      const errors = analyze(`
+        void main() {
+          u8 a <- 1;
+          i8 b <- 2;
+          u8 c <- a | b;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("rejects a mixed operand reached through parentheses and negation", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          i32 b <- 2;
+          u32 c <- a + (-b);
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("reports the differing pair in a chain (u32 + u32 + i32)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          u32 b <- 2;
+          i32 c <- 3;
+          u32 d <- a + b + c;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+  });
+
+  describe("same-category and exempt operands (accepted)", () => {
+    it("accepts same category (u32 + u32)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          u32 b <- 2;
+          u32 c <- a + b;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("accepts same category, different width (u8 + u32 widening)", () => {
+      const errors = analyze(`
+        void main() {
+          u8 a <- 1;
+          u32 b <- 2;
+          u32 c <- a + b;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("accepts an unsigned variable plus an integer literal", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          u32 c <- a + 5;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("accepts the sanctioned bit-indexed reinterpretation (a + b[0, 32])", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          i32 b <- 2;
+          u32 c <- a + b[0, 32];
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("accepts a single operand (no binary operator)", () => {
+      const errors = analyze(`
+        void main() {
+          i32 b <- 2;
+          i32 c <- b;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  describe("scope-aware variable typing (Issue #1085 review, Finding A)", () => {
+    it("does not flag a valid same-category expression because a same-named variable of a different category exists in another function", () => {
+      // main's `value` is u32; other's parameter `value` is i32. A flat,
+      // file-wide name->type map (last write wins) made `base + value` in main
+      // resolve `value` as i32 and falsely reject valid u32 + u32 code.
+      const errors = analyze(`
+        u32 main() {
+          u32 base <- 1;
+          u32 value <- 2;
+          u32 result <- base + value;
+          return 0;
+        }
+        i32 other(i32 value) {
+          return value;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("flags the genuinely mixed expression in its own function, not masked by a same-named variable elsewhere", () => {
+      // main's `value + delta` is u32 + i32 (mixed -> 1 error). other's
+      // `value + value` is i32 + i32 (same category -> no error). A flat map
+      // would mis-type main's `value` as i32 and MISS the real violation.
+      const errors = analyze(`
+        u32 main() {
+          u32 value <- 1;
+          i32 delta <- 2;
+          u32 r <- value + delta;
+          return 0;
+        }
+        void other(i32 value) {
+          i32 x <- value + value;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("does not flag !a = !b — logical negation yields Boolean, not the operand category (Issue #1085)", () => {
+      // `!a` and `!b` are both essentially Boolean regardless of a/b signedness,
+      // so the comparison shares a category and Rule 10.4 must NOT fire. The old
+      // code recursed through `!` and compared a's (unsigned) vs b's (signed)
+      // category, falsely rejecting valid code.
+      const errors = analyze(`
+        void main() {
+          u32 a <- 5;
+          i32 b <- 3;
+          bool r <- !a = !b;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("still flags a + b when operands differ in signedness (control for the ! fix)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 a <- 5;
+          i32 b <- 3;
+          i32 r <- a + b;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("isolates variables declared in different named scopes", () => {
+      // Each scope's `count` has its own type; neither scope's expression is mixed.
+      const errors = analyze(`
+        scope A {
+          u32 count <- 1;
+          u32 total <- count + count;
+        }
+        scope B {
+          i32 count <- 1;
+          i32 total <- count + count;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  describe("shift operators (Rule 10.4 does not govern shifts)", () => {
+    it("does not flag a left shift whose count is signed (u32 << i32)", () => {
+      // Rule 10.4 only governs operators subject to the usual arithmetic
+      // conversions; shifts are not (the count is promoted independently). A
+      // signed shift COUNT is a Rule 10.1 concern, not 10.4, so E0810 must not
+      // fire here (Issue #1085 review).
+      const errors = analyze(`
+        void main() {
+          u32 value <- 256;
+          i32 count <- 2;
+          u32 r <- value << count;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("does not flag a right shift whose count is signed (u32 >> i32)", () => {
+      const errors = analyze(`
+        void main() {
+          u32 value <- 256;
+          i32 count <- 2;
+          u32 r <- value >> count;
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  describe("block-aware variable typing (Issue #1085 review)", () => {
+    it("does not flag an outer expression when a different-category variable of the same name is declared in a nested block", () => {
+      // The inner `i32 x` shadows only within the if-block. The outer `x + a`
+      // (both u32) must not be poisoned by it. A function-wide last-write-wins
+      // map mis-typed the outer `x` as i32 and falsely rejected valid code.
+      const errors = analyze(`
+        void main() {
+          u32 x <- 1;
+          u32 a <- 2;
+          u32 r <- x + a;
+          if (r > 0) {
+            i32 x <- 5;
+            i32 z <- x + x;
+          }
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("does not flag an outer expression poisoned by a different-category for-loop variable", () => {
+      const errors = analyze(`
+        void main() {
+          u32 i <- 1;
+          u32 a <- 2;
+          u32 r <- i + a;
+          for (i32 i <- 0; i < 4; i <- i + 1) {
+            a <- a + 1;
+          }
+        }
+      `);
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  describe("no cascade of duplicate errors (Issue #1085 review)", () => {
+    it("reports a mixed nested expression once, not again at the enclosing level", () => {
+      // `a * b` is i32 * u32 (one violation). Representing the product by its
+      // leftmost operand (`a`, signed) let the `+ c` level re-report it against
+      // `c` (unsigned) — a second, misleading error. The product's category is
+      // ambiguous, so the enclosing level must not re-flag it.
+      const errors = analyze(`
+        void main() {
+          i32 a <- 1;
+          u32 b <- 2;
+          u32 c <- 3;
+          u32 r <- a * b + c;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("reports a mix inside parentheses once, not again at the outer operator", () => {
+      const errors = analyze(`
+        void main() {
+          i32 a <- 1;
+          u32 b <- 2;
+          u32 c <- 3;
+          u32 r <- (a + b) + c;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("still flags a uniform compound operand mixed against an outer operand", () => {
+      // (a + b) is u32 + u32 (uniform unsigned); combining it with the signed `c`
+      // is a real Rule 10.4 violation that must still be caught at the outer `+`.
+      const errors = analyze(`
+        void main() {
+          u32 a <- 1;
+          u32 b <- 2;
+          i32 c <- 3;
+          i32 r <- (a + b) + c;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+  });
+});

package/src/transpiler/logic/analysis/__tests__/ReturnPathAnalyzer.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Unit tests for ReturnPathAnalyzer
+ * ADR-112 / Issue #1040: non-void functions must return a value on all paths.
+ */
+import { describe, it, expect } from "vitest";
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { CNextLexer } from "../../parser/grammar/CNextLexer";
+import { CNextParser } from "../../parser/grammar/CNextParser";
+import ReturnPathAnalyzer from "../ReturnPathAnalyzer";
+
+function parse(source: string) {
+  const charStream = CharStream.fromString(source);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+  return parser.program();
+}
+
+function analyze(source: string) {
+  return new ReturnPathAnalyzer().analyze(parse(source));
+}
+
+describe("ReturnPathAnalyzer", () => {
+  describe("flags non-void functions that can fall through (E0704)", () => {
+    it("flags a function with no return at all", () => {
+      const errors = analyze(`
+        u8 getValue() {
+          u8 x <- 123;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0704");
+      expect(errors[0].functionName).toBe("getValue");
+    });
+
+    it("flags an if without else", () => {
+      const errors = analyze(`
+        u8 f(bool ready) {
+          if (ready = true) { return 1; }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags an if/else where one branch does not return", () => {
+      const errors = analyze(`
+        u8 f(bool ready) {
+          if (ready = true) { return 1; } else { u8 y <- 0; }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags a switch without a default", () => {
+      const errors = analyze(`
+        u8 f(u8 code) {
+          switch (code) {
+            case 1 { return 10; }
+            case 2 { return 20; }
+          }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags a switch where a case does not return", () => {
+      const errors = analyze(`
+        u8 f(u8 code) {
+          switch (code) {
+            case 1 { return 10; }
+            default { u8 z <- 0; }
+          }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags a while loop body (may not execute)", () => {
+      const errors = analyze(`
+        u8 f(u8 start) {
+          while (start > 0) { return start; }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags a for loop body (may not execute)", () => {
+      const errors = analyze(`
+        u8 f() {
+          for (u8 i <- 0; i < 3; i +<- 1) { return i; }
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("flags a bare `return;` in a non-void function", () => {
+      const errors = analyze(`
+        u8 f(bool done) {
+          if (done = true) { return 5; }
+          return;
+        }
+      `);
+      expect(errors).toHaveLength(1);
+    });
+  });
+
+  describe("accepts functions that return on all paths", () => {
+    it("accepts a simple return", () => {
+      expect(
+        analyze(`
+        u8 f() { return 1; }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts if/else where both branches return", () => {
+      expect(
+        analyze(`
+        u8 f(bool ready) {
+          if (ready = true) { return 1; } else { return 0; }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts an else-if chain that returns on every branch", () => {
+      expect(
+        analyze(`
+        u8 f(u8 n) {
+          if (n = 0) { return 1; }
+          else if (n = 1) { return 2; }
+          else { return 3; }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts a switch with default where all paths return", () => {
+      expect(
+        analyze(`
+        u8 f(u8 code) {
+          switch (code) {
+            case 1 { return 10; }
+            case 2 { return 20; }
+            default { return 0; }
+          }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts a do-while whose body unconditionally returns", () => {
+      expect(
+        analyze(`
+        u8 f() {
+          do { return 7; } while (1 = 1);
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts a loop followed by a trailing return (the canonical E0704 fix)", () => {
+      // The loop never counts as a guaranteed return; the trailing return does.
+      // This is the shape users will most often write to satisfy E0704, and it
+      // guards against any future drift toward 'last statement must return'.
+      expect(
+        analyze(`
+        u8 firstPositive(u8 n) {
+          while (n > 0) { return n; }
+          return 0;
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts a return after other statements (later statements unreachable)", () => {
+      expect(
+        analyze(`
+        u8 f() {
+          u8 x <- 1;
+          return x;
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("accepts a return nested in a critical block", () => {
+      expect(
+        analyze(`
+        u8 f() {
+          critical { return 1; }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("does not flag a void function with no return", () => {
+      expect(
+        analyze(`
+        void f() { u8 x <- 1; }
+      `),
+      ).toHaveLength(0);
+    });
+  });
+
+  describe("treats `forever` as a divergent terminal path (ADR-113, the primitive #849 consumes)", () => {
+    // A `forever` loop never exits (C-Next has no break/continue, ADR-026), so a
+    // function whose terminal path is `forever` never falls through and must not
+    // be flagged E0704. (In real programs `forever` is void-only via E0705 in
+    // codegen; this is the shared divergence primitive ADR-114 reuses.)
+    it("does not flag a function whose only path is a forever loop", () => {
+      expect(
+        analyze(`
+        u8 f() {
+          forever { u8 x <- 1; }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+
+    it("does not flag a forever loop after a non-returning if", () => {
+      expect(
+        analyze(`
+        u8 f(bool ready) {
+          if (ready = true) { return 1; }
+          forever { u8 y <- 0; }
+        }
+      `),
+      ).toHaveLength(0);
+    });
+  });
+});