c-next 0.1.70 → 0.1.72

package/src/transpiler/output/codegen/types/IFunctionContextCallbacks.ts

@@ -0,0 +1,12 @@
+/**
+ * Callbacks required for parameter type resolution.
+ * Issue #793: Used by FunctionContextManager for CodeGenerator dependencies.
+ */
+interface IFunctionContextCallbacks {
+  /** Check if a type name is a struct type */
+  isStructType: (typeName: string) => boolean;
+  /** Resolve qualified type identifiers to a type name */
+  resolveQualifiedType: (identifiers: string[]) => string;
+}
+
+export default IFunctionContextCallbacks;

package/src/transpiler/output/codegen/types/IVariableFormatInput.ts

@@ -45,7 +45,7 @@ interface IVariableFormatInput {
   modifiers: IVariableModifiers;
 
   /** Array dimensions as strings (e.g., ['10', '20']) */
-  arrayDimensions?: string[];
+  arrayDimensions?: readonly string[];
 }
 
 export default IVariableFormatInput;

package/src/transpiler/output/codegen/utils/QualifiedNameGenerator.ts

@@ -0,0 +1,114 @@
+/**
+ * QualifiedNameGenerator - C-style name generation for C-Next symbols
+ *
+ * Provides C-style mangled name generation for use in the output layer.
+ * Delegates to FunctionUtils.getCMangledName() for the actual implementation
+ * to avoid duplication with the types layer.
+ *
+ * Design decisions:
+ * - Lives in output layer (codegen) since it generates C output
+ * - Delegates to FunctionUtils for symbol-based name generation
+ * - Provides string-based methods for backward compatibility
+ * - Handles nested scopes: Outer.Inner.func -> Outer_Inner_func
+ * - Global scope functions keep their bare names
+ */
+import type IFunctionSymbol from "../../../types/symbols/IFunctionSymbol";
+import type IScopeSymbol from "../../../types/symbols/IScopeSymbol";
+import SymbolRegistry from "../../../state/SymbolRegistry";
+import FunctionUtils from "../../../../utils/FunctionUtils";
+import ScopeUtils from "../../../../utils/ScopeUtils";
+
+class QualifiedNameGenerator {
+  // ============================================================================
+  // Symbol-based methods (preferred)
+  // ============================================================================
+
+  /**
+   * Generate the C-style mangled name for a function.
+   *
+   * For global scope functions, returns the bare name (e.g., "main").
+   * For scoped functions, returns "Scope_name" (e.g., "Test_fillData").
+   * For nested scopes, returns "Outer_Inner_name" (e.g., "Outer_Inner_deepFunc").
+   *
+   * Delegates to FunctionUtils.getCMangledName() to avoid duplication.
+   */
+  static forFunction(func: IFunctionSymbol): string {
+    return FunctionUtils.getCMangledName(func);
+  }
+
+  /**
+   * Get the scope path as an array of scope names (outermost first).
+   *
+   * Returns empty array for global scope.
+   * Returns ["Test"] for scope "Test".
+   * Returns ["Outer", "Inner"] for scope "Outer.Inner".
+   *
+   * Delegates to ScopeUtils.getScopePath() to avoid duplication.
+   */
+  static getScopePath(scope: IScopeSymbol): string[] {
+    return ScopeUtils.getScopePath(scope);
+  }
+
+  // ============================================================================
+  // String-based methods (for transition - use symbol-based when possible)
+  // ============================================================================
+
+  /**
+   * Generate a qualified function name from strings.
+   *
+   * Tries to look up the function in SymbolRegistry first.
+   * Falls back to simple string concatenation if not found.
+   *
+   * @param scopeName Scope name (e.g., "Test", "Outer.Inner") or undefined for global
+   * @param funcName Bare function name (e.g., "fillData")
+   * @returns C-mangled name (e.g., "Test_fillData")
+   */
+  static forFunctionStrings(
+    scopeName: string | undefined,
+    funcName: string,
+  ): string {
+    // Try SymbolRegistry first (using getScope to avoid creating orphaned scopes)
+    if (scopeName) {
+      const scope = SymbolRegistry.getScope(scopeName);
+      if (scope) {
+        const func = SymbolRegistry.resolveFunction(funcName, scope);
+        if (func) {
+          return this.forFunction(func);
+        }
+      }
+    } else {
+      const global = SymbolRegistry.getGlobalScope();
+      const func = SymbolRegistry.resolveFunction(funcName, global);
+      if (func) {
+        return this.forFunction(func);
+      }
+    }
+
+    // Fallback to string concatenation
+    if (!scopeName) {
+      return funcName;
+    }
+    // Convert dotted scope path to underscores
+    const scopePrefix = scopeName.replaceAll(".", "_");
+    return `${scopePrefix}_${funcName}`;
+  }
+
+  /**
+   * Generate a qualified name for any scoped member (variable, enum, etc.).
+   *
+   * This is a simple string concatenation helper for non-function members.
+   *
+   * @param scopeName Scope name or undefined for global
+   * @param memberName Member name
+   * @returns C-mangled name
+   */
+  static forMember(scopeName: string | undefined, memberName: string): string {
+    if (!scopeName) {
+      return memberName;
+    }
+    const scopePrefix = scopeName.replaceAll(".", "_");
+    return `${scopePrefix}_${memberName}`;
+  }
+}
+
+export default QualifiedNameGenerator;

