c-next 0.1.70 → 0.1.72

package/src/transpiler/state/CodeGenState.ts

@@ -30,8 +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 ESymbolKind from "../../utils/types/ESymbolKind";
-import ESourceLanguage from "../../utils/types/ESourceLanguage";
+import TypeResolver from "../../utils/TypeResolver";
 
 /**
  * Default target capabilities (safe fallback)
@@ -471,16 +470,12 @@ export default class CodeGenState {
       return localInfo;
     }
 
-    // Fall back to SymbolTable for cross-file C-Next variables only.
+    // 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 symbols from SymbolTable.
-    const symbol = this.symbolTable.getSymbol(name);
-    if (
-      symbol?.kind === ESymbolKind.Variable &&
-      symbol.type &&
-      symbol.sourceLanguage === ESourceLanguage.CNext
-    ) {
-      return this.convertSymbolToTypeInfo(symbol);
+    // 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;
@@ -496,17 +491,14 @@ export default class CodeGenState {
 
   /**
    * 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.getSymbol(name);
-    return (
-      symbol?.kind === ESymbolKind.Variable &&
-      symbol.type !== undefined &&
-      symbol.sourceLanguage === ESourceLanguage.CNext
-    );
+    const symbol = this.symbolTable.getTSymbol(name);
+    return symbol?.kind === "variable" && symbol.type !== undefined;
   }
 
   /**
@@ -533,37 +525,32 @@ export default class CodeGenState {
   }
 
   /**
-   * Convert an ISymbol to TTypeInfo for unified type lookups.
-   * Used when looking up cross-file variables from SymbolTable.
+   * Convert a TSymbol IVariableSymbol to TTypeInfo for unified type lookups.
+   * ADR-055 Phase 7: Works with typed TSymbol instead of ISymbol.
    */
-  private static convertSymbolToTypeInfo(symbol: {
-    type?: string;
-    isArray?: boolean;
-    arrayDimensions?: string[];
-    isConst?: boolean;
-    isAtomic?: boolean;
-  }): TTypeInfo {
-    const rawType = symbol.type || "unknown";
+  private static convertTSymbolToTypeInfo(
+    symbol: import("../types/symbols/IVariableSymbol").default,
+  ): TTypeInfo {
+    const typeName = TypeResolver.getTypeName(symbol.type);
 
-    // Parse string<N> type pattern
+    // Parse string capacity using regex
     const stringPattern = /^string<(\d+)>$/;
-    const stringMatch = stringPattern.exec(rawType);
+    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 (StringDeclHelper.ts)
-    const baseType = isString ? "char" : rawType;
+    // Use char for string types to match local convention
+    const baseType = isString ? "char" : typeName;
 
     const isEnum = this.isKnownEnum(baseType);
 
     return {
       baseType,
-      // Use bitWidth 8 for strings (char), otherwise lookup from TYPE_WIDTH
       bitWidth: isString ? 8 : TYPE_WIDTH[baseType] || 0,
       isArray: symbol.isArray || false,
       arrayDimensions: symbol.arrayDimensions
-        ?.map((d) => Number.parseInt(d, 10))
+        ?.map((d) => (typeof d === "number" ? d : Number.parseInt(d, 10)))
         .filter((n) => !Number.isNaN(n)),
       isConst: symbol.isConst || false,
       isAtomic: symbol.isAtomic || false,

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,25 +6,51 @@ import { describe, it, expect, beforeEach } from "vitest";
 import CodeGenState from "../CodeGenState";
 import TTypeInfo from "../../output/codegen/types/TTypeInfo";
 import ICodeGenSymbols from "../../types/ICodeGenSymbols";
-import ESymbolKind from "../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../utils/types/ESourceLanguage";
-import ISymbol from "../../../utils/types/ISymbol";
+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 ISymbol for testing with required fields.
+ * Create a minimal C-Next IVariableSymbol for testing.
  */
-function createTestSymbol(
-  overrides: Partial<ISymbol> & {
-    name: string;
-    kind: ESymbolKind;
-    sourceLanguage: ESourceLanguage;
-  },
-): ISymbol {
+function createCNextVariableSymbol(
+  overrides: Partial<IVariableSymbol> & { name: string },
+): IVariableSymbol {
   return {
-    sourceFile: "test.cnx",
-    sourceLine: 1,
-    isExported: false,
-    ...overrides,
+    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,
   };
 }
 
@@ -389,14 +415,12 @@ describe("CodeGenState", () => {
 
     it("getVariableTypeInfo falls back to SymbolTable for C-Next variables", () => {
       // Add a C-Next variable to SymbolTable (simulating cross-file include)
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "crossFileVar",
-          kind: ESymbolKind.Variable,
-          type: "u16",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createPrimitive("u16"),
           isArray: true,
-          arrayDimensions: ["10"],
+          arrayDimensions: [10],
         }),
       );
 
@@ -411,12 +435,10 @@ describe("CodeGenState", () => {
 
     it("getVariableTypeInfo does not use C header symbols", () => {
       // Add a C header variable (should NOT be used)
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
           name: "cHeaderVar",
-          kind: ESymbolKind.Variable,
           type: "uint32_t",
-          sourceLanguage: ESourceLanguage.C,
         }),
       );
 
@@ -433,12 +455,10 @@ describe("CodeGenState", () => {
       };
       CodeGenState.setVariableTypeInfo("mixedVar", localInfo);
 
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "mixedVar",
-          kind: ESymbolKind.Variable,
-          type: "u8",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createPrimitive("u8"),
         }),
       );
 
@@ -460,12 +480,10 @@ describe("CodeGenState", () => {
     });
 
     it("hasVariableTypeInfo returns true for C-Next SymbolTable variable", () => {
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "crossFileVar",
-          kind: ESymbolKind.Variable,
-          type: "u32",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createPrimitive("u32"),
         }),
       );
 
@@ -477,12 +495,10 @@ describe("CodeGenState", () => {
     });
 
     it("hasVariableTypeInfo returns false for C header variable", () => {
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
           name: "cVar",
-          kind: ESymbolKind.Variable,
           type: "int",
-          sourceLanguage: ESourceLanguage.C,
         }),
       );
 
@@ -540,12 +556,10 @@ describe("CodeGenState", () => {
     });
 
     it("convertSymbolToTypeInfo handles string<N> types", () => {
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "myString",
-          kind: ESymbolKind.Variable,
-          type: "string<32>",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createString(32),
         }),
       );
 
@@ -563,12 +577,10 @@ describe("CodeGenState", () => {
         knownEnums: new Set(["EColor"]),
       });
 
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "color",
-          kind: ESymbolKind.Variable,
-          type: "EColor",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createEnum("EColor"),
         }),
       );
 
@@ -580,12 +592,10 @@ describe("CodeGenState", () => {
     });
 
     it("convertSymbolToTypeInfo handles const and atomic", () => {
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "constAtomicVar",
-          kind: ESymbolKind.Variable,
-          type: "u32",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createPrimitive("u32"),
           isConst: true,
           isAtomic: true,
         }),
@@ -598,14 +608,12 @@ describe("CodeGenState", () => {
     });
 
     it("convertSymbolToTypeInfo filters invalid array dimensions", () => {
-      CodeGenState.symbolTable.addSymbol(
-        createTestSymbol({
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
           name: "arrayVar",
-          kind: ESymbolKind.Variable,
-          type: "u8",
-          sourceLanguage: ESourceLanguage.CNext,
+          type: TTypeUtils.createPrimitive("u8"),
           isArray: true,
-          arrayDimensions: ["10", "invalid", "20"],
+          arrayDimensions: [10, "invalid", 20],
         }),
       );