c-next 0.1.69 → 0.1.71

package/src/transpiler/state/CodeGenState.ts

@@ -30,6 +30,7 @@ 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";
+import TypeResolver from "../../utils/TypeResolver";
 
 /**
  * Default target capabilities (safe fallback)
@@ -101,8 +102,12 @@ export default class CodeGenState {
   // TYPE TRACKING
   // ===========================================================================
 
-  /** Track variable types for bit access, .length, and type inference */
-  static typeRegistry: Map<string, TTypeInfo> = new Map();
+  /**
+   * Track variable types for bit access, .length, and type inference.
+   * PRIVATE: Use getVariableTypeInfo()/setVariableTypeInfo() instead.
+   * This ensures cross-file variables from SymbolTable are also found.
+   */
+  private static typeRegistry: Map<string, TTypeInfo> = new Map();
 
   /** Bug #8: Compile-time const values for array size resolution */
   static constValues: Map<string, number> = new Map();
@@ -451,9 +456,109 @@ export default class CodeGenState {
 
   /**
    * Get type info for a variable.
+   * Checks local typeRegistry first, then falls back to SymbolTable
+   * for cross-file variables from included .cnx files.
+   *
+   * Issue #786: This unified lookup ensures cross-file variables
+   * (defined in included files) are found even before code generation
+   * registers them locally.
+   */
+  static getVariableTypeInfo(name: string): TTypeInfo | undefined {
+    // First check the local type registry (current file's variables)
+    const localInfo = this.typeRegistry.get(name);
+    if (localInfo) {
+      return localInfo;
+    }
+
+    // ADR-055 Phase 7: Fall back to SymbolTable for cross-file C-Next variables only.
+    // C/C++ header symbols don't have complete type info (e.g., isArray),
+    // so we only use C-Next TSymbols from SymbolTable.
+    const symbol = this.symbolTable.getTSymbol(name);
+    if (symbol?.kind === "variable" && symbol.type) {
+      return this.convertTSymbolToTypeInfo(symbol);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Legacy alias for getVariableTypeInfo.
+   * @deprecated Use getVariableTypeInfo() instead
    */
   static getTypeInfo(name: string): TTypeInfo | undefined {
-    return this.typeRegistry.get(name);
+    return this.getVariableTypeInfo(name);
+  }
+
+  /**
+   * Check if a variable type is registered (locally or in SymbolTable).
+   * ADR-055 Phase 7: Uses getTSymbol for typed symbol lookup.
+   */
+  static hasVariableTypeInfo(name: string): boolean {
+    if (this.typeRegistry.has(name)) {
+      return true;
+    }
+    const symbol = this.symbolTable.getTSymbol(name);
+    return symbol?.kind === "variable" && symbol.type !== undefined;
+  }
+
+  /**
+   * Set variable type info in the local registry.
+   */
+  static setVariableTypeInfo(name: string, info: TTypeInfo): void {
+    this.typeRegistry.set(name, info);
+  }
+
+  /**
+   * Delete variable type info from the local registry.
+   */
+  static deleteVariableTypeInfo(name: string): void {
+    this.typeRegistry.delete(name);
+  }
+
+  /**
+   * Get a read-only view of the local type registry.
+   * Used for passing to helper functions that need to iterate over types.
+   * Note: This only returns locally registered types, not cross-file symbols.
+   */
+  static getTypeRegistryView(): ReadonlyMap<string, TTypeInfo> {
+    return this.typeRegistry;
+  }
+
+  /**
+   * Convert a TSymbol IVariableSymbol to TTypeInfo for unified type lookups.
+   * ADR-055 Phase 7: Works with typed TSymbol instead of ISymbol.
+   */
+  private static convertTSymbolToTypeInfo(
+    symbol: import("../types/symbols/IVariableSymbol").default,
+  ): TTypeInfo {
+    const typeName = TypeResolver.getTypeName(symbol.type);
+
+    // Parse string capacity using regex
+    const stringPattern = /^string<(\d+)>$/;
+    const stringMatch = stringPattern.exec(typeName);
+    const isString = stringMatch !== null;
+    const stringCapacity = stringMatch
+      ? Number.parseInt(stringMatch[1], 10)
+      : undefined;
+    // Use char for string types to match local convention
+    const baseType = isString ? "char" : typeName;
+
+    const isEnum = this.isKnownEnum(baseType);
+
+    return {
+      baseType,
+      bitWidth: isString ? 8 : TYPE_WIDTH[baseType] || 0,
+      isArray: symbol.isArray || false,
+      arrayDimensions: symbol.arrayDimensions
+        ?.map((d) => (typeof d === "number" ? d : Number.parseInt(d, 10)))
+        .filter((n) => !Number.isNaN(n)),
+      isConst: symbol.isConst || false,
+      isAtomic: symbol.isAtomic || false,
+      isEnum,
+      enumTypeName: isEnum ? baseType : undefined,
+      isString,
+      stringCapacity,
+    };
   }
 
   /**
@@ -785,7 +890,7 @@ export default class CodeGenState {
    * Register a variable type.
    */
   static registerType(name: string, info: TTypeInfo): void {
-    this.typeRegistry.set(name, info);
+    this.setVariableTypeInfo(name, info);
   }
 
   /**

package/src/transpiler/state/SymbolRegistry.ts

@@ -0,0 +1,181 @@
+/**
+ * SymbolRegistry - Central registry for C-Next symbol management
+ *
+ * Provides centralized storage and lookup for all symbols in the C-Next transpiler.
+ *
+ * Design decisions:
+ * - Static class with global state (reset between transpilation runs)
+ * - `getOrCreateScope` handles scope merging across files (same scope name = same object)
+ * - `resolveFunction` walks scope chain (current -> parent -> global)
+ * - String keys in Maps for lookup, but values are proper symbol objects
+ */
+import ScopeUtils from "../../utils/ScopeUtils";
+import type IScopeSymbol from "../types/symbols/IScopeSymbol";
+import type IFunctionSymbol from "../types/symbols/IFunctionSymbol";
+
+class SymbolRegistry {
+  /** The global scope singleton (recreated on reset) */
+  private static globalScope: IScopeSymbol = ScopeUtils.createGlobalScope();
+
+  /** Map from scope path (e.g., "Outer.Inner") to scope object */
+  private static readonly scopes: Map<string, IScopeSymbol> = new Map();
+
+  // ============================================================================
+  // Scope Management
+  // ============================================================================
+
+  /**
+   * Get the global scope singleton.
+   *
+   * The global scope has:
+   * - name: "" (empty string)
+   * - parent: points to itself (self-reference)
+   */
+  static getGlobalScope(): IScopeSymbol {
+    return this.globalScope;
+  }
+
+  /**
+   * Get a scope by its dotted path without creating it.
+   *
+   * Use this for read-only lookups where you don't want to create
+   * orphaned scopes. Returns null if the scope doesn't exist.
+   */
+  static getScope(path: string): IScopeSymbol | null {
+    if (path === "") return this.globalScope;
+    return this.scopes.get(path) ?? null;
+  }
+
+  /**
+   * Get or create a scope by its dotted path.
+   *
+   * For simple names (e.g., "Test"), creates scope with global parent.
+   * For dotted paths (e.g., "Outer.Inner"), creates nested scopes.
+   *
+   * If the scope already exists, returns the existing scope.
+   * This enables scope merging across files.
+   *
+   * Note: This creates scopes that don't exist. For read-only lookups,
+   * use getScope() instead to avoid creating orphaned scopes.
+   */
+  static getOrCreateScope(path: string): IScopeSymbol {
+    if (path === "") return this.globalScope;
+    if (this.scopes.has(path)) return this.scopes.get(path)!;
+
+    const parts = path.split(".");
+    const name = parts.pop()!;
+    const parentPath = parts.join(".");
+    const parent =
+      parentPath === "" ? this.globalScope : this.getOrCreateScope(parentPath);
+
+    const scope = ScopeUtils.createScope(name, parent);
+    this.scopes.set(path, scope);
+    return scope;
+  }
+
+  // ============================================================================
+  // Function Management
+  // ============================================================================
+
+  /**
+   * Register a function in its scope.
+   *
+   * The function is added to the scope's functions array.
+   */
+  static registerFunction(func: IFunctionSymbol): void {
+    func.scope.functions.push(func);
+  }
+
+  /**
+   * Resolve a function by name, walking the scope chain.
+   *
+   * Searches in order:
+   * 1. Current scope
+   * 2. Parent scope
+   * 3. Parent's parent (recursively)
+   * 4. Global scope
+   *
+   * Returns null if the function is not found.
+   */
+  static resolveFunction(
+    name: string,
+    fromScope: IScopeSymbol,
+  ): IFunctionSymbol | null {
+    // Search in current scope
+    const found = fromScope.functions.find((f) => f.name === name);
+    if (found) return found;
+
+    // Walk up the scope chain (stop when we reach global scope's self-reference)
+    if (fromScope !== this.globalScope && fromScope.parent !== fromScope) {
+      return this.resolveFunction(name, fromScope.parent);
+    }
+
+    return null;
+  }
+
+  // ============================================================================
+  // Reset
+  // ============================================================================
+
+  /**
+   * Reset all registry state.
+   *
+   * Creates a fresh global scope and clears all registered scopes.
+   * Call this between transpilation runs.
+   */
+  static reset(): void {
+    this.globalScope = ScopeUtils.createGlobalScope();
+    this.scopes.clear();
+  }
+
+  // ============================================================================
+  // Bridge Methods (for gradual migration from string-based lookups)
+  // ============================================================================
+
+  /**
+   * Find a function by its C-mangled name (e.g., "Test_fillData").
+   *
+   * This is a bridge method for gradual migration. New code should use
+   * resolveFunction() with bare names and scope references instead.
+   *
+   * @param mangledName C-mangled function name (e.g., "Test_fillData", "main")
+   * @returns The function symbol, or null if not found
+   */
+  static findByMangledName(mangledName: string): IFunctionSymbol | null {
+    // Check global scope first (no underscore = global function)
+    for (const func of this.globalScope.functions) {
+      if (func.name === mangledName) {
+        return func;
+      }
+    }
+
+    // Check all scopes - the mangled name should match scope_name pattern
+    for (const [scopePath, scope] of this.scopes) {
+      const prefix = scopePath.replaceAll(".", "_") + "_";
+      for (const func of scope.functions) {
+        if (prefix + func.name === mangledName) {
+          return func;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get the scope of a function given its C-mangled name.
+   *
+   * This is a bridge method for gradual migration.
+   *
+   * @param mangledName C-mangled function name
+   * @returns The scope the function belongs to, or null if not found
+   */
+  static getScopeByMangledFunctionName(
+    mangledName: string,
+  ): IScopeSymbol | null {
+    const func = this.findByMangledName(mangledName);
+    return func?.scope ?? null;
+  }
+}
+
+export default SymbolRegistry;

package/src/transpiler/{types → state}/TranspilerState.ts

@@ -6,7 +6,7 @@
  * and typed accessors for all accumulated data.
  */
 
-import ICodeGenSymbols from "./ICodeGenSymbols";
+import ICodeGenSymbols from "../types/ICodeGenSymbols";
 
 /**
  * Encapsulates the 6 accumulated state fields from Transpiler.

package/src/transpiler/state/__tests__/CodeGenState.test.ts

@@ -6,6 +6,53 @@ import { describe, it, expect, beforeEach } from "vitest";
 import CodeGenState from "../CodeGenState";
 import TTypeInfo from "../../output/codegen/types/TTypeInfo";
 import ICodeGenSymbols from "../../types/ICodeGenSymbols";
+import ESourceLanguage from "../../../utils/types/ESourceLanguage";
+import IVariableSymbol from "../../types/symbols/IVariableSymbol";
+import ICVariableSymbol from "../../types/symbols/c/ICVariableSymbol";
+import TestScopeUtils from "../../logic/symbols/cnext/__tests__/testUtils";
+import TTypeUtils from "../../../utils/TTypeUtils";
+
+/**
+ * Create a minimal C-Next IVariableSymbol for testing.
+ */
+function createCNextVariableSymbol(
+  overrides: Partial<IVariableSymbol> & { name: string },
+): IVariableSymbol {
+  return {
+    kind: "variable",
+    name: overrides.name,
+    sourceFile: overrides.sourceFile ?? "test.cnx",
+    sourceLine: overrides.sourceLine ?? 1,
+    sourceLanguage: ESourceLanguage.CNext,
+    isExported: overrides.isExported ?? false,
+    scope: overrides.scope ?? TestScopeUtils.createMockGlobalScope(),
+    type: overrides.type ?? TTypeUtils.createPrimitive("u32"),
+    isConst: overrides.isConst ?? false,
+    isAtomic: overrides.isAtomic ?? false,
+    isArray: overrides.isArray ?? false,
+    arrayDimensions: overrides.arrayDimensions,
+  };
+}
+
+/**
+ * Create a minimal C ICVariableSymbol for testing.
+ */
+function createCVariableSymbol(
+  overrides: Partial<ICVariableSymbol> & { name: string; type: string },
+): ICVariableSymbol {
+  return {
+    kind: "variable",
+    name: overrides.name,
+    sourceFile: overrides.sourceFile ?? "test.h",
+    sourceLine: overrides.sourceLine ?? 1,
+    sourceLanguage: ESourceLanguage.C,
+    isExported: overrides.isExported ?? false,
+    type: overrides.type,
+    isConst: overrides.isConst,
+    isArray: overrides.isArray,
+    arrayDimensions: overrides.arrayDimensions,
+  };
+}
 
 /**
  * Create a minimal mock ICodeGenSymbols with default empty collections.
@@ -281,7 +328,7 @@ describe("CodeGenState", () => {
 
       CodeGenState.registerType("myVar", typeInfo);
 
-      expect(CodeGenState.typeRegistry.get("myVar")).toBe(typeInfo);
+      expect(CodeGenState.getVariableTypeInfo("myVar")).toBe(typeInfo);
     });
 
     it("registerConstValue adds to constValues", () => {
@@ -348,6 +395,235 @@ describe("CodeGenState", () => {
     });
   });
 
+  describe("Variable Type Info API (Issue #786)", () => {
+    it("getVariableTypeInfo returns local type info from registry", () => {
+      const typeInfo: TTypeInfo = {
+        baseType: "u32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
+      };
+
+      CodeGenState.setVariableTypeInfo("localVar", typeInfo);
+
+      expect(CodeGenState.getVariableTypeInfo("localVar")).toBe(typeInfo);
+    });
+
+    it("getVariableTypeInfo returns undefined for unknown variable", () => {
+      expect(CodeGenState.getVariableTypeInfo("unknownVar")).toBeUndefined();
+    });
+
+    it("getVariableTypeInfo falls back to SymbolTable for C-Next variables", () => {
+      // Add a C-Next variable to SymbolTable (simulating cross-file include)
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "crossFileVar",
+          type: TTypeUtils.createPrimitive("u16"),
+          isArray: true,
+          arrayDimensions: [10],
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("crossFileVar");
+
+      expect(result).toBeDefined();
+      expect(result?.baseType).toBe("u16");
+      expect(result?.bitWidth).toBe(16);
+      expect(result?.isArray).toBe(true);
+      expect(result?.arrayDimensions).toEqual([10]);
+    });
+
+    it("getVariableTypeInfo does not use C header symbols", () => {
+      // Add a C header variable (should NOT be used)
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "cHeaderVar",
+          type: "uint32_t",
+        }),
+      );
+
+      expect(CodeGenState.getVariableTypeInfo("cHeaderVar")).toBeUndefined();
+    });
+
+    it("getVariableTypeInfo prefers local registry over SymbolTable", () => {
+      // Add both local and SymbolTable version
+      const localInfo: TTypeInfo = {
+        baseType: "i32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: true,
+      };
+      CodeGenState.setVariableTypeInfo("mixedVar", localInfo);
+
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "mixedVar",
+          type: TTypeUtils.createPrimitive("u8"),
+        }),
+      );
+
+      // Should return local info, not SymbolTable info
+      const result = CodeGenState.getVariableTypeInfo("mixedVar");
+      expect(result?.baseType).toBe("i32");
+      expect(result?.isConst).toBe(true);
+    });
+
+    it("hasVariableTypeInfo returns true for local registry", () => {
+      CodeGenState.setVariableTypeInfo("localVar", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+      });
+
+      expect(CodeGenState.hasVariableTypeInfo("localVar")).toBe(true);
+    });
+
+    it("hasVariableTypeInfo returns true for C-Next SymbolTable variable", () => {
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "crossFileVar",
+          type: TTypeUtils.createPrimitive("u32"),
+        }),
+      );
+
+      expect(CodeGenState.hasVariableTypeInfo("crossFileVar")).toBe(true);
+    });
+
+    it("hasVariableTypeInfo returns false for unknown variable", () => {
+      expect(CodeGenState.hasVariableTypeInfo("unknownVar")).toBe(false);
+    });
+
+    it("hasVariableTypeInfo returns false for C header variable", () => {
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "cVar",
+          type: "int",
+        }),
+      );
+
+      expect(CodeGenState.hasVariableTypeInfo("cVar")).toBe(false);
+    });
+
+    it("setVariableTypeInfo and deleteVariableTypeInfo work correctly", () => {
+      const typeInfo: TTypeInfo = {
+        baseType: "f32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
+      };
+
+      CodeGenState.setVariableTypeInfo("tempVar", typeInfo);
+      expect(CodeGenState.getVariableTypeInfo("tempVar")).toBe(typeInfo);
+
+      CodeGenState.deleteVariableTypeInfo("tempVar");
+      expect(CodeGenState.getVariableTypeInfo("tempVar")).toBeUndefined();
+    });
+
+    it("getTypeRegistryView returns readonly view", () => {
+      CodeGenState.setVariableTypeInfo("var1", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+      });
+      CodeGenState.setVariableTypeInfo("var2", {
+        baseType: "u16",
+        bitWidth: 16,
+        isArray: false,
+        isConst: false,
+      });
+
+      const view = CodeGenState.getTypeRegistryView();
+
+      expect(view.size).toBe(2);
+      expect(view.has("var1")).toBe(true);
+      expect(view.has("var2")).toBe(true);
+    });
+
+    it("getTypeInfo is deprecated alias for getVariableTypeInfo", () => {
+      const typeInfo: TTypeInfo = {
+        baseType: "u64",
+        bitWidth: 64,
+        isArray: false,
+        isConst: false,
+      };
+
+      CodeGenState.setVariableTypeInfo("aliasVar", typeInfo);
+
+      // getTypeInfo should return same result
+      expect(CodeGenState.getTypeInfo("aliasVar")).toBe(typeInfo);
+    });
+
+    it("convertSymbolToTypeInfo handles string<N> types", () => {
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "myString",
+          type: TTypeUtils.createString(32),
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("myString");
+
+      expect(result?.baseType).toBe("char");
+      expect(result?.bitWidth).toBe(8);
+      expect(result?.isString).toBe(true);
+      expect(result?.stringCapacity).toBe(32);
+    });
+
+    it("convertSymbolToTypeInfo handles enum types", () => {
+      // Register an enum
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EColor"]),
+      });
+
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "color",
+          type: TTypeUtils.createEnum("EColor"),
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("color");
+
+      expect(result?.baseType).toBe("EColor");
+      expect(result?.isEnum).toBe(true);
+      expect(result?.enumTypeName).toBe("EColor");
+    });
+
+    it("convertSymbolToTypeInfo handles const and atomic", () => {
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "constAtomicVar",
+          type: TTypeUtils.createPrimitive("u32"),
+          isConst: true,
+          isAtomic: true,
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("constAtomicVar");
+
+      expect(result?.isConst).toBe(true);
+      expect(result?.isAtomic).toBe(true);
+    });
+
+    it("convertSymbolToTypeInfo filters invalid array dimensions", () => {
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "arrayVar",
+          type: TTypeUtils.createPrimitive("u8"),
+          isArray: true,
+          arrayDimensions: [10, "invalid", 20],
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("arrayVar");
+
+      // Should only include valid numeric dimensions
+      expect(result?.arrayDimensions).toEqual([10, 20]);
+    });
+  });
+
   describe("Overflow Operation Helpers", () => {
     it("markClampOpUsed adds to usedClampOps", () => {
       CodeGenState.markClampOpUsed("add", "u8");