package/src/transpiler/output/codegen/utils/__tests__/QualifiedNameGenerator.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Tests for QualifiedNameGenerator
+ *
+ * QualifiedNameGenerator is the ONLY place that constructs C-style mangled names
+ * like "Test_fillData" from function symbols.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import QualifiedNameGenerator from "../QualifiedNameGenerator";
+import SymbolRegistry from "../../../../state/SymbolRegistry";
+import FunctionUtils from "../../../../../utils/FunctionUtils";
+import TTypeUtils from "../../../../../utils/TTypeUtils";
+
+describe("QualifiedNameGenerator", () => {
+  beforeEach(() => {
+    SymbolRegistry.reset();
+  });
+
+  describe("forFunction", () => {
+    it("returns bare name for global scope function", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      const func = FunctionUtils.create({
+        name: "main",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("i32"),
+        visibility: "public",
+        body: null,
+        sourceFile: "main.cnx",
+        sourceLine: 1,
+      });
+
+      expect(QualifiedNameGenerator.forFunction(func)).toBe("main");
+    });
+
+    it("returns Scope_name for scoped function", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const func = FunctionUtils.create({
+        name: "fillData",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+
+      expect(QualifiedNameGenerator.forFunction(func)).toBe("Test_fillData");
+    });
+
+    it("returns Outer_Inner_name for nested scope function", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Outer.Inner");
+      const func = FunctionUtils.create({
+        name: "deepFunc",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+
+      expect(QualifiedNameGenerator.forFunction(func)).toBe(
+        "Outer_Inner_deepFunc",
+      );
+    });
+
+    it("returns deeply nested path for 3-level scope", () => {
+      const scope = SymbolRegistry.getOrCreateScope("A.B.C");
+      const func = FunctionUtils.create({
+        name: "veryDeep",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+
+      expect(QualifiedNameGenerator.forFunction(func)).toBe("A_B_C_veryDeep");
+    });
+  });
+
+  describe("getScopePath", () => {
+    it("returns empty array for global scope", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      expect(QualifiedNameGenerator.getScopePath(global)).toEqual([]);
+    });
+
+    it("returns single element for direct child of global", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      expect(QualifiedNameGenerator.getScopePath(scope)).toEqual(["Test"]);
+    });
+
+    it("returns full path for nested scope", () => {
+      const scope = SymbolRegistry.getOrCreateScope("A.B.C");
+      expect(QualifiedNameGenerator.getScopePath(scope)).toEqual([
+        "A",
+        "B",
+        "C",
+      ]);
+    });
+
+    it("returns path in correct order (outermost first)", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Outer.Middle.Inner");
+      expect(QualifiedNameGenerator.getScopePath(scope)).toEqual([
+        "Outer",
+        "Middle",
+        "Inner",
+      ]);
+    });
+  });
+
+  describe("forFunctionStrings", () => {
+    it("returns bare name for undefined scope", () => {
+      expect(QualifiedNameGenerator.forFunctionStrings(undefined, "main")).toBe(
+        "main",
+      );
+    });
+
+    it("returns mangled name for simple scope", () => {
+      expect(
+        QualifiedNameGenerator.forFunctionStrings("Test", "fillData"),
+      ).toBe("Test_fillData");
+    });
+
+    it("converts dotted scope to underscores", () => {
+      expect(
+        QualifiedNameGenerator.forFunctionStrings("Outer.Inner", "func"),
+      ).toBe("Outer_Inner_func");
+    });
+
+    it("uses SymbolRegistry when function is registered", () => {
+      // Register a function in SymbolRegistry
+      const scope = SymbolRegistry.getOrCreateScope("Motor");
+      const func = FunctionUtils.create({
+        name: "init",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "motor.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      // forFunctionStrings should find it via SymbolRegistry
+      expect(QualifiedNameGenerator.forFunctionStrings("Motor", "init")).toBe(
+        "Motor_init",
+      );
+    });
+
+    it("falls back to string concat when function not in registry", () => {
+      // Don't register the function - should fall back to string concat
+      expect(QualifiedNameGenerator.forFunctionStrings("Unknown", "func")).toBe(
+        "Unknown_func",
+      );
+    });
+  });
+
+  describe("forMember", () => {
+    it("returns bare name for undefined scope", () => {
+      expect(QualifiedNameGenerator.forMember(undefined, "value")).toBe(
+        "value",
+      );
+    });
+
+    it("returns mangled name for simple scope", () => {
+      expect(QualifiedNameGenerator.forMember("Test", "counter")).toBe(
+        "Test_counter",
+      );
+    });
+
+    it("converts dotted scope to underscores", () => {
+      expect(QualifiedNameGenerator.forMember("Outer.Inner", "data")).toBe(
+        "Outer_Inner_data",
+      );
+    });
+  });
+});

package/src/transpiler/output/headers/BaseHeaderGenerator.ts

@@ -6,7 +6,7 @@
  * determine pointer (*) vs reference (&) semantics.
  */
 
-import ISymbol from "../../../utils/types/ISymbol";
+import IHeaderSymbol from "./types/IHeaderSymbol";
 import IParameterSymbol from "../../../utils/types/IParameterSymbol";
 import IHeaderOptions from "../codegen/types/IHeaderOptions";
 import IHeaderTypeInput from "./generators/IHeaderTypeInput";
@@ -40,7 +40,7 @@ abstract class BaseHeaderGenerator {
    * Generate a header file from symbols
    */
   generate(
-    symbols: ISymbol[],
+    symbols: IHeaderSymbol[],
     filename: string,
     options: IHeaderOptions = {},
     typeInput?: IHeaderTypeInput,
@@ -128,7 +128,7 @@ abstract class BaseHeaderGenerator {
    * Generate function prototypes section
    */
   private generateFunctionSection(
-    functions: ISymbol[],
+    functions: IHeaderSymbol[],
     passByValueParams?: TPassByValueParams,
     allKnownEnums?: ReadonlySet<string>,
   ): string[] {
@@ -155,7 +155,7 @@ abstract class BaseHeaderGenerator {
    * Generate a function prototype
    */
   private generateFunctionPrototype(
-    sym: ISymbol,
+    sym: IHeaderSymbol,
     passByValueParams?: TPassByValueParams,
     allKnownEnums?: ReadonlySet<string>,
   ): string | null {

package/src/transpiler/output/headers/ExternalTypeHeaderBuilder.ts

@@ -5,16 +5,16 @@
  * Issue #589: Extracted from Transpiler.buildExternalTypeHeaders()
  * Issue #497: Enables header generation to include original C headers instead of
  * generating conflicting forward declarations for types like anonymous struct typedefs.
+ * ADR-055 Phase 7: Uses TAnySymbol instead of ISymbol.
  */
 
-import ESymbolKind from "../../../utils/types/ESymbolKind";
-import ISymbol from "../../../utils/types/ISymbol";
+import TAnySymbol from "../../types/symbols/TAnySymbol";
 
 /**
  * Interface for accessing symbols by file path
  */
 interface ISymbolSource {
-  getSymbolsByFile(filePath: string): ISymbol[];
+  getSymbolsByFile(filePath: string): TAnySymbol[];
 }
 
 /**
@@ -45,10 +45,10 @@ class ExternalTypeHeaderBuilder {
       // Map each struct/type/enum name to the include directive
       for (const sym of symbols) {
         if (
-          sym.kind === ESymbolKind.Struct ||
-          sym.kind === ESymbolKind.Type ||
-          sym.kind === ESymbolKind.Enum ||
-          sym.kind === ESymbolKind.Class
+          sym.kind === "struct" ||
+          sym.kind === "type" ||
+          sym.kind === "enum" ||
+          sym.kind === "class"
         ) {
           // Only add if we don't already have a mapping (first include wins)
           if (!typeHeaders.has(sym.name)) {

package/src/transpiler/output/headers/HeaderGenerator.ts

@@ -5,9 +5,9 @@
  * Maintains backward-compatible API.
  */
 
-import ISymbol from "../../../utils/types/ISymbol";
-import ESourceLanguage from "../../../utils/types/ESourceLanguage";
+import IHeaderSymbol from "./types/IHeaderSymbol";
 import SymbolTable from "../../logic/symbols/SymbolTable";
+import HeaderSymbolAdapter from "./adapters/HeaderSymbolAdapter";
 import IHeaderOptions from "../codegen/types/IHeaderOptions";
 import IHeaderTypeInput from "./generators/IHeaderTypeInput";
 import CHeaderGenerator from "./CHeaderGenerator";
@@ -39,7 +39,7 @@ class HeaderGenerator {
    * @param allKnownEnums - All known enum names from entire compilation
    */
   generate(
-    symbols: ISymbol[],
+    symbols: IHeaderSymbol[],
     filename: string,
     options: IHeaderOptions = {},
     typeInput?: IHeaderTypeInput,
@@ -66,11 +66,12 @@ class HeaderGenerator {
     sourceFile: string,
     options: IHeaderOptions = {},
   ): string {
-    const symbols = symbolTable.getSymbolsByFile(sourceFile);
+    const tSymbols = symbolTable.getTSymbolsByFile(sourceFile);
+    const headerSymbols = HeaderSymbolAdapter.fromTSymbols(tSymbols);
     const basename = sourceFile.replace(/\.[^.]+$/, "");
     const headerName = `${basename}.h`;
 
-    return this.generate(symbols, headerName, options);
+    return this.generate(headerSymbols, headerName, options);
   }
 
   /**
@@ -81,8 +82,9 @@ class HeaderGenerator {
     filename: string,
     options: IHeaderOptions = {},
   ): string {
-    const symbols = symbolTable.getSymbolsByLanguage(ESourceLanguage.CNext);
-    return this.generate(symbols, filename, options);
+    const tSymbols = symbolTable.getAllTSymbols();
+    const headerSymbols = HeaderSymbolAdapter.fromTSymbols(tSymbols);
+    return this.generate(headerSymbols, filename, options);
   }
 }
 

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -5,8 +5,7 @@
  * CHeaderGenerator and CppHeaderGenerator.
  */
 
-import ISymbol from "../../../utils/types/ISymbol";
-import ESymbolKind from "../../../utils/types/ESymbolKind";
+import IHeaderSymbol from "./types/IHeaderSymbol";
 import SymbolTable from "../../logic/symbols/SymbolTable";
 import CppNamespaceUtils from "../../../utils/CppNamespaceUtils";
 import typeUtils from "./generators/mapType";
@@ -45,15 +44,15 @@ class HeaderGeneratorUtils {
   /**
    * Group symbols by their kind for organized header output
    */
-  static groupSymbolsByKind(symbols: ISymbol[]): IGroupedSymbols {
+  static groupSymbolsByKind(symbols: IHeaderSymbol[]): IGroupedSymbols {
     return {
-      structs: symbols.filter((s) => s.kind === ESymbolKind.Struct),
-      classes: symbols.filter((s) => s.kind === ESymbolKind.Class),
-      functions: symbols.filter((s) => s.kind === ESymbolKind.Function),
-      variables: symbols.filter((s) => s.kind === ESymbolKind.Variable),
-      enums: symbols.filter((s) => s.kind === ESymbolKind.Enum),
-      types: symbols.filter((s) => s.kind === ESymbolKind.Type),
-      bitmaps: symbols.filter((s) => s.kind === ESymbolKind.Bitmap),
+      structs: symbols.filter((s) => s.kind === "struct"),
+      classes: symbols.filter((s) => s.kind === "class"),
+      functions: symbols.filter((s) => s.kind === "function"),
+      variables: symbols.filter((s) => s.kind === "variable"),
+      enums: symbols.filter((s) => s.kind === "enum"),
+      types: symbols.filter((s) => s.kind === "type"),
+      bitmaps: symbols.filter((s) => s.kind === "bitmap"),
     };
   }
 
@@ -112,8 +111,8 @@ class HeaderGeneratorUtils {
    * - Not cross-file enums (which can't be forward-declared as structs)
    */
   static collectExternalTypes(
-    functions: ISymbol[],
-    variables: ISymbol[],
+    functions: IHeaderSymbol[],
+    variables: IHeaderSymbol[],
     localStructs: Set<string>,
     localEnums: Set<string>,
     localTypes: Set<string>,
@@ -192,9 +191,9 @@ class HeaderGeneratorUtils {
    * Excludes C++ namespace types, templates, and underscore-format namespace types
    */
   static filterCCompatibleVariables(
-    variables: ISymbol[],
+    variables: IHeaderSymbol[],
     symbolTable?: SymbolTable,
-  ): ISymbol[] {
+  ): IHeaderSymbol[] {
     return variables.filter(
       (v) =>
         !v.type?.includes("::") &&
@@ -331,7 +330,7 @@ class HeaderGeneratorUtils {
    * Generate enum section
    */
   static generateEnumSection(
-    enums: ISymbol[],
+    enums: IHeaderSymbol[],
     typeInput?: IHeaderTypeInput,
   ): string[] {
     if (enums.length === 0) {
@@ -354,7 +353,7 @@ class HeaderGeneratorUtils {
    * Generate bitmap section
    */
   static generateBitmapSection(
-    bitmaps: ISymbol[],
+    bitmaps: IHeaderSymbol[],
     typeInput?: IHeaderTypeInput,
   ): string[] {
     if (bitmaps.length === 0) {
@@ -376,7 +375,7 @@ class HeaderGeneratorUtils {
   /**
    * Generate type alias section
    */
-  static generateTypeAliasSection(types: ISymbol[]): string[] {
+  static generateTypeAliasSection(types: IHeaderSymbol[]): string[] {
     if (types.length === 0) {
       return [];
     }
@@ -396,8 +395,8 @@ class HeaderGeneratorUtils {
    * Generate struct and class definitions section
    */
   static generateStructSection(
-    structs: ISymbol[],
-    classes: ISymbol[],
+    structs: IHeaderSymbol[],
+    classes: IHeaderSymbol[],
     typeInput?: IHeaderTypeInput,
   ): string[] {
     if (structs.length === 0 && classes.length === 0) {
@@ -432,7 +431,7 @@ class HeaderGeneratorUtils {
    *
    * Uses VariableDeclarationFormatter for consistent formatting with CodeGenerator.
    */
-  static generateVariableSection(variables: ISymbol[]): string[] {
+  static generateVariableSection(variables: IHeaderSymbol[]): string[] {
     if (variables.length === 0) {
       return [];
     }

package/src/transpiler/output/headers/__tests__/BaseHeaderGenerator.test.ts

@@ -5,9 +5,7 @@
 import { describe, it, expect } from "vitest";
 import CHeaderGenerator from "../CHeaderGenerator";
 import CppHeaderGenerator from "../CppHeaderGenerator";
-import ISymbol from "../../../../utils/types/ISymbol";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
+import IHeaderSymbol from "../types/IHeaderSymbol";
 
 /**
  * Helper to create a minimal function symbol for tests
@@ -23,14 +21,13 @@ function createFunctionSymbol(
     isArray?: boolean;
     arrayDimensions?: string[];
   }>,
-): ISymbol {
+): IHeaderSymbol {
   return {
     name,
-    kind: ESymbolKind.Function,
+    kind: "function",
     type,
     sourceFile: "test.cnx",
     sourceLine: 1,
-    sourceLanguage: ESourceLanguage.CNext,
     isExported: true,
     parameters: parameters.map((p) => ({
       name: p.name,
@@ -47,7 +44,7 @@ describe("BaseHeaderGenerator", () => {
   describe("CHeaderGenerator", () => {
     it("should generate pointer syntax for struct parameters", () => {
       const generator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processData", "void", [
           { name: "data", type: "MyStruct" },
         ]),
@@ -60,7 +57,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should pass primitives by value when specified", () => {
       const generator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("add", "i32", [
           { name: "a", type: "i32" },
           { name: "b", type: "i32" },
@@ -85,7 +82,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should handle const parameters with pointer syntax", () => {
       const generator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("readData", "void", [
           { name: "data", type: "MyStruct", isConst: true },
         ]),
@@ -100,7 +97,7 @@ describe("BaseHeaderGenerator", () => {
   describe("CppHeaderGenerator", () => {
     it("should generate reference syntax for struct parameters", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processData", "void", [
           { name: "data", type: "MyStruct" },
         ]),
@@ -113,7 +110,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should handle const parameters with reference syntax", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("readData", "void", [
           { name: "data", type: "MyStruct", isConst: true },
         ]),
@@ -129,7 +126,7 @@ describe("BaseHeaderGenerator", () => {
     it("should handle float types as pass-by-value for both generators", () => {
       const cGenerator = new CHeaderGenerator();
       const cppGenerator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("calculate", "f32", [
           { name: "x", type: "f32" },
           { name: "y", type: "f64" },
@@ -146,7 +143,7 @@ describe("BaseHeaderGenerator", () => {
     it("should handle enum types as pass-by-value", () => {
       const cGenerator = new CHeaderGenerator();
       const cppGenerator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("setMode", "void", [
           { name: "mode", type: "Mode" },
         ]),
@@ -178,7 +175,7 @@ describe("BaseHeaderGenerator", () => {
     it("should handle array parameters consistently", () => {
       const cGenerator = new CHeaderGenerator();
       const cppGenerator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processArray", "void", [
           { name: "arr", type: "u8", isArray: true, arrayDimensions: ["10"] },
         ]),
@@ -193,7 +190,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should generate header guards", () => {
       const generator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "my_module.h");
 
@@ -204,7 +201,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should generate C++ extern wrapper", () => {
       const generator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -215,7 +212,7 @@ describe("BaseHeaderGenerator", () => {
     it("should handle ISR function pointer type as pass-by-value", () => {
       const cGenerator = new CHeaderGenerator();
       const cppGenerator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("registerHandler", "void", [
           { name: "handler", type: "ISR" },
         ]),
@@ -231,7 +228,7 @@ describe("BaseHeaderGenerator", () => {
 
     it("should handle autoConst parameter modifier", () => {
       const cGenerator = new CHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processData", "void", [
           { name: "data", type: "MyStruct", isAutoConst: true },
         ]),