c-next 0.1.69 → 0.1.71

package/src/transpiler/logic/symbols/cnext/collectors/VariableCollector.ts

@@ -1,12 +1,15 @@
 /**
  * VariableCollector - Extracts variable declarations from parse trees.
  * Handles types, const modifier, arrays, and initial values.
+ *
+ * Produces TType-based IVariableSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IVariableSymbol from "../../types/IVariableSymbol";
+import IVariableSymbol from "../../../../types/symbols/IVariableSymbol";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import TypeResolver from "../../../../../utils/TypeResolver";
 import ArrayInitializerUtils from "../utils/ArrayInitializerUtils";
 import TypeUtils from "../utils/TypeUtils";
 import LiteralUtils from "../../../../../utils/LiteralUtils";
@@ -102,25 +105,26 @@ class VariableCollector {
    *
    * @param ctx The variable declaration context
    * @param sourceFile Source file path
-   * @param scopeName Optional scope name for scoped variables
+   * @param scope The scope this variable belongs to (IScopeSymbol)
    * @param isPublic Whether this variable is public (default true for top-level)
    * @param constValues Map of constant names to their numeric values (for resolving array dimensions)
-   * @returns The variable symbol
+   * @returns The variable symbol with TType-based types and scope reference
    */
   static collect(
     ctx: Parser.VariableDeclarationContext,
     sourceFile: string,
-    scopeName?: string,
+    scope: IScopeSymbol,
     isPublic: boolean = true,
     constValues?: Map<string, number>,
   ): IVariableSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const line = ctx.start?.line ?? 0;
 
-    // Get type
+    // Get type string and convert to TType
     const typeCtx = ctx.type();
-    const type = TypeUtils.getTypeName(typeCtx, scopeName);
+    const scopeName = scope.name === "" ? undefined : scope.name;
+    const typeStr = TypeUtils.getTypeName(typeCtx, scopeName);
+    const type = TypeResolver.resolve(typeStr);
 
     // Check for const modifier
     const isConst = ctx.constModifier() !== null;
@@ -160,28 +164,23 @@ class VariableCollector {
     // Issue #282: Capture initial value for const inlining
     const initialValue = initExpr?.getText();
 
+    // Build base symbol
     const symbol: IVariableSymbol = {
-      name: fullName,
-      parent: scopeName,
+      kind: "variable",
+      name,
+      scope,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: isPublic,
-      kind: ESymbolKind.Variable,
       type,
       isConst,
       isAtomic,
       isArray,
+      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      initialValue,
     };
 
-    if (arrayDimensions.length > 0) {
-      symbol.arrayDimensions = arrayDimensions;
-    }
-
-    if (initialValue !== undefined) {
-      symbol.initialValue = initialValue;
-    }
-
     return symbol;
   }
 }

package/src/transpiler/logic/symbols/cnext/index.ts

