c-next 0.1.65 → 0.1.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",
@@ -118,5 +118,9 @@
     "*.ts": [
       "oxlint --fix"
     ]
+  },
+  "volta": {
+    "node": "24.13.1",
+    "npm": "11.8.0"
   }
 }

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

@@ -463,4 +463,133 @@ describe("TSymbolAdapter", () => {
       expect(symbolTable.getStructFieldType("Point", "x")).toBe("i32");
     });
   });
+
+  describe("array dimension conversion", () => {
+    it("converts qualified enum access (dots to underscores) in variable dimensions", () => {
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: ["EColor.COUNT"],
+      };
+
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
+
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym).toBeDefined();
+      expect(varSym!.arrayDimensions).toEqual(["EColor_COUNT"]);
+    });
+
+    it("converts qualified enum access in function parameter dimensions", () => {
+      const funcSym: IFunctionSymbol = {
+        kind: ESymbolKind.Function,
+        name: "process",
+        sourceFile: "test.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: "void",
+        visibility: "public",
+        parameters: [
+          {
+            name: "buffer",
+            type: "u8",
+            isConst: false,
+            isArray: true,
+            arrayDimensions: ["Size.MEDIUM"],
+          },
+        ],
+      };
+
+      const result = TSymbolAdapter.toISymbols([funcSym], symbolTable);
+
+      const funcResult = result.find(
+        (s) => s.kind === ESymbolKind.Function && s.name === "process",
+      );
+      expect(funcResult).toBeDefined();
+      expect(funcResult!.parameters).toBeDefined();
+      expect(funcResult!.parameters![0].arrayDimensions).toEqual([
+        "Size_MEDIUM",
+      ]);
+    });
+
+    it("passes through unqualified string dimensions as-is", () => {
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: ["DEVICE_COUNT"], // C macro passthrough
+      };
+
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
+
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym).toBeDefined();
+      expect(varSym!.arrayDimensions).toEqual(["DEVICE_COUNT"]);
+    });
+
+    it("preserves numeric array dimensions", () => {
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        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",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: ["Motor.State.COUNT"],
+      };
+
+      const result = TSymbolAdapter.toISymbols([variable], symbolTable);
+
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym!.arrayDimensions).toEqual(["Motor_State_COUNT"]);
+    });
+  });
 });

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

@@ -71,6 +71,24 @@ class TSymbolAdapter {
     return result;
   }
 
+  /**
+   * 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): string {
+    if (typeof dim === "number") {
+      return String(dim);
+    }
+
+    // Qualified enum access (e.g., "EColor.COUNT") - convert dots to underscores
+    if (dim.includes(".")) {
+      return dim.replaceAll(".", "_");
+    }
+
+    // Pass through as-is (C macros, other identifiers)
+    return dim;
+  }
+
   /**
    * Convert IBitmapSymbol to ISymbol + BitmapField symbols.
    */
@@ -180,6 +198,7 @@ class TSymbolAdapter {
 
   /**
    * Convert IFunctionSymbol to ISymbol + parameter symbols for hover support.
+   * Converts qualified enum names in parameter array dimensions.
    */
   private static convertFunction(func: IFunctionSymbol): ISymbol[] {
     const result: ISymbol[] = [];
@@ -194,7 +213,9 @@ class TSymbolAdapter {
       type: p.type,
       isConst: p.isConst,
       isArray: p.isArray,
-      arrayDimensions: p.arrayDimensions,
+      arrayDimensions: p.arrayDimensions?.map((dim) =>
+        TSymbolAdapter.resolveArrayDimension(dim),
+      ),
       isAutoConst: p.isAutoConst,
     }));
 
@@ -233,10 +254,13 @@ class TSymbolAdapter {
 
   /**
    * Convert IVariableSymbol to ISymbol.
+   * Converts qualified enum names in array dimensions.
    */
   private static convertVariable(variable: IVariableSymbol): ISymbol {
-    // Convert dimensions to string dimensions for ISymbol
-    const arrayDimensions = variable.arrayDimensions?.map(String);
+    // Convert dimensions to string dimensions
+    const arrayDimensions = variable.arrayDimensions?.map((dim) =>
+      TSymbolAdapter.resolveArrayDimension(dim),
+    );
 
     // Get first dimension for legacy size field (only if numeric)
     const firstDim = variable.arrayDimensions?.[0];