c-next 0.2.0 → 0.2.2

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", () => {
@@ -9105,8 +9112,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 +9375,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("(x > 3) ? 10 : 20");
+        expect(code).toContain("(x > 3U) ? 10U : 20U");
       });
     });
 
@@ -9632,7 +9639,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("{1, 2, 3, 4, 5}");
+        expect(code).toContain("{1U, 2U, 3U, 4U, 5U}");
       });
     });
 
@@ -9890,7 +9897,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("sizeof(x + 1)");
+        expect(code).toContain("sizeof(x + 1U)");
       });
     });
 
@@ -9936,6 +9943,7 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
+        // Array element assignments don't get U suffix yet
         expect(code).toContain("c.points[0].x = 5");
       });
     });
@@ -10002,8 +10010,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 +10218,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 +10702,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)");
       });
@@ -11952,7 +11961,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);
@@ -12361,7 +12370,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 +12559,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");
       });
     });
 
@@ -12949,11 +12958,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 +13541,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("buffer[5]");
+        expect(code).toContain("buffer[5U]");
       });
 
       it("should handle array access with variable index", () => {
@@ -13648,8 +13657,8 @@ 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", () => {
@@ -14102,6 +14111,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 +14239,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 +14639,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 +15200,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 +15224,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("Math_square(5)");
+        expect(code).toContain("Math_square(5U)");
       });
     });
 