@@ -1,10 +1,13 @@
 /**
  * CNextResolver - Orchestrates symbol collection from C-Next parse trees.
  * Uses two-pass collection to handle forward references (bitmaps before registers).
+ *
+ * Produces TType-based symbols with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../parser/grammar/CNextParser";
-import TSymbol from "../types/TSymbol";
+import TSymbol from "../../../types/symbols/TSymbol";
+import SymbolRegistry from "../../../state/SymbolRegistry";
 import LiteralUtils from "../../../../utils/LiteralUtils";
 import BitmapCollector from "./collectors/BitmapCollector";
 import EnumCollector from "./collectors/EnumCollector";
@@ -149,12 +152,19 @@ class CNextResolver {
     knownBitmaps: Set<string>,
     constValues: Map<string, number>,
   ): void {
+    const globalScope = SymbolRegistry.getGlobalScope();
+
     for (const decl of tree.declaration()) {
       // Top-level bitmaps
       if (decl.bitmapDeclaration()) {
         const bitmapCtx = decl.bitmapDeclaration()!;
-        const symbol = BitmapCollector.collect(bitmapCtx, sourceFile);
+        const symbol = BitmapCollector.collect(
+          bitmapCtx,
+          sourceFile,
+          globalScope,
+        );
         symbols.push(symbol);
+        // Use mangled name (global bitmaps have no scope prefix)
         knownBitmaps.add(symbol.name);
       }
 
@@ -183,17 +193,16 @@ class CNextResolver {
     constValues: Map<string, number>,
   ): void {
     const scopeName = scopeDecl.IDENTIFIER().getText();
+    const scope = SymbolRegistry.getOrCreateScope(scopeName);
 
     for (const member of scopeDecl.scopeMember()) {
       if (member.bitmapDeclaration()) {
         const bitmapCtx = member.bitmapDeclaration()!;
-        const symbol = BitmapCollector.collect(
-          bitmapCtx,
-          sourceFile,
-          scopeName,
-        );
+        const symbol = BitmapCollector.collect(bitmapCtx, sourceFile, scope);
         symbols.push(symbol);
-        knownBitmaps.add(symbol.name);
+        // Use mangled name (e.g., "Timer_ControlBits") for scoped bitmaps
+        const mangledName = `${scopeName}_${symbol.name}`;
+        knownBitmaps.add(mangledName);
       }
 
       // Collect structs early so they're available as types
@@ -202,7 +211,7 @@ class CNextResolver {
         const symbol = StructCollector.collect(
           structCtx,
           sourceFile,
-          scopeName,
+          scope,
           constValues,
         );
         symbols.push(symbol);
@@ -247,6 +256,8 @@ class CNextResolver {
     knownBitmaps: Set<string>,
     constValues: Map<string, number>,
   ): void {
+    const globalScope = SymbolRegistry.getGlobalScope();
+
     // Scopes (ScopeCollector handles nested members)
     if (decl.scopeDeclaration()) {
       CNextResolver._collectScopeDeclaration(
@@ -264,7 +275,7 @@ class CNextResolver {
       const symbol = StructCollector.collect(
         decl.structDeclaration()!,
         sourceFile,
-        undefined,
+        globalScope,
         constValues,
       );
       symbols.push(symbol);
@@ -273,7 +284,11 @@ class CNextResolver {
 
     // Top-level enums
     if (decl.enumDeclaration()) {
-      const symbol = EnumCollector.collect(decl.enumDeclaration()!, sourceFile);
+      const symbol = EnumCollector.collect(
+        decl.enumDeclaration()!,
+        sourceFile,
+        globalScope,
+      );
       symbols.push(symbol);
       return;
     }
@@ -284,6 +299,7 @@ class CNextResolver {
         decl.registerDeclaration()!,
         sourceFile,
         knownBitmaps,
+        globalScope,
       );
       symbols.push(symbol);
       return;
@@ -291,9 +307,15 @@ class CNextResolver {
 
     // Top-level functions
     if (decl.functionDeclaration()) {
-      const symbol = FunctionCollector.collect(
-        decl.functionDeclaration()!,
+      const funcDecl = decl.functionDeclaration()!;
+      const body = funcDecl.block();
+      // Use collectAndRegister to populate both old symbols and SymbolRegistry
+      const symbol = FunctionCollector.collectAndRegister(
+        funcDecl,
         sourceFile,
+        undefined, // global scope name (empty string)
+        body,
+        "private", // default visibility for global functions
       );
       symbols.push(symbol);
       return;
@@ -304,7 +326,7 @@ class CNextResolver {
       const symbol = VariableCollector.collect(
         decl.variableDeclaration()!,
         sourceFile,
-        undefined,
+        globalScope,
         true,
         constValues,
       );

package/src/transpiler/logic/symbols/cnext/types/IScopeCollectorResult.ts

@@ -3,8 +3,8 @@
  * Contains both the scope symbol itself and all nested member symbols.
  */
 
