c-next 0.1.66 → 0.1.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/Transpiler.ts

@@ -19,7 +19,7 @@ import CNextSourceParser from "./logic/parser/CNextSourceParser";
 import HeaderParser from "./logic/parser/HeaderParser";
 
 import CodeGenerator from "./output/codegen/CodeGenerator";
-import CodeGenState from "./output/codegen/CodeGenState";
+import CodeGenState from "./state/CodeGenState";
 import HeaderGenerator from "./output/headers/HeaderGenerator";
 import ExternalTypeHeaderBuilder from "./output/headers/ExternalTypeHeaderBuilder";
 import ICodeGenSymbols from "./types/ICodeGenSymbols";
@@ -65,7 +65,6 @@ import TransitiveEnumCollector from "./logic/symbols/TransitiveEnumCollector";
  */
 class Transpiler {
   private readonly config: Required<ITranspilerConfig>;
-  private readonly symbolTable: SymbolTable;
   private readonly preprocessor: Preprocessor;
   private readonly codeGenerator: CodeGenerator;
   private readonly headerGenerator: HeaderGenerator;
@@ -108,7 +107,6 @@ class Transpiler {
     // Issue #211: Initialize cppDetected from config (--cpp flag sets this)
     this.cppDetected = this.config.cppRequired;
 
-    this.symbolTable = new SymbolTable();
     this.preprocessor = new Preprocessor();
     this.codeGenerator = new CodeGenerator();
     this.headerGenerator = new HeaderGenerator();
@@ -269,7 +267,7 @@ class Transpiler {
     }
 
     // Stage 3b: Resolve external const array dimensions
-    this.symbolTable.resolveExternalArrayDimensions();
+    CodeGenState.symbolTable.resolveExternalArrayDimensions();
 
     // Stage 4: Check for symbol conflicts (skipped in standalone mode)
     if (!input.skipConflictCheck && !this._checkSymbolConflicts(result)) {
@@ -337,8 +335,11 @@ class Transpiler {
     try {
       // ADR-055: Use composable collectors via CNextResolver + TSymbolAdapter
       const tSymbols = CNextResolver.resolve(tree, file.path);
-      const iSymbols = TSymbolAdapter.toISymbols(tSymbols, this.symbolTable);
-      this.symbolTable.addSymbols(iSymbols);
+      const iSymbols = TSymbolAdapter.toISymbols(
+        tSymbols,
+        CodeGenState.symbolTable,
+      );
+      CodeGenState.symbolTable.addSymbols(iSymbols);
 
       // Issue #465: Store ICodeGenSymbols for external enum resolution in stage 5
       const symbolInfo = TSymbolInfoAdapter.convert(tSymbols);
@@ -396,11 +397,13 @@ class Transpiler {
 
       // Run analyzers
       const externalStructFields =
-        AnalyzerContextBuilder.buildExternalStructFields(this.symbolTable);
+        AnalyzerContextBuilder.buildExternalStructFields(
+          CodeGenState.symbolTable,
+        );
 
       const analyzerErrors = runAnalyzers(tree, tokenStream, {
         externalStructFields,
-        symbolTable: this.symbolTable,
+        symbolTable: CodeGenState.symbolTable,
       });
       if (analyzerErrors.length > 0) {
         return this.buildErrorResult(
@@ -430,18 +433,13 @@ class Transpiler {
       this._setupCrossFileModifications();
 
       // Generate code
-      const code = this.codeGenerator.generate(
-        tree,
-        this.symbolTable,
-        tokenStream,
-        {
-          debugMode: this.config.debugMode,
-          target: this.config.target,
-          sourcePath,
-          cppMode: this.cppDetected,
-          symbolInfo,
-        },
-      );
+      const code = this.codeGenerator.generate(tree, tokenStream, {
+        debugMode: this.config.debugMode,
+        target: this.config.target,
+        sourcePath,
+        cppMode: this.cppDetected,
+        symbolInfo,
+      });
 
       // Collect user includes
       const userIncludes = IncludeExtractor.collectUserIncludes(tree);
@@ -461,7 +459,7 @@ class Transpiler {
       }
 
       // Update symbol parameters with auto-const info
-      const symbols = this.symbolTable.getSymbolsByFile(sourcePath);
+      const symbols = CodeGenState.symbolTable.getSymbolsByFile(sourcePath);
       const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
       const knownEnums =
         this.state.getSymbolInfo(sourcePath)?.knownEnums ?? new Set<string>();
@@ -471,7 +469,6 @@ class Transpiler {
       const headerCode = this.generateHeaderContent(
         symbols,
         sourcePath,
-        this.symbolTable,
         this.cppDetected,
         userIncludes,
         passByValueCopy,
@@ -631,7 +628,7 @@ class Transpiler {
     // Issue #587: Reset accumulated state for new run
     this.state.reset();
     // Issue #634: Reset symbol table for new run
-    this.symbolTable.clear();
+    CodeGenState.symbolTable.clear();
   }
 
   /**
@@ -668,7 +665,7 @@ class Transpiler {
    * @returns true if no blocking conflicts, false otherwise
    */
   private _checkSymbolConflicts(result: ITranspilerResult): boolean {
-    const conflicts = this.symbolTable.getConflicts();
+    const conflicts = CodeGenState.symbolTable.getConflicts();
     for (const conflict of conflicts) {
       result.conflicts.push(conflict.message);
       if (conflict.severity === "error") {
@@ -751,7 +748,7 @@ class Transpiler {
     if (warning) {
       result.warnings.push(warning);
     }
-    result.symbolsCollected = this.symbolTable.size;
+    result.symbolsCollected = CodeGenState.symbolTable.size;
     result.warnings = [...result.warnings, ...this.warnings];
 
     if (this.cacheManager) {
@@ -1040,13 +1037,16 @@ class Transpiler {
 
     // Debug: Show symbols found
     if (this.config.debugMode) {
-      const symbols = this.symbolTable.getSymbolsByFile(file.path);
+      const symbols = CodeGenState.symbolTable.getSymbolsByFile(file.path);
       console.log(`[DEBUG]   Found ${symbols.length} symbols in ${file.path}`);
     }
 
     // Issue #590: Cache the results using simplified API
     if (this.cacheManager) {
-      this.cacheManager.setSymbolsFromTable(file.path, this.symbolTable);
+      this.cacheManager.setSymbolsFromTable(
+        file.path,
+        CodeGenState.symbolTable,
+      );
     }
   }
 
@@ -1065,10 +1065,12 @@ class Transpiler {
     }
 
     // Restore symbols, struct fields, needsStructKeyword, and enumBitWidth from cache
-    this.symbolTable.addSymbols(cached.symbols);
-    this.symbolTable.restoreStructFields(cached.structFields);
-    this.symbolTable.restoreNeedsStructKeyword(cached.needsStructKeyword);
-    this.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
+    CodeGenState.symbolTable.addSymbols(cached.symbols);
+    CodeGenState.symbolTable.restoreStructFields(cached.structFields);
+    CodeGenState.symbolTable.restoreNeedsStructKeyword(
+      cached.needsStructKeyword,
+    );
+    CodeGenState.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
 
     // Issue #211: Still check for C++ syntax even on cache hit
     this.detectCppFromFileType(file);
@@ -1140,10 +1142,13 @@ class Transpiler {
   private parsePureCHeader(content: string, filePath: string): void {
     const { tree } = HeaderParser.parseC(content);
     if (tree) {
-      const collector = new CSymbolCollector(filePath, this.symbolTable);
+      const collector = new CSymbolCollector(
+        filePath,
+        CodeGenState.symbolTable,
+      );
       const symbols = collector.collect(tree);
       if (symbols.length > 0) {
-        this.symbolTable.addSymbols(symbols);
+        CodeGenState.symbolTable.addSymbols(symbols);
       }
     }
   }
@@ -1154,9 +1159,12 @@ class Transpiler {
   private parseCppHeader(content: string, filePath: string): void {
     const { tree } = HeaderParser.parseCpp(content);
     if (tree) {
-      const collector = new CppSymbolCollector(filePath, this.symbolTable);
+      const collector = new CppSymbolCollector(
+        filePath,
+        CodeGenState.symbolTable,
+      );
       const symbols = collector.collect(tree);
-      this.symbolTable.addSymbols(symbols);
+      CodeGenState.symbolTable.addSymbols(symbols);
     }
   }
 
@@ -1168,7 +1176,7 @@ class Transpiler {
    * Stage 6: Generate header file for a C-Next file
    */
   private generateHeader(file: IDiscoveredFile): string | null {
-    const symbols = this.symbolTable.getSymbolsByFile(file.path);
+    const symbols = CodeGenState.symbolTable.getSymbolsByFile(file.path);
     const exportedSymbols = symbols.filter((s) => s.isExported);
 
     if (exportedSymbols.length === 0) {
@@ -1199,12 +1207,12 @@ class Transpiler {
     // Issue #497: Build mapping from external types to their C header includes
     const externalTypeHeaders = ExternalTypeHeaderBuilder.build(
       this.state.getAllHeaderDirectives(),
-      this.symbolTable,
+      CodeGenState.symbolTable,
     );
 
     // Issue #502: Include symbolTable in typeInput for C++ namespace type detection
     const typeInputWithSymbolTable = typeInput
-      ? { ...typeInput, symbolTable: this.symbolTable }
+      ? { ...typeInput, symbolTable: CodeGenState.symbolTable }
       : undefined;
 
     const headerContent = this.headerGenerator.generate(
@@ -1274,7 +1282,6 @@ class Transpiler {
   private generateHeaderContent(
     symbols: ISymbol[],
     sourcePath: string,
-    symbolTable: SymbolTable,
     cppMode: boolean,
     userIncludes: string[],
     passByValueParams: Map<string, Set<string>>,
@@ -1318,12 +1325,12 @@ class Transpiler {
     // Issue #497: Build mapping from external types to their C header includes
     const externalTypeHeaders = ExternalTypeHeaderBuilder.build(
       this.state.getAllHeaderDirectives(),
-      symbolTable,
+      CodeGenState.symbolTable,
     );
 
     // Issue #502: Include symbolTable in typeInput for C++ namespace type detection
     const typeInputWithSymbolTable = typeInput
-      ? { ...typeInput, symbolTable }
+      ? { ...typeInput, symbolTable: CodeGenState.symbolTable }
       : undefined;
 
     // Issue #478: Pass all known enums for cross-file type handling
@@ -1429,7 +1436,7 @@ class Transpiler {
    * Get the symbol table (for testing/inspection)
    */
   getSymbolTable(): SymbolTable {
-    return this.symbolTable;
+    return CodeGenState.symbolTable;
   }
 
   /**

package/src/transpiler/logic/symbols/cnext/__tests__/TSymbolAdapter.test.ts

@@ -464,23 +464,8 @@ describe("TSymbolAdapter", () => {
     });
   });
 
-  describe("enum member resolution in array dimensions", () => {
-    it("resolves unqualified enum member in variable array dimension", () => {
-      const enumSym: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
-        name: "EColor",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: new Map([
-          ["RED", 0],
-          ["GREEN", 1],
-          ["BLUE", 2],
-          ["COUNT", 3],
-        ]),
-      };
-
+  describe("array dimension conversion", () => {
+    it("converts qualified enum access (dots to underscores) in variable dimensions", () => {
       const variable: IVariableSymbol = {
         kind: ESymbolKind.Variable,
         name: "DATA",
@@ -492,15 +477,11 @@ describe("TSymbolAdapter", () => {
         isConst: true,
         isAtomic: false,
         isArray: true,
-        arrayDimensions: ["COUNT"], // Unqualified enum member
+        arrayDimensions: ["EColor.COUNT"],
       };
 
-      const result = TSymbolAdapter.toISymbols(
-        [enumSym, variable],
-        symbolTable,
-      );
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
 
-      // Find the variable symbol
       const varSym = result.find(
         (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
       );
@@ -508,21 +489,7 @@ describe("TSymbolAdapter", () => {
       expect(varSym!.arrayDimensions).toEqual(["EColor_COUNT"]);
     });
 
-    it("resolves enum member in function parameter array dimension", () => {
-      const enumSym: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
-        name: "Size",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: new Map([
-          ["SMALL", 10],
-          ["MEDIUM", 20],
-          ["LARGE", 30],
-        ]),
-      };
-
+    it("converts qualified enum access in function parameter dimensions", () => {
       const funcSym: IFunctionSymbol = {
         kind: ESymbolKind.Function,
         name: "process",
@@ -538,14 +505,13 @@ describe("TSymbolAdapter", () => {
             type: "u8",
             isConst: false,
             isArray: true,
-            arrayDimensions: ["MEDIUM"], // Unqualified enum member
+            arrayDimensions: ["Size.MEDIUM"],
           },
         ],
       };
 
-      const result = TSymbolAdapter.toISymbols([enumSym, funcSym], symbolTable);
+      const result = TSymbolAdapter.toISymbols([funcSym], symbolTable);
 
-      // Find the function symbol
       const funcResult = result.find(
         (s) => s.kind === ESymbolKind.Function && s.name === "process",
       );
@@ -556,29 +522,7 @@ describe("TSymbolAdapter", () => {
       ]);
     });
 
-    it("does not resolve ambiguous enum member (exists in multiple enums)", () => {
-      const enum1: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
-        name: "EColor",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: new Map([["COUNT", 3]]),
-      };
-
-      const enum2: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
-        name: "ESize",
-        sourceFile: "test.cnx",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: new Map([
-          ["COUNT", 5], // Same member name in different enum
-        ]),
-      };
-
+    it("passes through unqualified string dimensions as-is", () => {
       const variable: IVariableSymbol = {
         kind: ESymbolKind.Variable,
         name: "DATA",
@@ -590,33 +534,42 @@ describe("TSymbolAdapter", () => {
         isConst: true,
         isAtomic: false,
         isArray: true,
-        arrayDimensions: ["COUNT"], // Ambiguous - exists in both enums
+        arrayDimensions: ["DEVICE_COUNT"], // C macro passthrough
       };
 
-      const result = TSymbolAdapter.toISymbols(
-        [enum1, enum2, variable],
-        symbolTable,
-      );
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
 
-      // Find the variable symbol - dimension should NOT be resolved
       const varSym = result.find(
         (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
       );
       expect(varSym).toBeDefined();
-      expect(varSym!.arrayDimensions).toEqual(["COUNT"]); // Left as-is
+      expect(varSym!.arrayDimensions).toEqual(["DEVICE_COUNT"]);
     });
 
     it("preserves numeric array dimensions", () => {
-      const enumSym: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
-        name: "EColor",
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
         sourceFile: "test.cnx",
-        sourceLine: 1,
+        sourceLine: 10,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        members: new Map([["COUNT", 3]]),
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: [256],
       };
 
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
+
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym!.arrayDimensions).toEqual(["256"]);
+    });
+
+    it("handles multi-dot qualified access (Motor.State.IDLE)", () => {
       const variable: IVariableSymbol = {
         kind: ESymbolKind.Variable,
         name: "DATA",
@@ -628,18 +581,15 @@ describe("TSymbolAdapter", () => {
         isConst: true,
         isAtomic: false,
         isArray: true,
-        arrayDimensions: [256], // Numeric dimension
+        arrayDimensions: ["Motor.State.COUNT"],
       };
 
-      const result = TSymbolAdapter.toISymbols(
-        [enumSym, variable],
-        symbolTable,
-      );
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
 
       const varSym = result.find(
         (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
       );
-      expect(varSym!.arrayDimensions).toEqual(["256"]);
+      expect(varSym!.arrayDimensions).toEqual(["Motor_State_COUNT"]);
     });
   });
 });

package/src/transpiler/logic/symbols/cnext/adapters/TSymbolAdapter.ts

@@ -40,9 +40,6 @@ class TSymbolAdapter {
    * @returns Array of flat ISymbol objects for Pipeline consumption
    */
   static toISymbols(symbols: TSymbol[], symbolTable: SymbolTable): ISymbol[] {
-    // First pass: Build enum member lookup for array dimension resolution
-    const enumMemberLookup = TSymbolAdapter.buildEnumMemberLookup(symbols);
-
     const result: ISymbol[] = [];
 
     for (const symbol of symbols) {
@@ -57,12 +54,10 @@ class TSymbolAdapter {
           result.push(TSymbolAdapter.convertStruct(symbol, symbolTable));
           break;
         case ESymbolKind.Function:
-          result.push(
-            ...TSymbolAdapter.convertFunction(symbol, enumMemberLookup),
-          );
+          result.push(...TSymbolAdapter.convertFunction(symbol));
           break;
         case ESymbolKind.Variable:
-          result.push(TSymbolAdapter.convertVariable(symbol, enumMemberLookup));
+          result.push(TSymbolAdapter.convertVariable(symbol));
           break;
         case ESymbolKind.Register:
           result.push(...TSymbolAdapter.convertRegister(symbol));
@@ -77,53 +72,20 @@ class TSymbolAdapter {
   }
 
   /**
-   * Build a lookup map from enum member names to their fully-qualified enum names.
-   * Used to resolve unqualified enum members in array dimensions.
-   *
-   * If a member name exists in multiple enums, it's marked as ambiguous (null value)
-   * and will not be resolved (the header will fail to compile, surfacing the issue).
-   */
-  private static buildEnumMemberLookup(
-    symbols: TSymbol[],
-  ): Map<string, string | null> {
-    const lookup = new Map<string, string | null>();
-
-    for (const symbol of symbols) {
-      if (symbol.kind !== ESymbolKind.Enum) continue;
-
-      for (const memberName of symbol.members.keys()) {
-        if (lookup.has(memberName)) {
-          // Ambiguous: member exists in multiple enums
-          lookup.set(memberName, null);
-        } else {
-          lookup.set(memberName, symbol.name);
-        }
-      }
-    }
-
-    return lookup;
-  }
-
-  /**
-   * Resolve an array dimension string, adding enum prefix if it's an unqualified enum member.
+   * Convert an array dimension to a string for header generation.
+   * Converts qualified enum access (e.g., "EColor.COUNT") to C-style ("EColor_COUNT").
    */
-  private static resolveArrayDimension(
-    dim: number | string,
-    enumMemberLookup: Map<string, string | null>,
-  ): string {
-    // Numeric dimensions don't need resolution
+  private static resolveArrayDimension(dim: number | string): string {
     if (typeof dim === "number") {
       return String(dim);
     }
 
-    // Check if this is an unqualified enum member
-    const enumName = enumMemberLookup.get(dim);
-    if (enumName) {
-      // Found in exactly one enum - add the prefix
-      return `${enumName}_${dim}`;
+    // Qualified enum access (e.g., "EColor.COUNT") - convert dots to underscores
+    if (dim.includes(".")) {
+      return dim.replaceAll(".", "_");
     }
 
-    // Not an enum member, or ambiguous - return as-is
+    // Pass through as-is (C macros, other identifiers)
     return dim;
   }
 
@@ -236,26 +198,23 @@ class TSymbolAdapter {
 
   /**
    * Convert IFunctionSymbol to ISymbol + parameter symbols for hover support.
-   * Resolves unqualified enum members in parameter array dimensions.
+   * Converts qualified enum names in parameter array dimensions.
    */
-  private static convertFunction(
-    func: IFunctionSymbol,
-    enumMemberLookup: Map<string, string | null>,
-  ): ISymbol[] {
+  private static convertFunction(func: IFunctionSymbol): ISymbol[] {
     const result: ISymbol[] = [];
 
     // Build parameter types for signature
     const paramTypes = func.parameters.map((p) => p.type);
     const signature = `${func.returnType} ${func.name}(${paramTypes.join(", ")})`;
 
-    // Build parameter info for header generation, resolving enum members in dimensions
+    // Build parameter info for header generation
     const parameters = func.parameters.map((p) => ({
       name: p.name,
       type: p.type,
       isConst: p.isConst,
       isArray: p.isArray,
       arrayDimensions: p.arrayDimensions?.map((dim) =>
-        TSymbolAdapter.resolveArrayDimension(dim, enumMemberLookup),
+        TSymbolAdapter.resolveArrayDimension(dim),
       ),
       isAutoConst: p.isAutoConst,
     }));
@@ -295,15 +254,12 @@ class TSymbolAdapter {
 
   /**
    * Convert IVariableSymbol to ISymbol.
-   * Resolves unqualified enum members in array dimensions.
+   * Converts qualified enum names in array dimensions.
    */
-  private static convertVariable(
-    variable: IVariableSymbol,
-    enumMemberLookup: Map<string, string | null>,
-  ): ISymbol {
-    // Convert dimensions to string dimensions, resolving enum member references
+  private static convertVariable(variable: IVariableSymbol): ISymbol {
+    // Convert dimensions to string dimensions
     const arrayDimensions = variable.arrayDimensions?.map((dim) =>
-      TSymbolAdapter.resolveArrayDimension(dim, enumMemberLookup),
+      TSymbolAdapter.resolveArrayDimension(dim),
     );
 
     // Get first dimension for legacy size field (only if numeric)