c-next 0.2.1 → 0.2.3

package/src/transpiler/output/codegen/__tests__/CodeGenerator.test.ts

@@ -29,6 +29,8 @@ function setupGenerator(source: string): {
 
   const symbolTable = new SymbolTable();
   const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+  // Issue #831: Register TSymbols in SymbolTable (single source of truth)
+  symbolTable.addTSymbols(tSymbols);
   const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
   const generator = new CodeGenerator();
@@ -982,7 +984,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("x = 42;");
+      expect(code).toContain("x = 42U;");
     });
 
     it("should translate compound assignment operators", () => {
@@ -1007,10 +1009,10 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("x += 5;");
-      expect(code).toContain("x -= 3;");
-      expect(code).toContain("x *= 2;");
-      expect(code).toContain("x /= 2;");
+      expect(code).toContain("x += 5U;");
+      expect(code).toContain("x -= 3U;");
+      expect(code).toContain("x *= 2U;");
+      expect(code).toContain("x /= 2U;");
     });
   });
 
@@ -1159,7 +1161,7 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("cnx_clamp_add_u8");
-      expect(code).toContain("cnx_clamp_add_u8(value, 100)");
+      expect(code).toContain("cnx_clamp_add_u8(value, 100U)");
     });
   });
 
@@ -1302,7 +1304,7 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("if (x == 10)");
-      expect(code).toContain("x = 5;");
+      expect(code).toContain("x = 5U;");
     });
 
     it("should generate if-else statement", () => {
@@ -1482,7 +1484,7 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("arr[3]");
-      expect(code).toContain("{1, 2, 3}");
+      expect(code).toContain("{1U, 2U, 3U}");
     });
 
     it("should generate multi-dimensional array", () => {
@@ -1583,7 +1585,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("a + b * 2 - 1");
+      expect(code).toContain("a + b * 2U - 1U");
     });
 
     it("should generate comparison expressions", () => {
@@ -1868,7 +1870,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("result = add(1, 2);");
+      expect(code).toContain("result = add(1U, 2U);");
     });
 
     it("should generate scope function call", () => {
@@ -1893,7 +1895,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("Math_square(5)");
+      expect(code).toContain("Math_square(5U)");
     });
   });
 
@@ -2145,7 +2147,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("(a > b) ? 1 : 0");
+      expect(code).toContain("(a > b) ? 1U : 0U");
     });
   });
 
@@ -2940,7 +2942,7 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("values[5]"); // Size inferred from initializer
-      expect(code).toContain("{1, 2, 3, 4, 5}");
+      expect(code).toContain("{1U, 2U, 3U, 4U, 5U}");
     });
   });
 
@@ -3347,7 +3349,7 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("const uint32_t LOOKUP[4]");
-      expect(code).toContain("{10, 20, 30, 40}");
+      expect(code).toContain("{10U, 20U, 30U, 40U}");
     });
   });
 
@@ -3754,8 +3756,8 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      // Should generate {0} for fill-all syntax
-      expect(code).toContain("{0}");
+      // Should generate all zeros with U suffix for unsigned fill-all
+      expect(code).toContain("{0U, 0U");
     });
 
     it("should generate fill-all array with non-zero value", () => {
@@ -3773,7 +3775,7 @@ describe("CodeGenerator", () => {
       });
 
       // Non-zero fill-all expands to all elements
-      expect(code).toContain("= {255, 255, 255, 255}");
+      expect(code).toContain("= {255U, 255U, 255U, 255U}");
     });
   });
 
@@ -3792,7 +3794,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("{{1, 2, 3}, {4, 5, 6}}");
+      expect(code).toContain("{{1U, 2U, 3U}, {4U, 5U, 6U}}");
     });
   });
 
@@ -5079,7 +5081,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("add(10, 20)");
+      expect(code).toContain("add(10U, 20U)");
     });
   });
 
@@ -5751,6 +5753,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
+      // Array element assignments don't get U suffix yet
       expect(code).toContain("output[0]");
       expect(code).toContain("output[1]");
     });
@@ -6562,7 +6565,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("{1, 2, 3, 4}");
+      expect(code).toContain("{1U, 2U, 3U, 4U}");
     });
   });
 