-import IScopeSymbol from "../../types/IScopeSymbol";
-import TSymbol from "../../types/TSymbol";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import TSymbol from "../../../../types/symbols/TSymbol";
 
 interface IScopeCollectorResult {
   scopeSymbol: IScopeSymbol;

package/src/transpiler/logic/symbols/cnext/utils/SymbolNameUtils.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility functions for symbol name manipulation.
+ */
+
+/**
+ * Get the C-mangled name for a symbol (e.g., "Geometry_Point" for Point in Geometry scope).
+ * Works with any symbol that has a name and scope reference.
+ *
+ * @param symbol Object with name and scope.name properties
+ * @returns The mangled name (e.g., "Motor_init") or bare name if global scope
+ */
+function getMangledName(symbol: {
+  name: string;
+  scope: { name: string };
+}): string {
+  const scopeName = symbol.scope.name;
+  if (scopeName === "") {
+    return symbol.name;
+  }
+  return `${scopeName}_${symbol.name}`;
+}
+
+class SymbolNameUtils {
+  static readonly getMangledName = getMangledName;
+}
+
+export default SymbolNameUtils;

package/src/transpiler/logic/symbols/cpp/__tests__/CppResolver.integration.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Integration tests for CppResolver.
+ * Verifies that the resolver correctly extracts symbols from C++ parse trees.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import CppResolver from "../index";
+import SymbolTable from "../../SymbolTable";
+import TestHelpers from "./testHelpers";
+
+describe("CppResolver", () => {
+  let symbolTable: SymbolTable;
+
+  beforeEach(() => {
+    symbolTable = new SymbolTable();
+  });
+
+  describe("namespace collection", () => {
+    it("collects a simple namespace", () => {
+      const source = `namespace MyNamespace { }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "namespace",
+        name: "MyNamespace",
+        sourceFile: "test.hpp",
+      });
+    });
+
+    it("collects nested namespaces", () => {
+      const source = `namespace Outer { namespace Inner { } }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(2);
+      expect(result.symbols[0].name).toBe("Outer");
+      expect(result.symbols[1].name).toBe("Outer::Inner");
+    });
+  });
+
+  describe("class collection", () => {
+    it("collects a simple class", () => {
+      const source = `class MyClass { };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "class",
+        name: "MyClass",
+        sourceFile: "test.hpp",
+      });
+    });
+
+    it("collects a class with fields", () => {
+      const source = `class Point { int x; int y; };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      const classSymbol = result.symbols[0];
+      expect(classSymbol.kind).toBe("class");
+
+      // Verify fields are stored in symbol table
+      const xType = symbolTable.getStructFieldType("Point", "x");
+      expect(xType).toBe("int");
+
+      const yType = symbolTable.getStructFieldType("Point", "y");
+      expect(yType).toBe("int");
+    });
+
+    it("collects class in namespace", () => {
+      const source = `namespace NS { class MyClass { }; }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const classSymbol = result.symbols.find((s) => s.kind === "class");
+      expect(classSymbol).toBeDefined();
+      expect(classSymbol!.name).toBe("NS::MyClass");
+      expect(classSymbol!.parent).toBe("NS");
+    });
+
+    it("collects member functions", () => {
+      const source = `class MyClass { void doSomething(); int getValue(); };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const funcSymbols = result.symbols.filter((s) => s.kind === "function");
+      expect(funcSymbols).toHaveLength(2);
+      expect(funcSymbols[0].name).toBe("MyClass::doSomething");
+      expect(funcSymbols[1].name).toBe("MyClass::getValue");
+    });
+
+    it("collects inline member function definitions", () => {
+      const source = `class MyClass { void inline_func() { } };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const funcSymbol = result.symbols.find((s) => s.kind === "function");
+      expect(funcSymbol).toBeDefined();
+      expect(funcSymbol!.name).toBe("MyClass::inline_func");
+    });
+  });
+
+  describe("enum collection", () => {
+    it("collects a simple enum", () => {
+      const source = `enum Color { RED, GREEN, BLUE };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "enum",
+        name: "Color",
+        sourceFile: "test.hpp",
+      });
+    });
+
+    it("collects typed enum with bit width", () => {
+      const source = `enum class EPressureType : uint8_t { PSIA, PSIG };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const enumSymbol = result.symbols.find((s) => s.kind === "enum");
+      expect(enumSymbol).toBeDefined();
+      expect(enumSymbol!.name).toBe("EPressureType");
+
+      // Check that bit width was stored in symbol table
+      const bitWidth = symbolTable.getEnumBitWidth("EPressureType");
+      expect(bitWidth).toBe(8);
+    });
+  });
+
+  describe("function collection", () => {
+    it("collects a free function definition", () => {
+      const source = `void myFunction() { }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "function",
+        name: "myFunction",
+        type: "void",
+      });
+    });
+
+    it("collects function with parameters", () => {
+      const source = `int add(int a, int b) { return a + b; }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const funcSymbol = result.symbols[0];
+      expect(funcSymbol.kind).toBe("function");
+      if (funcSymbol.kind === "function") {
+        expect(funcSymbol.parameters).toHaveLength(2);
+        expect(funcSymbol.parameters![0].name).toBe("a");
+        expect(funcSymbol.parameters![0].type).toBe("int");
+      }
+    });
+
+    it("collects function declaration (prototype)", () => {
+      const source = `int myFunc(int x);`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const funcSymbol = result.symbols[0];
+      expect(funcSymbol.kind).toBe("function");
+      if (funcSymbol.kind === "function") {
+        expect(funcSymbol.isDeclaration).toBe(true);
+      }
+    });
+
+    it("collects function in namespace", () => {
+      const source = `namespace NS { void foo() { } }`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const funcSymbol = result.symbols.find((s) => s.kind === "function");
+      expect(funcSymbol).toBeDefined();
+      expect(funcSymbol!.name).toBe("NS::foo");
+    });
+  });
+
+  describe("variable collection", () => {
+    it("collects a global variable", () => {
+      const source = `int globalVar;`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "variable",
+        name: "globalVar",
+        type: "int",
+      });
+    });
+
+    it("collects array variable", () => {
+      const source = `int buffer[32];`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const varSymbol = result.symbols[0];
+      expect(varSymbol.kind).toBe("variable");
+      if (varSymbol.kind === "variable") {
+        expect(varSymbol.isArray).toBe(true);
+        expect(varSymbol.arrayDimensions).toEqual([32]);
+      }
+    });
+  });
+
+  describe("type alias collection", () => {
+    it("collects a using alias", () => {
+      const source = `using MyInt = int;`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0]).toMatchObject({
+        kind: "type",
+        name: "MyInt",
+      });
+    });
+  });
+
+  describe("anonymous struct typedef", () => {
+    it("collects anonymous struct with typedef name", () => {
+      const source = `struct { int x; int y; } Point;`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      const classSymbol = result.symbols.find((s) => s.kind === "class");
+      expect(classSymbol).toBeDefined();
+      expect(classSymbol!.name).toBe("Point");
+    });
+  });
+
+  describe("warnings", () => {
+    it("warns about reserved field names", () => {
+      const source = `class MyStruct { int length; };`;
+      const tree = TestHelpers.parseCpp(source);
+      expect(tree).not.toBeNull();
+      const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
+
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]).toContain("length");
+      expect(result.warnings[0]).toContain("MyStruct");
+    });
+  });
+});

package/src/transpiler/logic/symbols/cpp/__tests__/testHelpers.ts

@@ -0,0 +1,20 @@
+/**
+ * Test helpers for C++ collector tests.
+ */
+
+import HeaderParser from "../../../parser/HeaderParser";
+import { TranslationUnitContext } from "../../../parser/cpp/grammar/CPP14Parser";
+
+/**
+ * Parse C++ source code and return the translation unit context.
+ */
+function parseCpp(source: string): TranslationUnitContext | null {
+  const result = HeaderParser.parseCpp(source);
+  return result.tree;
+}
+
+class TestHelpers {
+  static readonly parseCpp = parseCpp;
+}
+
+export default TestHelpers;