c-next 0.1.70 → 0.1.71

package/src/transpiler/Transpiler.ts

@@ -25,13 +25,16 @@ import ExternalTypeHeaderBuilder from "./output/headers/ExternalTypeHeaderBuilde
 import ICodeGenSymbols from "./types/ICodeGenSymbols";
 import IncludeExtractor from "./logic/IncludeExtractor";
 import SymbolTable from "./logic/symbols/SymbolTable";
-import ESymbolKind from "../utils/types/ESymbolKind";
-import ISymbol from "../utils/types/ISymbol";
+import ISerializedSymbol from "./types/ISerializedSymbol";
+import ESourceLanguage from "../utils/types/ESourceLanguage";
 import CNextResolver from "./logic/symbols/cnext";
-import TSymbolAdapter from "./logic/symbols/cnext/adapters/TSymbolAdapter";
+import SymbolRegistry from "./state/SymbolRegistry";
 import TSymbolInfoAdapter from "./logic/symbols/cnext/adapters/TSymbolInfoAdapter";
-import CSymbolCollector from "./logic/symbols/CSymbolCollector";
-import CppSymbolCollector from "./logic/symbols/CppSymbolCollector";
+import CResolver from "./logic/symbols/c";
+import CppResolver from "./logic/symbols/cpp";
+import HeaderSymbolAdapter from "./output/headers/adapters/HeaderSymbolAdapter";
+import IHeaderSymbol from "./output/headers/types/IHeaderSymbol";
+import TSymbol from "./types/symbols/TSymbol";
 import Preprocessor from "./logic/preprocessor/Preprocessor";
 
 import FileDiscovery from "./data/FileDiscovery";
@@ -50,13 +53,12 @@ import IFileResult from "./types/IFileResult";
 import IPipelineFile from "./types/IPipelineFile";
 import IPipelineInput from "./types/IPipelineInput";
 import ITranspileError from "../lib/types/ITranspileError";
-import TranspilerState from "./types/TranspilerState";
+import TranspilerState from "./state/TranspilerState";
 import runAnalyzers from "./logic/analysis/runAnalyzers";
 import ModificationAnalyzer from "./logic/analysis/ModificationAnalyzer";
 import CacheManager from "../utils/cache/CacheManager";
 import MapUtils from "../utils/MapUtils";
 import detectCppSyntax from "./logic/detectCppSyntax";