@@ -7655,7 +7658,7 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("while (i < 10)");
-        expect(code).toContain("cnx_clamp_add_u32(i, 1)");
+        expect(code).toContain("cnx_clamp_add_u32(i, 1U)");
       });
 
       it("should handle for loop with block", () => {
@@ -7723,7 +7726,7 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("__cnx_disable_irq()");
-        expect(code).toContain("cnx_clamp_add_u32(counter, 1)");
+        expect(code).toContain("cnx_clamp_add_u32(counter, 1U)");
         expect(code).toContain("__cnx_set_PRIMASK");
       });
 
@@ -8349,7 +8352,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("arr[5]");
+        expect(code).toContain("arr[5U]");
       });
 
       it("should handle bit range access on integer", () => {
@@ -8389,7 +8392,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("arr[0]");
+        expect(code).toContain("arr[0U]");
       });
 
       it("should handle struct member array element access", () => {
@@ -8409,7 +8412,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("d->values[0]");
+        expect(code).toContain("d->values[0U]");
       });
 
       it("should handle C++ mode array access", () => {
@@ -8430,7 +8433,7 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        expect(code).toContain("arr[5]");
+        expect(code).toContain("arr[5U]");
       });
 
       it("should handle multi-dimensional array access", () => {
@@ -8450,7 +8453,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("matrix[1][2]");
+        expect(code).toContain("matrix[1U][2U]");
       });
     });
 
@@ -8594,6 +8597,10 @@ describe("CodeGenerator", () => {
         const { tree, tokenStream } = CNextSourceParser.parse(source);
         const generator = new CodeGenerator();
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        // Issue #831: Register TSymbols in SymbolTable (single source of truth)
+        const symbolTable = new SymbolTable();
+        symbolTable.addTSymbols(tSymbols);
+        CodeGenState.symbolTable = symbolTable;
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
         const code = generator.generate(tree, tokenStream, {
@@ -8602,7 +8609,7 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        expect(code).toContain("d.values[0]");
+        expect(code).toContain("d.values[0U]");
       });
 
       it("should handle struct array element member access", () => {
@@ -8623,7 +8630,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("points[0].x");
+        expect(code).toContain("points[0U].x");
       });
 
       it("should handle function return member access pattern", () => {
@@ -8769,7 +8776,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain(">> 4");
       });
 
-      it("should generate float bit range read with shadow variable", () => {
+      it("should generate float bit range read with union shadow variable", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -8786,8 +8793,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses shadow variable and memcpy
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -9105,8 +9113,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Bitmap indexing generates bit extraction
-        expect(code).toContain("((flags >> 0) & 1)");
+        // Bitmap indexing generates bit extraction with U suffix
+        expect(code).toContain("((flags >> 0U) & 1)");
       });
     });
 
@@ -9368,7 +9376,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("(x > 3) ? 10 : 20");
+        expect(code).toContain("(x > 3U) ? 10U : 20U");
       });
     });
 
@@ -9632,7 +9640,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("{1, 2, 3, 4, 5}");
+        expect(code).toContain("{1U, 2U, 3U, 4U, 5U}");
       });
     });
 
@@ -9890,7 +9898,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("sizeof(x + 1)");
+        expect(code).toContain("sizeof(x + 1U)");
       });
     });
 
@@ -9936,6 +9944,7 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
+        // Array element assignments don't get U suffix yet
         expect(code).toContain("c.points[0].x = 5");
       });
     });
@@ -10002,8 +10011,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Constant expressions may be folded
-        expect(code).toContain("compute(8)");
+        // Literals get U suffix per MISRA Rule 7.2
+        expect(code).toContain("compute(5U + 3U)");
       });
     });
 
@@ -10210,9 +10219,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain(">> 8");
-        // Mask is generated as ((1U << 4) - 1) for bit width 4
-        expect(code).toContain("((1U << 4) - 1)");
+        expect(code).toContain(">> 8U");
+        // Mask is generated as ((1U << 4U) - 1) for bit width 4
+        expect(code).toContain("((1U << 4U) - 1)");
       });
     });
 
@@ -10694,6 +10703,7 @@ describe("CodeGenerator", () => {
         });
 
         // Array params don't need dereference
+        // Array element access doesn't get U suffix yet
         expect(code).toContain("arr[5]");
         expect(code).not.toContain("(*arr)");
       });
