c-next 0.1.66 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "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";
@@ -53,7 +53,6 @@ import ITranspileError from "../lib/types/ITranspileError";
 import TranspilerState from "./types/TranspilerState";
 import runAnalyzers from "./logic/analysis/runAnalyzers";
 import ModificationAnalyzer from "./logic/analysis/ModificationAnalyzer";
-import AnalyzerContextBuilder from "./logic/analysis/AnalyzerContextBuilder";
 import CacheManager from "../utils/cache/CacheManager";
 import MapUtils from "../utils/MapUtils";
 import detectCppSyntax from "./logic/detectCppSyntax";
@@ -65,7 +64,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 +106,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();
@@ -249,7 +246,7 @@ class Transpiler {
    *
    * Both run() and transpileSource() delegate here after file discovery.
    *
-   * Stage 2: Collect symbols from C/C++ headers
+   * Stage 2: Collect symbols from C/C++ headers (includes building analyzer context)
    * Stage 3: Collect symbols from C-Next files
    * Stage 3b: Resolve external const array dimensions
    * Stage 4: Check for symbol conflicts
@@ -260,8 +257,9 @@ class Transpiler {
     input: IPipelineInput,
     result: ITranspilerResult,
   ): Promise<void> {
-    // Stage 2: Collect symbols from C/C++ headers
+    // Stage 2: Collect symbols from C/C++ headers and build analyzer context
     this._collectAllHeaderSymbols(input.headerFiles, result);
+    CodeGenState.buildExternalStructFields();
 
     // Stage 3: Collect symbols from C-Next files
     if (!this._collectAllCNextSymbolsFromPipeline(input.cnextFiles, result)) {
@@ -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);
@@ -394,14 +395,8 @@ class Transpiler {
         return this.buildParseOnlyResult(sourcePath, declarationCount);
       }
 
-      // Run analyzers
-      const externalStructFields =
-        AnalyzerContextBuilder.buildExternalStructFields(this.symbolTable);
-
-      const analyzerErrors = runAnalyzers(tree, tokenStream, {
-        externalStructFields,
-        symbolTable: this.symbolTable,
-      });
+      // Run analyzers (reads externalStructFields and symbolTable from CodeGenState)
+      const analyzerErrors = runAnalyzers(tree, tokenStream);
       if (analyzerErrors.length > 0) {
         return this.buildErrorResult(
           sourcePath,
@@ -430,18 +425,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 +451,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 +461,6 @@ class Transpiler {
       const headerCode = this.generateHeaderContent(
         symbols,
         sourcePath,
-        this.symbolTable,
         this.cppDetected,
         userIncludes,
         passByValueCopy,
@@ -631,7 +620,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 +657,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 +740,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 +1029,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 +1057,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 +1134,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 +1151,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 +1168,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 +1199,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 +1274,6 @@ class Transpiler {
   private generateHeaderContent(
     symbols: ISymbol[],
     sourcePath: string,
-    symbolTable: SymbolTable,
     cppMode: boolean,
     userIncludes: string[],
     passByValueParams: Map<string, Set<string>>,
@@ -1318,12 +1317,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 +1428,7 @@ class Transpiler {
    * Get the symbol table (for testing/inspection)
    */
   getSymbolTable(): SymbolTable {
-    return this.symbolTable;
+    return CodeGenState.symbolTable;
   }
 
   /**

package/src/transpiler/logic/analysis/InitializationAnalyzer.ts

@@ -21,6 +21,7 @@ import ExpressionUtils from "../../../utils/ExpressionUtils";
 import ParserUtils from "../../../utils/ParserUtils";
 import analyzePostfixOps from "../../../utils/PostfixAnalysisUtils";
 import SymbolTable from "../symbols/SymbolTable";
+import CodeGenState from "../../state/CodeGenState";
 import ESourceLanguage from "../../../utils/types/ESourceLanguage";
 import ESymbolKind from "../../../utils/types/ESymbolKind";
 
@@ -408,8 +409,11 @@ class InitializationAnalyzer {
 
   private scopeStack: ScopeStack<IVariableState> = new ScopeStack();
 
-  /** Known struct types and their fields */
-  private readonly structFields: Map<string, Set<string>> = new Map();
+  /**
+   * C-Next struct fields from current file (collected at analysis time).
+   * External struct fields from C/C++ headers are accessed via CodeGenState.
+   */
+  private cnextStructFields: Map<string, Set<string>> = new Map();
 
   /** Track if we're processing a write target (left side of assignment) */
   private inWriteContext: boolean = false;
@@ -418,17 +422,25 @@ class InitializationAnalyzer {
   private symbolTable: SymbolTable | null = null;
 
   /**
-   * Register external struct fields from C/C++ headers
-   * This allows the analyzer to recognize types defined in headers
-   *
-   * @param externalFields Map of struct name -> Set of field names
+   * Get struct fields for a given struct type.
+   * Checks C-Next structs first, then falls back to CodeGenState for external structs.
    */
-  public registerExternalStructFields(
-    externalFields: Map<string, Set<string>>,
-  ): void {
-    for (const [structName, fields] of externalFields) {
-      this.structFields.set(structName, fields);
+  private getStructFields(structName: string): Set<string> | undefined {
+    // Check C-Next structs from current file first
+    const cnextFields = this.cnextStructFields.get(structName);
+    if (cnextFields) {
+      return cnextFields;
     }
+
+    // Check external structs from CodeGenState
+    return CodeGenState.getExternalStructFields().get(structName);
+  }
+
+  /**
+   * Check if a type name is a known struct.
+   */
+  private isKnownStruct(typeName: string): boolean {
+    return this.getStructFields(typeName) !== undefined;
   }
 
   /**
@@ -469,9 +481,10 @@ class InitializationAnalyzer {
     this.errors = [];
     this.scopeStack = new ScopeStack();
     this.symbolTable = symbolTable ?? null;
-    // Don't clear structFields - external fields may have been registered
+    // Clear C-Next struct fields from previous analysis (external fields come from CodeGenState)
+    this.cnextStructFields = new Map();
 
-    // First pass: collect struct definitions
+    // First pass: collect struct definitions from current file
     this.collectStructDefinitions(tree);
 
     // Create global scope with all global/namespace variable declarations
@@ -553,7 +566,8 @@ class InitializationAnalyzer {
   }
 
   /**
-   * Collect struct definitions to know their fields
+   * Collect struct definitions from current file to know their fields.
+   * This supplements the external struct fields from CodeGenState.
    */
   private collectStructDefinitions(tree: Parser.ProgramContext): void {
     for (const decl of tree.declaration()) {
@@ -567,7 +581,7 @@ class InitializationAnalyzer {
           fields.add(fieldName);
         }
 
-        this.structFields.set(structName, fields);
+        this.cnextStructFields.set(structName, fields);
       }
     }
   }
@@ -610,9 +624,9 @@ class InitializationAnalyzer {
       this.enterScope();
     }
 
-    const isStruct = typeName !== null && this.structFields.has(typeName);
+    const isStruct = typeName !== null && this.isKnownStruct(typeName);
     const fields = isStruct
-      ? this.structFields.get(typeName)!
+      ? this.getStructFields(typeName)!
       : new Set<string>();
 
     // Issue #503: C++ classes with default constructors are automatically initialized
@@ -637,13 +651,11 @@ class InitializationAnalyzer {
    * SonarCloud S3776: Refactored to use helper methods.
    */
   public recordAssignment(name: string, field?: string): void {
-    const structFields = this.structFields;
-
     this.scopeStack.update(name, (state) => {
       if (field) {
-        this.recordFieldAssignment(state, field, structFields);
+        this.recordFieldAssignment(state, field);
       } else {
-        this.recordWholeAssignment(state, structFields);
+        this.recordWholeAssignment(state);
       }
       return state;
     });
@@ -652,16 +664,12 @@ class InitializationAnalyzer {
   /**
    * Handle field-level assignment.
    */
-  private recordFieldAssignment(
-    state: IVariableState,
-    field: string,
-    structFields: Map<string, Set<string>>,
-  ): void {
+  private recordFieldAssignment(state: IVariableState, field: string): void {
     state.initializedFields.add(field);
     // Check if all fields are now initialized
     if (!state.isStruct || !state.typeName) return;
 
-    const allFields = structFields.get(state.typeName);
+    const allFields = this.getStructFields(state.typeName);
     if (!allFields) return;
 
     const allInitialized = [...allFields].every((f) =>
@@ -675,15 +683,12 @@ class InitializationAnalyzer {
   /**
    * Handle whole-variable assignment.
    */
-  private recordWholeAssignment(
-    state: IVariableState,
-    structFields: Map<string, Set<string>>,
-  ): void {
+  private recordWholeAssignment(state: IVariableState): void {
     state.initialized = true;
     // Mark all fields as initialized too
     if (!state.isStruct || !state.typeName) return;
 
-    const fields = structFields.get(state.typeName);
+    const fields = this.getStructFields(state.typeName);
     if (fields) {
       state.initializedFields = new Set(fields);
     }
@@ -745,8 +750,8 @@ class InitializationAnalyzer {
     field: string,
     state: IVariableState,
   ): void {
-    const structFields = this.structFields.get(state.typeName!);
-    if (!structFields?.has(field)) return;
+    const structFieldSet = this.getStructFields(state.typeName!);
+    if (!structFieldSet?.has(field)) return;
 
     if (!state.initializedFields.has(field)) {
       this.addError(`${name}.${field}`, line, column, state.declaration, false);
@@ -874,9 +879,9 @@ class InitializationAnalyzer {
       this.enterScope();
     }
 
-    const isStruct = typeName !== null && this.structFields.has(typeName);
+    const isStruct = typeName !== null && this.isKnownStruct(typeName);
     const fields = isStruct
-      ? this.structFields.get(typeName)!
+      ? this.getStructFields(typeName)!
       : new Set<string>();
 
     const state: IVariableState = {

package/src/transpiler/logic/analysis/__tests__/InitializationAnalyzer.test.ts

@@ -4,11 +4,12 @@
  */
 
 import { CharStream, CommonTokenStream } from "antlr4ng";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import { CNextLexer } from "../../parser/grammar/CNextLexer";
 import { CNextParser } from "../../parser/grammar/CNextParser";
 import InitializationAnalyzer from "../InitializationAnalyzer";
 import SymbolTable from "../../symbols/SymbolTable";
+import CodeGenState from "../../../state/CodeGenState";
 import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
@@ -24,6 +25,12 @@ function parse(source: string) {
 }
 
 describe("InitializationAnalyzer", () => {
+  // Reset CodeGenState before each test
+  beforeEach(() => {
+    CodeGenState.reset();
+    CodeGenState.symbolTable.clear();
+  });
+
   // ========================================================================
   // Issue #503: C++ Class Initialization
   // ========================================================================
@@ -38,9 +45,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C++ class
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C++ class
+      CodeGenState.symbolTable.addSymbol({
         name: "CppMessage",
         kind: ESymbolKind.Class,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -49,14 +55,13 @@ describe("InitializationAnalyzer", () => {
         isExported: true,
       });
       // Add the field so the analyzer knows about it
-      symbolTable.addStructField("CppMessage", "pgn", "u16");
+      CodeGenState.symbolTable.addStructField("CppMessage", "pgn", "u16");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CppMessage", new Set(["pgn"])]]),
-      );
+      // Build external struct fields from symbol table
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // Should have NO errors - C++ class is initialized by constructor
       expect(errors).toHaveLength(0);
@@ -95,9 +100,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C++ struct (not class)
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C++ struct (not class)
+      CodeGenState.symbolTable.addSymbol({
         name: "CppStruct",
         kind: ESymbolKind.Struct,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -105,14 +109,13 @@ describe("InitializationAnalyzer", () => {
         sourceLine: 1,
         isExported: true,
       });
-      symbolTable.addStructField("CppStruct", "value", "u32");
+      CodeGenState.symbolTable.addStructField("CppStruct", "value", "u32");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CppStruct", new Set(["value"])]]),
-      );
+      // Build external struct fields from symbol table
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // Should have NO errors - C++ structs also have default constructors
       expect(errors).toHaveLength(0);
@@ -127,9 +130,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C struct (not C++)
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C struct (not C++)
+      CodeGenState.symbolTable.addSymbol({
         name: "CStruct",
         kind: ESymbolKind.Struct,
         sourceLanguage: ESourceLanguage.C,
@@ -137,14 +139,13 @@ describe("InitializationAnalyzer", () => {
         sourceLine: 1,
         isExported: true,
       });
-      symbolTable.addStructField("CStruct", "value", "u32");
+      CodeGenState.symbolTable.addStructField("CStruct", "value", "u32");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CStruct", new Set(["value"])]]),
-      );
+      // Build external struct fields from symbol table (as pipeline does)
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // SHOULD have an error - C structs don't have constructors
       expect(errors.length).toBeGreaterThan(0);