c-next 0.2.0 → 0.2.2

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

@@ -1807,40 +1807,24 @@ export default class CodeGenerator implements IOrchestrator {
   /**
    * Get struct field info for .length calculations.
    * Part of IOrchestrator interface.
+   *
+   * Issue #831: SymbolTable is the single source of truth for struct fields
+   * (both C-Next and C header structs).
    */
   getStructFieldInfo(
     structType: string,
     fieldName: string,
   ): { type: string; dimensions?: (number | string)[] } | null {
-    // First check SymbolTable (C header structs)
-    if (CodeGenState.symbolTable) {
-      const fieldInfo = CodeGenState.symbolTable.getStructFieldInfo(
-        structType,
-        fieldName,
-      );
-      if (fieldInfo) {
-        return {
-          type: fieldInfo.type,
-          dimensions: fieldInfo.arrayDimensions,
-        };
-      }
-    }
-
-    // Fall back to local C-Next struct fields
-    const localFields = CodeGenState.symbols!.structFields.get(structType);
-    if (localFields) {
-      const fieldType = localFields.get(fieldName);
-      if (fieldType) {
-        const fieldDimensions =
-          CodeGenState.symbols!.structFieldDimensions.get(structType);
-        const dimensions = fieldDimensions?.get(fieldName);
-        return {
-          type: fieldType,
-          dimensions: dimensions ? [...dimensions] : undefined,
-        };
-      }
+    const fieldInfo = CodeGenState.symbolTable?.getStructFieldInfo(
+      structType,
+      fieldName,
+    );
+    if (fieldInfo) {
+      return {
+        type: fieldInfo.type,
+        dimensions: fieldInfo.arrayDimensions,
+      };
     }
-
     return null;
   }
 
@@ -3451,14 +3435,25 @@ export default class CodeGenerator implements IOrchestrator {
     const isCppClass =
       CodeGenState.cppMode && this._isCppClassWithConstructor(typeName);
 
+    // Issue #834: For named struct tags (no typedef), we need 'struct' prefix in C mode
+    const needsStructKeyword =
+      !CodeGenState.cppMode &&
+      CodeGenState.symbolTable.checkNeedsStructKeyword(typeName);
+    const castType = TypeGenerationHelper.generateUserType(
+      typeName,
+      needsStructKeyword,
+    );
+
     if (!fieldList) {
       // Empty initializer: Point {} -> (Point){ 0 } or {} for C++ classes
-      return isCppClass ? "{}" : `(${typeName}){ 0 }`;
+      return isCppClass ? "{}" : `(${castType}){ 0 }`;
     }
 
     // Get field type info for nested initializers
-    // Issue #502: Check both local struct fields and SymbolTable (for C++ header structs)
-    const structFieldTypes = CodeGenState.symbols!.structFields.get(typeName);
+    // Issue #831: SymbolTable is the single source of truth for struct fields
+    // (both C-Next and C/C++ header structs)
+    const structFieldTypes =
+      CodeGenState.symbolTable?.getStructFieldTypes(typeName);
 
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
@@ -3501,7 +3496,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // For C-Next/C structs, generate designated initializer
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
-    return `(${typeName}){ ${fieldInits.join(", ")} }`;
+    return `(${castType}){ ${fieldInits.join(", ")} }`;
   }
 
   /**

package/src/transpiler/output/codegen/TypeResolver.ts

@@ -457,36 +457,24 @@ class TypeResolver {
 
   /**
    * Get type info for a struct member field.
-   * Issue #103: Checks SymbolTable first for C header structs.
+   * Issue #831: SymbolTable is the single source of truth for struct fields.
    */
   static getMemberTypeInfo(
     structType: string,
     memberName: string,
   ): { isArray: boolean; baseType: string } | undefined {
-    if (CodeGenState.symbolTable) {
-      const fieldInfo = CodeGenState.symbolTable.getStructFieldInfo(
-        structType,
-        memberName,
-      );
-      if (fieldInfo) {
-        return {
-          isArray:
-            fieldInfo.arrayDimensions !== undefined &&
-            fieldInfo.arrayDimensions.length > 0,
-          baseType: fieldInfo.type,
-        };
-      }
-    }
-
-    const fieldType = CodeGenState.symbols?.structFields
-      .get(structType)
-      ?.get(memberName);
-    if (!fieldType) return undefined;
-
-    const arrayFields = CodeGenState.symbols?.structFieldArrays.get(structType);
-    const isArray = arrayFields?.has(memberName) ?? false;
+    const fieldInfo = CodeGenState.symbolTable?.getStructFieldInfo(
+      structType,
+      memberName,
+    );
+    if (!fieldInfo) return undefined;
 
-    return { isArray, baseType: fieldType };
+    return {
+      isArray:
+        fieldInfo.arrayDimensions !== undefined &&
+        fieldInfo.arrayDimensions.length > 0,
+      baseType: fieldInfo.type,
+    };
   }
 }
 

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

@@ -36,6 +36,8 @@ function setupGenerator(
 
   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();
@@ -105,7 +107,7 @@ describe("CodeGenerator Coverage Tests", () => {
       `;
       const { code } = setupGenerator(source);
       // Single string indexing returns a char, not a string
-      expect(code).toContain("name[0]");
+      expect(code).toContain("name[0U]");
     });
 
     it("should return false for non-string array type", () => {
@@ -116,7 +118,7 @@ describe("CodeGenerator Coverage Tests", () => {
         }
       `;
       const { code } = setupGenerator(source);
-      expect(code).toContain("values[0]");
+      expect(code).toContain("values[0U]");
     });
 
     it("should handle array access without typeInfo", () => {
@@ -627,8 +629,8 @@ describe("CodeGenerator Coverage Tests", () => {
         u8[2][3] matrix <- [[1, 2, 3], [4, 5, 6]];
       `;
       const { code } = setupGenerator(source);
-      expect(code).toContain("{1, 2, 3}");
-      expect(code).toContain("{4, 5, 6}");
+      expect(code).toContain("{1U, 2U, 3U}");
+      expect(code).toContain("{4U, 5U, 6U}");
     });
 
     it("should generate simple expression elements", () => {
@@ -636,7 +638,130 @@ describe("CodeGenerator Coverage Tests", () => {
         u32[5] values <- [10, 20, 30, 40, 50];
       `;
       const { code } = setupGenerator(source);
-      expect(code).toContain("{10, 20, 30, 40, 50}");
+      expect(code).toContain("{10U, 20U, 30U, 40U, 50U}");
+    });
+  });
+
+  // ==========================================================================
+  // Issue #834: generateStructInitializer with named struct tags
+  // ==========================================================================
+  describe("generateStructInitializer() with named struct tags", () => {
+    it("should include struct keyword in compound literal for named struct tags", () => {
+      // Test the fix for issue #834: named struct tags need 'struct' prefix in cast
+      const source = `
+        struct NamedPoint { i32 x; i32 y; }
+        void test() {
+          NamedPoint p <- {x: 10, y: 20};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      // Mark NamedPoint as requiring 'struct' keyword (simulates C header import)
+      symbolTable.markNeedsStructKeyword("NamedPoint");
+
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+
+      // The compound literal cast should include 'struct' keyword
+      expect(code).toContain("(struct NamedPoint)");
+      expect(code).toContain(".x = 10");
+      expect(code).toContain(".y = 20");
+    });
+
+    it("should include struct keyword in empty initializer via return statement", () => {
+      // Test the empty initializer path (line 3465) via return statement
+      // This is the only way to use explicit type syntax without expectedType context
+      const source = `
+        struct ReturnStruct { i32 value; }
+        ReturnStruct getEmpty() {
+          return ReturnStruct {};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      symbolTable.markNeedsStructKeyword("ReturnStruct");
+
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+
+      // Empty initializer should have struct keyword: (struct ReturnStruct){ 0 }
+      expect(code).toContain("(struct ReturnStruct){ 0 }");
+    });
+
+    it("should NOT include struct keyword for typedef'd structs in C mode", () => {
+      // This tests the branch where checkNeedsStructKeyword returns false
+      const source = `
+        struct TypedefPoint { i32 x; i32 y; }
+        void test() {
+          TypedefPoint p <- {x: 1, y: 2};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      // Do NOT mark as needing struct keyword (simulates typedef'd struct)
+
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+
+      // Should NOT have 'struct' keyword since it's not marked
+      expect(code).not.toContain("(struct TypedefPoint)");
+      expect(code).toContain("(TypedefPoint)");
+    });
+
+    it("should NOT include struct keyword in C++ mode", () => {
+      const source = `
+        struct CppPoint { i32 x; i32 y; }
+        void test() {
+          CppPoint p <- {x: 5, y: 10};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      // Even if marked, C++ mode should not use struct keyword
+      symbolTable.markNeedsStructKeyword("CppPoint");
+
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: true,
+      });
+
+      // In C++ mode, struct keyword should NOT be in the cast
+      expect(code).not.toContain("(struct CppPoint)");
+      expect(code).toContain("(CppPoint)");
     });
   });