c-next 0.1.67 → 0.1.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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

@@ -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";
@@ -247,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
@@ -258,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)) {
@@ -395,16 +395,8 @@ class Transpiler {
         return this.buildParseOnlyResult(sourcePath, declarationCount);
       }
 
-      // Run analyzers
-      const externalStructFields =
-        AnalyzerContextBuilder.buildExternalStructFields(
-          CodeGenState.symbolTable,
-        );
-
-      const analyzerErrors = runAnalyzers(tree, tokenStream, {
-        externalStructFields,
-        symbolTable: CodeGenState.symbolTable,
-      });
+      // Run analyzers (reads externalStructFields and symbolTable from CodeGenState)
+      const analyzerErrors = runAnalyzers(tree, tokenStream);
       if (analyzerErrors.length > 0) {
         return this.buildErrorResult(
           sourcePath,

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);

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

@@ -2,12 +2,13 @@
  * Unit tests for runAnalyzers
  * Tests that all 8 analyzers run in sequence with early returns on errors
  */
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { CharStream, CommonTokenStream } from "antlr4ng";
 import { CNextLexer } from "../../parser/grammar/CNextLexer";
 import { CNextParser } from "../../parser/grammar/CNextParser";
 import runAnalyzers from "../runAnalyzers";
 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 parseWithStream(source: string) {
 }
 
 describe("runAnalyzers", () => {
+  // Reset CodeGenState before each test
+  beforeEach(() => {
+    CodeGenState.reset();
+    CodeGenState.symbolTable.clear();
+  });
+
   // ========================================================================
   // Happy Path
   // ========================================================================
@@ -206,24 +213,33 @@ describe("runAnalyzers", () => {
   });
 
   // ========================================================================
-  // Options: externalStructFields and symbolTable
+  // Options: CodeGenState integration and symbolTable
   // ========================================================================
 
   describe("options", () => {
-    it("should pass externalStructFields to InitializationAnalyzer", () => {
-      // Code that uses a field from an external struct - the externalStructFields
-      // option tells the analyzer about external struct types
+    it("should read externalStructFields from CodeGenState", () => {
+      // Code that uses a field from an external struct - externalStructFields
+      // are now read from CodeGenState
       const { tree, tokenStream } = parseWithStream(`
         void main() {
           u32 x <- 5;
         }
       `);
 
-      const externalStructFields = new Map<string, Set<string>>([
-        ["ExternalStruct", new Set(["field1", "field2"])],
-      ]);
+      // Set up external struct fields in CodeGenState
+      CodeGenState.symbolTable.addStructField(
+        "ExternalStruct",
+        "field1",
+        "u32",
+      );
+      CodeGenState.symbolTable.addStructField(
+        "ExternalStruct",
+        "field2",
+        "u32",
+      );
+      CodeGenState.buildExternalStructFields();
 
-      const errors = runAnalyzers(tree, tokenStream, { externalStructFields });
+      const errors = runAnalyzers(tree, tokenStream);
       expect(errors).toHaveLength(0);
     });
 
@@ -248,18 +264,15 @@ describe("runAnalyzers", () => {
       expect(errors).toHaveLength(0);
     });
 
-    it("should pass both options together", () => {
+    it("should use CodeGenState.symbolTable by default", () => {
       const { tree, tokenStream } = parseWithStream(`
         void main() {
           u32 x <- 5;
         }
       `);
 
-      const externalStructFields = new Map<string, Set<string>>([
-        ["CppMessage", new Set(["pgn"])],
-      ]);
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up C++ class in CodeGenState.symbolTable
+      CodeGenState.symbolTable.addSymbol({
         name: "CppMessage",
         kind: ESymbolKind.Class,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -267,11 +280,11 @@ describe("runAnalyzers", () => {
         sourceLine: 1,
         isExported: true,
       });
+      CodeGenState.symbolTable.addStructField("CppMessage", "pgn", "u16");
+      CodeGenState.buildExternalStructFields();
 
-      const errors = runAnalyzers(tree, tokenStream, {
-        externalStructFields,
-        symbolTable,
-      });
+      // No options passed - should use CodeGenState.symbolTable
+      const errors = runAnalyzers(tree, tokenStream);
       expect(errors).toHaveLength(0);
     });
   });

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

@@ -17,20 +17,16 @@ import FloatModuloAnalyzer from "./FloatModuloAnalyzer";
 import CommentExtractor from "./CommentExtractor";
 import ITranspileError from "../../../lib/types/ITranspileError";
 import SymbolTable from "../symbols/SymbolTable";
+import CodeGenState from "../../state/CodeGenState";
 
 /**
  * Options for running analyzers
  */
 interface IAnalyzerOptions {
-  /**
-   * External struct field information from C/C++ headers
-   * Maps struct name -> Set of field names
-   */
-  externalStructFields?: Map<string, Set<string>>;
-
   /**
    * Symbol table containing external function definitions from C/C++ headers
-   * Used by FunctionCallAnalyzer to recognize external functions
+   * Used by FunctionCallAnalyzer to recognize external functions.
+   * Falls back to CodeGenState.symbolTable if not provided.
    */
   symbolTable?: SymbolTable;
 }
@@ -100,13 +96,11 @@ function runAnalyzers(
 
   // 3. Initialization analysis (Rust-style use-before-init detection)
   const initAnalyzer = new InitializationAnalyzer();
-  if (options?.externalStructFields) {
-    initAnalyzer.registerExternalStructFields(options.externalStructFields);
-  }
-  // Issue #503: Pass symbol table so C++ classes with default constructors are recognized
+  // External struct fields and symbolTable are read from CodeGenState directly
+  const symbolTable = options?.symbolTable ?? CodeGenState.symbolTable;
   if (
     collectErrors(
-      initAnalyzer.analyze(tree, options?.symbolTable),
+      initAnalyzer.analyze(tree, symbolTable),
       errors,
       formatWithCode,
     )
@@ -115,10 +109,10 @@ function runAnalyzers(
   }
 
   // 4. Call analysis (ADR-030: define-before-use)
-  const funcAnalyzer = new FunctionCallAnalyzer();
+  const callAnalyzer = new FunctionCallAnalyzer();
   if (
     collectErrors(
-      funcAnalyzer.analyze(tree, options?.symbolTable),
+      callAnalyzer.analyze(tree, symbolTable),
       errors,
       formatWithCode,
     )