@@ -10741,7 +10751,7 @@ describe("CodeGenerator", () => {
     });
 
     describe("float bit range access helpers", () => {
-      it("should generate float bit range read with memcpy", () => {
+      it("should generate float bit range read with union", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -10758,11 +10768,12 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses memcpy for type punning
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range read", () => {
+      it("should generate f64 bit range read with union", () => {
         const source = `
           void test() {
             f64 value <- 3.14159;
@@ -10779,7 +10790,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("memcpy");
+        // f64 uses double/uint64_t union
+        expect(code).toContain("union { double f; uint64_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -11952,7 +11965,7 @@ describe("CodeGenerator", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void processPoints(Point[4] points) {
-            points[0].x <- 10;
+            points[0U].x <- 10;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -12255,7 +12268,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("flags");
       });
 
-      it("should handle float bit punning", () => {
+      it("should handle float bit punning with union", () => {
         const source = `
           void test() {
             f32 val <- 3.14;
@@ -12272,8 +12285,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses memcpy for type punning
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -12361,7 +12375,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("arr[5]");
+        expect(code).toContain("arr[5U]");
       });
 
       it("should resolve array element with variable index", () => {
@@ -12550,8 +12564,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Constant expressions get folded
-        expect(code).toContain("15");
+        // Literals get U suffix per MISRA Rule 7.2
+        expect(code).toContain("10U + 5U");
       });
     });
 
@@ -12861,7 +12875,7 @@ describe("CodeGenerator", () => {
 
   describe("refactored helper methods", () => {
     describe("float bit range access (PR #715 coverage)", () => {
-      it("should generate f32 bit range read with shadow and memcpy", () => {
+      it("should generate f32 bit range read with union shadow", () => {
         const source = `
           void test() {
             f32 floatVal <- 1.5;
@@ -12878,13 +12892,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Should use shadow variable pattern for float bit access
+        // Should use union-based type punning (MISRA 21.15 compliant)
         expect(code).toContain("__bits_floatVal");
-        expect(code).toContain("memcpy");
-        expect(code).toContain("uint32_t");
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range read with 64-bit shadow", () => {
+      it("should generate f64 bit range read with 64-bit union shadow", () => {
         const source = `
           void test() {
             f64 doubleVal <- 2.718;
@@ -12901,10 +12915,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Should use 64-bit shadow for f64
+        // Should use 64-bit union for f64 (MISRA 21.15 compliant)
         expect(code).toContain("__bits_doubleVal");
-        expect(code).toContain("uint64_t");
-        expect(code).toContain("memcpy");
+        expect(code).toContain("union { double f; uint64_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
       it("should reuse shadow variable for repeated float bit reads", () => {
@@ -12925,11 +12939,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Shadow variable should only be declared once
-        const shadowDecls = (code.match(/uint32_t __bits_val;/g) || []).length;
+        // Union shadow should only be declared once
+        const shadowDecls = (
+          code.match(/union { float f; uint32_t u; } __bits_val;/g) || []
+        ).length;
         expect(shadowDecls).toBe(1);
-        // But memcpy may be used only on first access
-        expect(code).toContain("__bits_val");
+        // Uses union member .u for bit access
+        expect(code).toContain("__bits_val.u");
       });
 
       it("should generate integer bit range with start=0 optimization", () => {
@@ -12949,11 +12965,11 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // When start=0, no shift needed - just mask
+        // Bit range access generates shift and mask
         expect(code).toContain("flags");
         expect(code).toContain("& 0xFF");
-        // Should NOT have >> 0 shift
-        expect(code).not.toContain(">> 0");
+        // MISRA Rule 7.2: shift amount gets U suffix
+        expect(code).toContain(">> 0U");
       });
 
       it("should generate integer bit range with shift for non-zero start", () => {
@@ -13532,7 +13548,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("buffer[5]");
+        expect(code).toContain("buffer[5U]");
       });
 
       it("should handle array access with variable index", () => {
@@ -13608,7 +13624,7 @@ describe("CodeGenerator", () => {
     });
 
     describe("float bit range edge cases", () => {
-      it("should generate f32 bit range with non-zero start position", () => {
+      it("should generate f32 bit range with non-zero start position using union", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -13627,7 +13643,9 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("__bits_value");
         expect(code).toContain(">> 8");
-        expect(code).toContain("memcpy");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
       it("should generate f32 bit range with start=0", () => {
@@ -13648,11 +13666,11 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("__bits_val");
-        // start=0 should NOT have >> 0 shift
-        expect(code).not.toContain(">> 0");
+        // MISRA Rule 7.2: shift amount gets U suffix
+        expect(code).toContain(">> 0U");
       });
 
-      it("should handle multiple reads from same float reusing shadow", () => {
+      it("should handle multiple reads from same float reusing union shadow", () => {
         const source = `
           void test() {
             f32 data <- 2.5;
@@ -13671,10 +13689,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Shadow declaration should appear once
-        expect(code).toContain("uint32_t __bits_data");
-        // Multiple reads should work
-        expect(code).toContain("__bits_data");
+        // Union shadow declaration should appear once
+        expect(code).toContain("union { float f; uint32_t u; } __bits_data;");
+        // Multiple reads should work via union member
+        expect(code).toContain("__bits_data.u");
       });
     });
 
@@ -14102,6 +14120,7 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("Point points[3]");
+        // Array element assignments don't get U suffix yet
         expect(code).toContain("points[0].x = 10");
       });
 
@@ -14229,7 +14248,7 @@ describe("CodeGenerator", () => {
         });
 
         // Array element member access
-        expect(code).toContain("items[0].id");
+        expect(code).toContain("items[0U].id");
       });
 
       it("should use arrow for struct params in C mode", () => {
@@ -14629,8 +14648,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Position 0 should NOT generate >> 0
-        expect(code).not.toContain(">> 0");
+        // MISRA Rule 7.2: shift amount gets U suffix
+        expect(code).toContain(">> 0U");
       });
 
       it("should generate 64-bit mask for u64 values", () => {
@@ -15190,7 +15209,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("multiply(5, 10)");
+        expect(code).toContain("multiply(5U, 10U)");
       });
 
       it("should generate scoped function call", () => {
@@ -15214,7 +15233,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("Math_square(5)");
+        expect(code).toContain("Math_square(5U)");
       });
     });
 
@@ -15352,7 +15371,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("arr[5]");
+        expect(code).toContain("arr[5U]");
       });
 
       it("should generate array access with variable index", () => {
@@ -15396,7 +15415,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("& 0xFF");
       });
 
-      it("should generate float bit range access with memcpy", () => {
+      it("should generate float bit range access with union", () => {
         const source = `
           void test() {
             f32 fval <- 1.5;
@@ -15413,11 +15432,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("memcpy");
-        expect(code).toContain("__bits_fval");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; } __bits_fval;");
+        expect(code).toContain("__bits_fval.u");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range access with uint64_t shadow", () => {
+      it("should generate f64 bit range access with uint64_t union shadow", () => {
         const source = `
           void test() {
             f64 dval <- 1.5;
@@ -15434,8 +15455,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("uint64_t __bits_dval");
-        expect(code).toContain("memcpy");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { double f; uint64_t u; } __bits_dval;");
+        expect(code).toContain("__bits_dval.u");
+        expect(code).not.toContain("memcpy");
       });
     });
   });
@@ -15487,8 +15510,8 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      // Expression should be constant-folded: 10 + 5 = 15
-      expect(code).toContain("uint8_t result = 15;");
+      // Const values are inlined, 5 gets U suffix per MISRA Rule 7.2
+      expect(code).toContain("uint8_t result = 10 + 5U;");
       expect(code).not.toContain("Bar_OFFSET");
     });
   });

package/src/transpiler/output/codegen/__tests__/RequireInclude.test.ts

@@ -133,7 +133,7 @@ describe("CodeGenerator requireInclude", () => {
       expect(result.code).toContain("sizeof(float)");
     });
 
-    it("generates static assert for float bit indexing read", async () => {
+    it("generates static assert for float bit indexing read (no string.h)", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
       const result = await transpiler.transpileSource(`
@@ -145,7 +145,9 @@ describe("CodeGenerator requireInclude", () => {
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("_Static_assert");
-      expect(result.code).toContain("#include <string.h>"); // For memcpy
+      // Uses union-based type punning, no memcpy needed (MISRA 21.15 compliant)
+      expect(result.code).not.toContain("#include <string.h>");
+      expect(result.code).toContain("union { float f; uint32_t u; }");
     });
   });