@@ -15352,7 +15362,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("arr[5]");
+        expect(code).toContain("arr[5U]");
       });
 
       it("should generate array access with variable index", () => {
@@ -15487,8 +15497,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/analysis/MemberChainAnalyzer.ts

@@ -171,25 +171,21 @@ class MemberChainAnalyzer {
       return false;
     }
 
-    const structFields = CodeGenState.symbols?.structFields.get(
+    // Issue #831: Use SymbolTable as single source of truth for struct fields
+    const fieldInfo = CodeGenState.symbolTable?.getStructFieldInfo(
       state.currentStructType,
+      fieldName,
     );
-    if (!structFields) {
+    if (!fieldInfo) {
       return false;
     }
 
-    const fieldType = structFields.get(fieldName);
-    if (!fieldType) {
-      return false;
-    }
-
-    state.currentType = fieldType;
+    state.currentType = fieldInfo.type;
 
-    // Check if this field is an array
-    const arrayFields = CodeGenState.symbols?.structFieldArrays.get(
-      state.currentStructType,
-    );
-    state.isCurrentArray = arrayFields?.has(fieldName) ?? false;
+    // Check if this field is an array (has array dimensions)
+    state.isCurrentArray =
+      fieldInfo.arrayDimensions !== undefined &&
+      fieldInfo.arrayDimensions.length > 0;
 
     // If the field type is a struct, update currentStructType
     state.currentStructType = CodeGenState.isKnownStruct(state.currentType)

package/src/transpiler/output/codegen/analysis/__tests__/MemberChainAnalyzer.test.ts

@@ -9,6 +9,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import MemberChainAnalyzer from "../MemberChainAnalyzer.js";
 import CodeGenState from "../../../../state/CodeGenState.js";
+import SymbolTable from "../../../../logic/symbols/SymbolTable.js";
 import type * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
 
 /** Mock type for PostfixTargetOpContext */
@@ -70,14 +71,31 @@ describe("MemberChainAnalyzer", () => {
   });
 
   /**
-   * Helper to set up struct fields in CodeGenState.symbols
+   * Helper to set up struct fields in CodeGenState.symbolTable
+   * Issue #831: SymbolTable is now the single source of truth for struct fields
    */
   function setupStructFields(
     structName: string,
     fields: Map<string, string>,
     arrayFields: Set<string> = new Set(),
   ): void {
-    // Initialize symbols if not set
+    // Initialize symbolTable if not set
+    if (!CodeGenState.symbolTable) {
+      CodeGenState.symbolTable = new SymbolTable();
+    }
+
+    // Register struct fields in SymbolTable
+    for (const [fieldName, fieldType] of fields) {
+      const isArray = arrayFields.has(fieldName);
+      CodeGenState.symbolTable.addStructField(
+        structName,
+        fieldName,
+        fieldType,
+        isArray ? [10] : undefined, // Use realistic dimension for arrays
+      );
+    }
+
+    // Also mark struct as known (for isKnownStruct checks)
     if (!CodeGenState.symbols) {
       CodeGenState.symbols = {
         knownStructs: new Set(),
@@ -108,14 +126,6 @@ describe("MemberChainAnalyzer", () => {
       };
     }
     (CodeGenState.symbols.knownStructs as Set<string>).add(structName);
-    (CodeGenState.symbols.structFields as Map<string, Map<string, string>>).set(
-      structName,
-      fields,
-    );
-    (CodeGenState.symbols.structFieldArrays as Map<string, Set<string>>).set(
-      structName,
-      arrayFields,
-    );
   }
 
   describe("analyze", () => {

package/src/transpiler/output/codegen/assignment/AssignmentClassifier.ts

@@ -669,8 +669,11 @@ class AssignmentClassifier {
     if (!structType) {
       return null;
     }
-    const structFields = CodeGenState.symbols!.structFields.get(structType);
-    const fieldType = structFields?.get(structFieldNames.fieldName);
+    // Issue #831: Use SymbolTable as single source of truth for struct fields
+    const fieldType = CodeGenState.symbolTable?.getStructFieldType(
+      structType,
+      structFieldNames.fieldName,
+    );
     return { structType, fieldType };
   }
 

package/src/transpiler/output/codegen/assignment/__tests__/AssignmentClassifier.test.ts

@@ -3,6 +3,7 @@ import AssignmentClassifier from "../AssignmentClassifier";
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
 import CodeGenState from "../../../../state/CodeGenState";
+import SymbolTable from "../../../../logic/symbols/SymbolTable";
 import TTypeInfo from "../../types/TTypeInfo";
 
 // ========================================================================
@@ -64,6 +65,7 @@ function createTypeInfo(overrides: Partial<TTypeInfo> = {}): TTypeInfo {
 
 /**
  * Helper to set up CodeGenState.symbols with minimal fields.
+ * Issue #831: Also registers struct fields in SymbolTable (single source of truth).
  */
 function setupSymbols(
   overrides: {
@@ -77,6 +79,22 @@ function setupSymbols(
     structFieldDimensions?: Map<string, Map<string, readonly number[]>>;
   } = {},
 ): void {
+  // Initialize symbolTable for struct field lookups
+  CodeGenState.symbolTable = new SymbolTable();
+
+  // Register struct fields in SymbolTable
+  if (overrides.structFields) {
+    for (const [structName, fields] of overrides.structFields) {
+      for (const [fieldName, fieldType] of fields) {
+        CodeGenState.symbolTable.addStructField(
+          structName,
+          fieldName,
+          fieldType,
+        );
+      }
+    }
+  }
+
   CodeGenState.symbols = {
     knownScopes: overrides.knownScopes ?? new Set(),
     knownStructs: overrides.knownStructs ?? new Set(),

package/src/transpiler/output/codegen/assignment/handlers/StringHandlers.ts

@@ -57,10 +57,26 @@ function handleSimpleStringAssignment(ctx: IAssignmentContext): string {
  * Shared helper for struct field string handlers.
  */
 function getStructFieldType(structName: string, fieldName: string): string {
+  // Issue #831: Use SymbolTable as single source of truth for struct fields
   const structTypeInfo = CodeGenState.getVariableTypeInfo(structName);
-  const structType = structTypeInfo!.baseType;
-  const structFields = CodeGenState.symbols!.structFields.get(structType);
-  return structFields!.get(fieldName)!;
+  if (!structTypeInfo) {
+    throw new Error(
+      `Error: Unknown struct variable '${structName}' in string assignment`,
+    );
+  }
+
+  const structType = structTypeInfo.baseType;
+  const fieldType = CodeGenState.symbolTable?.getStructFieldType(
+    structType,
+    fieldName,
+  );
+  if (!fieldType) {
+    throw new Error(
+      `Error: Unknown field '${fieldName}' on struct '${structType}' in string assignment`,
+    );
+  }
+
+  return fieldType;
 }
 
 /**
@@ -70,7 +86,12 @@ function getStructFieldType(structName: string, fieldName: string): string {
  */
 function getStructType(structName: string): string {
   const structTypeInfo = CodeGenState.getVariableTypeInfo(structName);
-  return structTypeInfo!.baseType;
+  if (!structTypeInfo) {
+    throw new Error(
+      `Error: Unknown struct variable '${structName}' in string assignment`,
+    );
+  }
+  return structTypeInfo.baseType;
 }
 
 /**

package/src/transpiler/output/codegen/assignment/handlers/__tests__/handlerTestUtils.ts

@@ -5,6 +5,7 @@
 
 import { vi } from "vitest";
 import CodeGenState from "../../../../../state/CodeGenState";
+import SymbolTable from "../../../../../logic/symbols/SymbolTable";
 import type ICodeGenApi from "../../../types/ICodeGenApi";
 import type ICodeGenSymbols from "../../../../../types/ICodeGenSymbols";
 import type TTypeInfo from "../../../types/TTypeInfo";
@@ -63,12 +64,29 @@ function createDefaultMockSymbols(): ICodeGenSymbols {
 /**
  * Set up mock symbols on CodeGenState.
  * Provides comprehensive defaults that can be overridden.
+ * Issue #831: Also registers struct fields in SymbolTable for single source of truth.
  */
 function setupMockSymbols(overrides: Partial<ICodeGenSymbols> = {}): void {
   CodeGenState.symbols = {
     ...createDefaultMockSymbols(),
     ...overrides,
   };
+
+  // Also register struct fields in SymbolTable (single source of truth)
+  if (overrides.structFields) {
+    if (!CodeGenState.symbolTable) {
+      CodeGenState.symbolTable = new SymbolTable();
+    }
+    for (const [structName, fields] of overrides.structFields) {
+      for (const [fieldName, fieldType] of fields) {
+        CodeGenState.symbolTable.addStructField(
+          structName,
+          fieldName,
+          fieldType,
+        );
+      }
+    }
+  }
 }
 
 /**