c-next 0.1.66 → 0.1.67

package/src/transpiler/{output/codegen → state}/CodeGenState.ts

@@ -5,26 +5,31 @@
  * Eliminates dependency injection complexity and makes debugging easier.
  *
  * Usage:
- *   import CodeGenState from "./CodeGenState";
+ *   import CodeGenState from "../state/CodeGenState";
  *   const type = CodeGenState.typeRegistry.get(name);
  *   if (CodeGenState.isKnownStruct(name)) { ... }
  *
  * Lifecycle:
  *   1. CodeGenerator.generate() calls CodeGenState.reset()
- *   2. CodeGenerator populates state during initialization
+ *   2. CodeGenerator sets CodeGenState.generator = this
  *   3. All generators/helpers read from CodeGenState directly
  *   4. State persists for the duration of one generate() call
+ *
+ * SymbolTable ownership:
+ *   CodeGenState owns the single SymbolTable instance. It persists across
+ *   reset() calls (which are per-file). The Transpiler clears it via
+ *   CodeGenState.symbolTable.clear() at the start of each run().
  */
 
-import SymbolTable from "../../logic/symbols/SymbolTable";
-import ICodeGenSymbols from "../../types/ICodeGenSymbols";
-import TTypeInfo from "./types/TTypeInfo";
-import TParameterInfo from "./types/TParameterInfo";
-import IFunctionSignature from "./types/IFunctionSignature";
-import ICallbackTypeInfo from "./types/ICallbackTypeInfo";
-import ITargetCapabilities from "./types/ITargetCapabilities";
-import TOverflowBehavior from "./types/TOverflowBehavior";
-import TYPE_WIDTH from "./types/TYPE_WIDTH";
+import SymbolTable from "../logic/symbols/SymbolTable";
+import ICodeGenSymbols from "../types/ICodeGenSymbols";
+import TTypeInfo from "../output/codegen/types/TTypeInfo";
+import TParameterInfo from "../output/codegen/types/TParameterInfo";
+import IFunctionSignature from "../output/codegen/types/IFunctionSignature";
+import ICallbackTypeInfo from "../output/codegen/types/ICallbackTypeInfo";
+import ITargetCapabilities from "../output/codegen/types/ITargetCapabilities";
+import TOverflowBehavior from "../output/codegen/types/TOverflowBehavior";
+import TYPE_WIDTH from "../output/codegen/types/TYPE_WIDTH";
 
 /**
  * Default target capabilities (safe fallback)
@@ -62,6 +67,16 @@ interface ICallGraphEntry {
  * during code generation.
  */
 export default class CodeGenState {
+  // ===========================================================================
+  // GENERATOR REFERENCE (for handler access)
+  // ===========================================================================
+
+  /**
+   * Reference to the CodeGenerator instance for handlers to call methods.
+   * Typed as unknown to avoid circular dependencies - handlers cast as needed.
+   */
+  static generator: unknown = null;
+
   // ===========================================================================
   // SYMBOL DATA (read-only after initialization)
   // ===========================================================================
@@ -69,8 +84,11 @@ export default class CodeGenState {
   /** ADR-055: Pre-collected symbol info from CNextResolver + TSymbolInfoAdapter */
   static symbols: ICodeGenSymbols | null = null;
 
-  /** External symbol table for cross-language interop (C headers) */
-  static symbolTable: SymbolTable | null = null;
+  /** External symbol table for cross-language interop (C headers).
+   * Owned by CodeGenState; persists across per-file reset() calls.
+   * Cleared via symbolTable.clear() at the start of each Transpiler run.
+   */
+  static symbolTable: SymbolTable = new SymbolTable();
 
   // ===========================================================================
   // TYPE TRACKING
@@ -277,9 +295,13 @@ export default class CodeGenState {
    * Called at the start of CodeGenerator.generate()
    */
   static reset(targetCapabilities?: ITargetCapabilities): void {
+    // Generator reference
+    this.generator = null;
+
     // Symbol data
     this.symbols = null;
-    this.symbolTable = null;
+    // Note: symbolTable is NOT reset here — it persists across per-file generates.
+    // It is cleared via symbolTable.clear() at the start of each Transpiler run.
 
     // Type tracking
     this.typeRegistry = new Map();
@@ -388,7 +410,7 @@ export default class CodeGenState {
   static isKnownStruct(name: string): boolean {
     if (this.symbols?.knownStructs.has(name)) return true;
     if (this.symbols?.knownBitmaps.has(name)) return true;
-    if (this.symbolTable?.getStructFields?.(name)) return true;
+    if (this.symbolTable.getStructFields(name)) return true;
     return false;
   }
 
@@ -553,17 +575,15 @@ export default class CodeGenState {
     fieldName: string,
   ): { type: string; dimensions?: (number | string)[] } | null {
     // First check SymbolTable (C header structs)
-    if (this.symbolTable) {
-      const fieldInfo = this.symbolTable.getStructFieldInfo(
-        structType,
-        fieldName,
-      );
-      if (fieldInfo) {
-        return {
-          type: fieldInfo.type,
-          dimensions: fieldInfo.arrayDimensions,
-        };
-      }
+    const fieldInfo = this.symbolTable.getStructFieldInfo(
+      structType,
+      fieldName,
+    );
+    if (fieldInfo) {
+      return {
+        type: fieldInfo.type,
+        dimensions: fieldInfo.arrayDimensions,
+      };
     }
 
     // Fall back to local C-Next struct fields

package/src/transpiler/{output/codegen → state}/__tests__/CodeGenState.test.ts

@@ -4,8 +4,8 @@
 
 import { describe, it, expect, beforeEach } from "vitest";
 import CodeGenState from "../CodeGenState";
-import TTypeInfo from "../types/TTypeInfo";
-import ICodeGenSymbols from "../../../types/ICodeGenSymbols";
+import TTypeInfo from "../../output/codegen/types/TTypeInfo";
+import ICodeGenSymbols from "../../types/ICodeGenSymbols";
 
 /**
  * Create a minimal mock ICodeGenSymbols with default empty collections.
@@ -76,6 +76,16 @@ describe("CodeGenState", () => {
       expect(CodeGenState.indentLevel).toBe(0);
     });
 
+    it("resets generator reference", () => {
+      // Simulate having a generator set
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      CodeGenState.generator = {} as any;
+
+      CodeGenState.reset();
+
+      expect(CodeGenState.generator).toBeNull();
+    });
+
     it("accepts custom target capabilities", () => {
       const customTarget = {
         hasFPU: true,

package/src/transpiler/output/codegen/assignment/handlers/IHandlerDeps.ts

@@ -1,161 +0,0 @@
-/**
- * Dependencies provided to assignment handlers (ADR-109).
- *
- * Handlers need access to various CodeGenerator capabilities without
- * taking a direct dependency on the full CodeGenerator class. This
- * interface defines the subset of functionality handlers need.
- */
-import * as Parser from "../../../../logic/parser/grammar/CNextParser";
-import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
-import TTypeInfo from "../../types/TTypeInfo";
-import ITargetCapabilities from "../../types/ITargetCapabilities";
-
-/**
- * Dependencies for assignment handlers.
- *
- * These are provided by CodeGenerator to enable handlers to:
- * - Look up type information
- * - Access symbol tables
- * - Generate expressions
- * - Track side effects (needsString, clampOps)
- */
-interface IHandlerDeps {
-  // === Symbol information ===
-
-  /** Read-only symbol info (registers, bitmaps, structs, etc.) */
-  readonly symbols: ICodeGenSymbols;
-
-  /** Type registry: variable name -> type info */
-  readonly typeRegistry: ReadonlyMap<string, TTypeInfo>;
-
-  /** Current scope name (for this.* resolution), null if not in scope */
-  readonly currentScope: string | null;
-
-  /** Parameters of current function */
-  readonly currentParameters: ReadonlyMap<
-    string,
-    { isStruct?: boolean; isArray?: boolean }
-  >;
-
-  /** Target platform capabilities */
-  readonly targetCapabilities: ITargetCapabilities;
-
-  // === Expression generation ===
-
-  /**
-   * Generate C code for an expression.
-   */
-  generateExpression(ctx: Parser.ExpressionContext): string;
-
-  /**
-   * Try to evaluate an expression as a compile-time constant.
-   * Returns undefined if not a constant.
-   */
-  tryEvaluateConstant(ctx: Parser.ExpressionContext): number | undefined;
-
-  /**
-   * Generate the C target string for an assignment target.
-   */
-  generateAssignmentTarget(ctx: Parser.AssignmentTargetContext): string;
-
-  // === Type checking ===
-
-  /**
-   * Check if a type name is a known struct.
-   */
-  isKnownStruct(typeName: string): boolean;
-
-  /**
-   * Check if a name is a known scope.
-   */
-  isKnownScope(name: string): boolean;
-
-  /**
-   * Get member type info for a struct field.
-   */
-  getMemberTypeInfo(structType: string, memberName: string): TTypeInfo | null;
-
-  // === Validation ===
-
-  /**
-   * Validate bitmap field literal fits in field width.
-   */
-  validateBitmapFieldLiteral(
-    expr: Parser.ExpressionContext,
-    width: number,
-    fieldName: string,
-  ): void;
-
-  /**
-   * Validate cross-scope visibility for member access.
-   */
-  validateCrossScopeVisibility(scopeName: string, memberName: string): void;
-
-  /**
-   * Check array bounds for compile-time constant indices.
-   */
-  checkArrayBounds(
-    arrayName: string,
-    dimensions: readonly number[],
-    indexExprs: readonly Parser.ExpressionContext[],
-    line: number,
-  ): void;
-
-  /**
-   * Analyze a member chain target for bit access.
-   * Returns { isBitAccess: false } if not bit access.
-   * Returns { isBitAccess: true, baseTarget, bitIndex, baseType } if bit access detected.
-   */
-  analyzeMemberChainForBitAccess(targetCtx: Parser.AssignmentTargetContext): {
-    isBitAccess: boolean;
-    baseTarget?: string;
-    bitIndex?: string;
-    baseType?: string;
-  };
-
-  // === Float bit indexing ===
-
-  /**
-   * Generate float bit write using shadow variable + memcpy.
-   * Returns the full statement for writing bits to a float variable.
-   * Returns null if typeInfo is not a float type.
-   */
-  generateFloatBitWrite(
-    name: string,
-    typeInfo: TTypeInfo,
-    bitIndex: string,
-    width: string | null,
-    value: string,
-  ): string | null;
-
-  /**
-   * Convert boolean expression to integer: true -> "1", false -> "0", else "(expr ? 1 : 0)"
-   */
-  foldBooleanToInt(expr: string): string;
-
-  // === Side effects ===
-
-  /**
-   * Mark that string.h is needed (for strncpy, memcpy).
-   */
-  markNeedsString(): void;
-
-  /**
-   * Mark that a clamp operation helper is used.
-   */
-  markClampOpUsed(op: string, typeName: string): void;
-
-  // === Atomic operations ===
-
-  /**
-   * Generate atomic read-modify-write operation.
-   */
-  generateAtomicRMW(
-    target: string,
-    cOp: string,
-    value: string,
-    typeInfo: TTypeInfo,
-  ): string;
-}
-
-export default IHandlerDeps;