-import AutoConstUpdater from "./logic/symbols/AutoConstUpdater";
 import TransitiveEnumCollector from "./logic/symbols/TransitiveEnumCollector";
 
 /**
@@ -333,13 +335,11 @@ class Transpiler {
     }
 
     try {
-      // ADR-055: Use composable collectors via CNextResolver + TSymbolAdapter
+      // ADR-055 Phase 7: Use composable collectors via CNextResolver
       const tSymbols = CNextResolver.resolve(tree, file.path);
-      const iSymbols = TSymbolAdapter.toISymbols(
-        tSymbols,
-        CodeGenState.symbolTable,
-      );
-      CodeGenState.symbolTable.addSymbols(iSymbols);
+
+      // ADR-055 Phase 7: Store TSymbol directly in SymbolTable (no ISymbol conversion)
+      CodeGenState.symbolTable.addTSymbols(tSymbols);
 
       // Issue #465: Store ICodeGenSymbols for external enum resolution in stage 5
       const symbolInfo = TSymbolInfoAdapter.convert(tSymbols);
@@ -450,16 +450,13 @@ class Transpiler {
         this._accumulateFileModifications();
       }
 
-      // Update symbol parameters with auto-const info
-      const symbols = CodeGenState.symbolTable.getSymbolsByFile(sourcePath);
-      const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
-      const knownEnums =
-        this.state.getSymbolInfo(sourcePath)?.knownEnums ?? new Set<string>();
-      AutoConstUpdater.update(symbols, unmodifiedParams, knownEnums);
+      // ADR-055 Phase 7: Get TSymbols for header generation (auto-const applied during conversion)
+      const fileSymbols =
+        CodeGenState.symbolTable.getTSymbolsByFile(sourcePath);
 
       // Generate header content
       const headerCode = this.generateHeaderContent(
-        symbols,
+        fileSymbols,
         sourcePath,
         this.cppDetected,
         userIncludes,
@@ -621,6 +618,8 @@ class Transpiler {
     this.state.reset();
     // Issue #634: Reset symbol table for new run
     CodeGenState.symbolTable.clear();
+    // Reset SymbolRegistry for new run (new IFunctionSymbol type system)
+    SymbolRegistry.reset();
   }
 
   /**
@@ -1057,7 +1056,8 @@ class Transpiler {
     }
 
     // Restore symbols, struct fields, needsStructKeyword, and enumBitWidth from cache
-    CodeGenState.symbolTable.addSymbols(cached.symbols);
+    // ADR-055 Phase 7: Cache returns ISerializedSymbol[], converted to typed symbols
+    this.restoreCachedSymbols(cached.symbols, file);
     CodeGenState.symbolTable.restoreStructFields(cached.structFields);
     CodeGenState.symbolTable.restoreNeedsStructKeyword(
       cached.needsStructKeyword,
@@ -1070,6 +1070,78 @@ class Transpiler {
     return true;
   }
 
+  /**
+   * Restore cached symbols to the symbol table.
+   * ADR-055 Phase 7: Converts ISerializedSymbol[] from cache to typed symbols.
+   */
+  private restoreCachedSymbols(
+    symbols: ISerializedSymbol[],
+    _file: IDiscoveredFile,
+  ): void {
+    for (const symbol of symbols) {
+      // Determine which storage to use based on source language
+      if (symbol.sourceLanguage === ESourceLanguage.CNext) {
+        // C-Next symbols are never cached (they use TSymbol format).
+        // If we see one here, it indicates a cache format issue - skip silently
+        // since C-Next symbols are always re-parsed from source anyway.
+        continue;
+      } else if (symbol.sourceLanguage === ESourceLanguage.C) {
+        // Convert ISymbol to TCSymbol (simplified conversion)
+        CodeGenState.symbolTable.addCSymbol({
+          kind: symbol.kind as
+            | "struct"
+            | "enum"
+            | "function"
+            | "variable"
+            | "enum_member"
+            | "typedef",
+          name: symbol.name,
+          sourceFile: symbol.sourceFile,
+          sourceLine: symbol.sourceLine,
+          sourceLanguage: ESourceLanguage.C,
+          type: symbol.type,
+          isExported: symbol.isExported ?? true,
+          isDeclaration: symbol.isDeclaration,
+          parameters: symbol.parameters?.map((p) => ({
+            name: p.name,
+            type: p.type,
+            isArray: p.isArray,
+          })),
+          arrayDimensions: symbol.arrayDimensions?.map(String),
+          members: undefined,
+          isUnion: false,
+        } as import("./types/symbols/c/TCSymbol").default);
+      } else if (symbol.sourceLanguage === ESourceLanguage.Cpp) {
+        // Convert ISymbol to TCppSymbol (simplified conversion)
+        CodeGenState.symbolTable.addCppSymbol({
+          kind: symbol.kind as
+            | "class"
+            | "struct"
+            | "namespace"
+            | "enum"
+            | "function"
+            | "variable"
+            | "enum_member"
+            | "type_alias",
+          name: symbol.name,
+          sourceFile: symbol.sourceFile,
+          sourceLine: symbol.sourceLine,
+          sourceLanguage: ESourceLanguage.Cpp,
+          type: symbol.type,
+          isExported: symbol.isExported ?? true,
+          isDeclaration: symbol.isDeclaration,
+          parent: symbol.parent,
+          parameters: symbol.parameters?.map((p) => ({
+            name: p.name,
+            type: p.type,
+            isArray: p.isArray,
+          })),
+          arrayDimensions: symbol.arrayDimensions?.map(String),
+        } as import("./types/symbols/cpp/TCppSymbol").default);
+      }
+    }
+  }
+
   /**
    * Detect C++ mode based on file type and content.
    * SonarCloud S3776: Extracted from doCollectHeaderSymbols().
@@ -1130,33 +1202,36 @@ class Transpiler {
 
   /**
    * Issue #208: Parse a pure C header (no C++ syntax detected)
+   * Uses CResolver for symbol collection
+   * ADR-055 Phase 7: Direct TCSymbol storage (no adapter conversion)
    */
   private parsePureCHeader(content: string, filePath: string): void {
     const { tree } = HeaderParser.parseC(content);
     if (tree) {
-      const collector = new CSymbolCollector(
+      const result = CResolver.resolve(
+        tree,
         filePath,
         CodeGenState.symbolTable,
       );
-      const symbols = collector.collect(tree);
-      if (symbols.length > 0) {
-        CodeGenState.symbolTable.addSymbols(symbols);
-      }
+      // ADR-055 Phase 7: Store TCSymbol directly
+      CodeGenState.symbolTable.addCSymbols(result.symbols);
     }
   }
 
   /**
-   * Parse a C++ header
+   * Parse a C++ header using CppResolver
+   * ADR-055 Phase 7: Direct TCppSymbol storage (no adapter conversion)
    */
   private parseCppHeader(content: string, filePath: string): void {
     const { tree } = HeaderParser.parseCpp(content);
     if (tree) {
-      const collector = new CppSymbolCollector(
+      const result = CppResolver.resolve(
+        tree,
         filePath,
         CodeGenState.symbolTable,
       );
-      const symbols = collector.collect(tree);
-      CodeGenState.symbolTable.addSymbols(symbols);
+      // ADR-055 Phase 7: Store TCppSymbol directly
+      CodeGenState.symbolTable.addCppSymbols(result.symbols);
     }
   }
 
@@ -1166,10 +1241,11 @@ class Transpiler {
 
   /**
    * Stage 6: Generate header file for a C-Next file
+   * ADR-055 Phase 7: Uses TSymbol directly, converts to IHeaderSymbol for generation.
    */
   private generateHeader(file: IDiscoveredFile): string | null {
-    const symbols = CodeGenState.symbolTable.getSymbolsByFile(file.path);
-    const exportedSymbols = symbols.filter((s) => s.isExported);
+    const tSymbols = CodeGenState.symbolTable.getTSymbolsByFile(file.path);
+    const exportedSymbols = tSymbols.filter((s) => s.isExported);
 
     if (exportedSymbols.length === 0) {
       return null;
@@ -1207,8 +1283,12 @@ class Transpiler {
       ? { ...typeInput, symbolTable: CodeGenState.symbolTable }
       : undefined;
 
+    // ADR-055 Phase 7: Convert TSymbol to IHeaderSymbol
+    // Note: In multi-file run() path, auto-const is already applied during transpilation
+    const headerSymbols = HeaderSymbolAdapter.fromTSymbols(exportedSymbols);
+
     const headerContent = this.headerGenerator.generate(
-      exportedSymbols,
+      headerSymbols,
       headerName,
       {
         exportedOnly: true,
@@ -1270,50 +1350,35 @@ class Transpiler {
   /**
    * Generate header content for exported symbols.
    * Issue #591: Extracted from transpileSource() for reduced complexity.
+   * ADR-055 Phase 7: Works with TSymbol[], converts to IHeaderSymbol for generation.
    */
   private generateHeaderContent(
-    symbols: ISymbol[],
+    tSymbols: TSymbol[],
     sourcePath: string,
     cppMode: boolean,
     userIncludes: string[],
     passByValueParams: Map<string, Set<string>>,
     symbolInfo: ICodeGenSymbols,
   ): string | undefined {
-    const exportedSymbols = symbols.filter(
-      (s: { isExported?: boolean }) => s.isExported,
-    );
+    const exportedSymbols = tSymbols.filter((s) => s.isExported);
 
     if (exportedSymbols.length === 0) {
       return undefined;
     }
 
+    // Convert to IHeaderSymbol with auto-const info
+    const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
+    const headerSymbols = this.convertToHeaderSymbols(
+      exportedSymbols,
+      unmodifiedParams,
+      symbolInfo.knownEnums,
+    );
+
     const headerName = basename(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
 
     // Get type input from CodeGenState (for struct/enum definitions)
     const typeInput = CodeGenState.symbols;
 
-    // Update auto-const info on symbol parameters
-    const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
-    for (const symbol of symbols) {
-      if (symbol.kind !== ESymbolKind.Function || !symbol.parameters) {
-        continue;
-      }
-      const unmodified = unmodifiedParams.get(symbol.name);
-      if (!unmodified) continue;
-
-      for (const param of symbol.parameters) {
-        const isPointerParam =
-          !param.isConst &&
-          !param.isArray &&
-          param.type !== "f32" &&
-          param.type !== "f64" &&
-          param.type !== "ISR";
-        if (isPointerParam && unmodified.has(param.name)) {
-          param.isAutoConst = true;
-        }
-      }
-    }
-
     // Issue #497: Build mapping from external types to their C header includes
     const externalTypeHeaders = ExternalTypeHeaderBuilder.build(
       this.state.getAllHeaderDirectives(),
@@ -1327,7 +1392,7 @@ class Transpiler {
 
     // Issue #478: Pass all known enums for cross-file type handling
     return this.headerGenerator.generate(
-      exportedSymbols,
+      headerSymbols,
       headerName,
       {
         exportedOnly: true,
@@ -1341,6 +1406,54 @@ class Transpiler {
     );
   }
 
+  /**
+   * Convert TSymbols to IHeaderSymbols with auto-const information applied.
+   * ADR-055 Phase 7: Replaces mutation-based auto-const updating.
+   */
+  private convertToHeaderSymbols(
+    symbols: TSymbol[],
+    unmodifiedParams: ReadonlyMap<string, ReadonlySet<string>>,
+    knownEnums: ReadonlySet<string>,
+  ): IHeaderSymbol[] {
+    return symbols.map((symbol) => {
+      const headerSymbol = HeaderSymbolAdapter.fromTSymbol(symbol);
+
+      // Apply auto-const to function parameters
+      if (
+        symbol.kind === "function" &&
+        headerSymbol.parameters &&
+        headerSymbol.parameters.length > 0
+      ) {
+        const unmodified = unmodifiedParams.get(headerSymbol.name);
+        if (unmodified) {
+          // Create a mutable copy of parameters with auto-const applied
+          const updatedParams = headerSymbol.parameters.map((param) => {
+            const isPointerParam =
+              !param.isConst &&
+              !param.isArray &&
+              param.type !== "f32" &&
+              param.type !== "f64" &&
+              param.type !== "ISR" &&
+              !knownEnums.has(param.type ?? "");
+            const isArrayParam = param.isArray && !param.isConst;
+
+            if (
+              (isPointerParam || isArrayParam) &&
+              unmodified.has(param.name)
+            ) {
+              return { ...param, isAutoConst: true };
+            }
+            return param;
+          });
+
+          return { ...headerSymbol, parameters: updatedParams };
+        }
+      }
+
+      return headerSymbol;
+    });
+  }
+
   // ===========================================================================
   // Result Builder Helpers
   // ===========================================================================

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

@@ -11,7 +11,6 @@ import { ParseTreeWalker } from "antlr4ng";
 import { CNextListener } from "../parser/grammar/CNextListener";
 import * as Parser from "../parser/grammar/CNextParser";
 import SymbolTable from "../symbols/SymbolTable";
-import ESymbolKind from "../../../utils/types/ESymbolKind";
 import IFunctionCallError from "./types/IFunctionCallError";
 import ParserUtils from "../../../utils/ParserUtils";
 
@@ -687,7 +686,7 @@ class FunctionCallAnalyzer {
       // Accept functions from any source language:
       // - C/C++ functions from header includes
       // - C-Next functions from .cnx file includes
-      if (sym.kind === ESymbolKind.Function) {
+      if (sym.kind === "function") {
         return true;
       }
     }

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

@@ -23,7 +23,6 @@ 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";
 
 /**
  * Tracks the initialization state of a variable
@@ -459,7 +458,7 @@ class InitializationAnalyzer {
     for (const sym of symbols) {
       if (sym.sourceLanguage === ESourceLanguage.Cpp) {
         // C++ classes and structs have default constructors
-        if (sym.kind === ESymbolKind.Struct || sym.kind === ESymbolKind.Class) {
+        if (sym.kind === "struct" || sym.kind === "class") {
           return true;
         }
       }

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

@@ -19,6 +19,8 @@
 
 import * as Parser from "../parser/grammar/CNextParser";
 import CodeGenState from "../../state/CodeGenState";
+import SymbolRegistry from "../../state/SymbolRegistry";
+import FunctionUtils from "../../../utils/FunctionUtils";
 import TransitiveModificationPropagator from "./helpers/TransitiveModificationPropagator";
 import StatementExpressionCollector from "./helpers/StatementExpressionCollector";
 import ChildStatementCollector from "./helpers/ChildStatementCollector";
@@ -480,6 +482,7 @@ class PassByValueAnalyzer {
 
   /**
    * Handle simple function calls: IDENTIFIER followed by '(' ... ')'
+   * Issue #797: Resolve bare function names to scope-qualified names when inside a scope.
    */
   private static handleSimpleFunctionCall(
     funcName: string,
@@ -492,15 +495,61 @@ class PassByValueAnalyzer {
     const firstOp = postfixOps[0];
     if (!firstOp.LPAREN()) return;
 
-    const calleeName = primary.IDENTIFIER()!.getText();
+    const bareCalleeName = primary.IDENTIFIER()!.getText();
+    const resolvedCalleeName = PassByValueAnalyzer.resolveCalleeNameInScope(
+      funcName,
+      bareCalleeName,
+    );
     PassByValueAnalyzer.recordCallsFromArgList(
       funcName,
       paramSet,
-      calleeName,
+      resolvedCalleeName,
       firstOp,
     );
   }
 
+  /**
+   * Issue #797: Resolve a bare function name to its scope-qualified name.
+   * When inside a scope, bare calls like `fillData()` should resolve to `Scope_fillData`.
+   *
+   * Uses SymbolRegistry for proper scope-aware resolution instead of string parsing.
+   */
+  private static resolveCalleeNameInScope(
+    callerFuncName: string,
+    bareCalleeName: string,
+  ): string {
+    // Try to resolve using SymbolRegistry (new type system)
+    const callerScope =
+      SymbolRegistry.getScopeByMangledFunctionName(callerFuncName);
+    if (callerScope) {
+      // Use SymbolRegistry.resolveFunction to find the callee in scope chain
+      const callee = SymbolRegistry.resolveFunction(
+        bareCalleeName,
+        callerScope,
+      );
+      if (callee) {
+        // Use FunctionUtils to get the C-mangled name (types layer, not output layer)
+        return FunctionUtils.getCMangledName(callee);
+      }
+    }
+
+    // Fallback to legacy string-based lookup for backward compatibility
+    // (handles functions from C headers, external functions, etc.)
+    const underscoreIndex = callerFuncName.indexOf("_");
+    if (underscoreIndex === -1) {
+      return bareCalleeName;
+    }
+
+    const scopePrefix = callerFuncName.substring(0, underscoreIndex + 1);
+    const qualifiedName = scopePrefix + bareCalleeName;
+
+    if (CodeGenState.functionParamLists.has(qualifiedName)) {
+      return qualifiedName;
+    }
+
+    return bareCalleeName;
+  }
+
   /**
    * Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
    * Track member accesses to build the mangled callee name (e.g., Storage_load)

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

@@ -9,7 +9,9 @@ import { CNextParser } from "../../parser/grammar/CNextParser";
 import FunctionCallAnalyzer from "../FunctionCallAnalyzer";
 import SymbolTable from "../../symbols/SymbolTable";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
+import TestScopeUtils from "../../symbols/cnext/__tests__/testUtils";
+import TTypeUtils from "../../../../utils/TTypeUtils";
+import type IFunctionSymbol from "../../../types/symbols/IFunctionSymbol";
 
 /**
  * Helper to parse C-Next code and return the AST
@@ -367,9 +369,9 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
         name: "myExternalFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "external.h",
         sourceLine: 1,
@@ -391,9 +393,9 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: "cppHelper",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "helper.hpp",
         sourceLine: 1,
@@ -517,9 +519,9 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: "customExternalFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "custom.hpp",
         sourceLine: 1,
@@ -626,15 +628,19 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "cnextFunc",
-        kind: ESymbolKind.Function,
-        sourceLanguage: ESourceLanguage.CNext,
         sourceFile: "module.cnx",
         sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        type: "void",
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
       const analyzer = new FunctionCallAnalyzer();
       const errors = analyzer.analyze(tree, symbolTable);

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

@@ -10,7 +10,6 @@ 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";
 
 /**
@@ -46,9 +45,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C++ class
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppMessage",
-        kind: ESymbolKind.Class,
+        kind: "class",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "CppMessage.hpp",
         sourceLine: 1,
@@ -101,9 +100,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C++ struct (not class)
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "types.hpp",
         sourceLine: 1,
@@ -131,13 +130,14 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C struct (not C++)
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCSymbol({
         name: "CStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "types.h",
         sourceLine: 1,
         isExported: true,
+        isUnion: false,
       });
       CodeGenState.symbolTable.addStructField("CStruct", "value", "u32");
 
@@ -836,9 +836,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: "CppEnum",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "types.hpp",
         sourceLine: 1,

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

@@ -9,7 +9,6 @@ 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";
 
 /**
@@ -251,13 +250,14 @@ describe("runAnalyzers", () => {
       `);
 
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
         name: "ExternalFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "external.h",
         sourceLine: 1,
         isExported: true,
+        type: "void",
       });
 
       const errors = runAnalyzers(tree, tokenStream, { symbolTable });
@@ -272,9 +272,9 @@ describe("runAnalyzers", () => {
       `);
 
       // Set up C++ class in CodeGenState.symbolTable
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppMessage",
-        kind: ESymbolKind.Class,
+        kind: "class",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "CppMessage.hpp",
         sourceLine: 1,