c-next 0.1.70 → 0.1.72

package/src/transpiler/logic/symbols/cnext/__tests__/VariableCollector.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from "vitest";
 import parse from "./testHelpers";
+import TestScopeUtils from "./testUtils";
 import VariableCollector from "../collectors/VariableCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import TypeResolver from "../../../../../utils/TypeResolver";
 
 describe("VariableCollector", () => {
   describe("basic variable extraction", () => {
@@ -12,11 +13,15 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
-      expect(symbol.kind).toBe(ESymbolKind.Variable);
+      expect(symbol.kind).toBe("variable");
       expect(symbol.name).toBe("counter");
-      expect(symbol.type).toBe("u32");
+      expect(TypeResolver.getTypeName(symbol.type)).toBe("u32");
       expect(symbol.isConst).toBe(false);
       expect(symbol.isArray).toBe(false);
       expect(symbol.sourceFile).toBe("test.cnx");
@@ -30,9 +35,13 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
-      expect(symbol.type).toBe("i64");
+      expect(TypeResolver.getTypeName(symbol.type)).toBe("i64");
     });
 
     it("collects variable with initial value", () => {
@@ -41,7 +50,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.initialValue).toBe("0");
     });
@@ -54,7 +67,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isConst).toBe(true);
       expect(symbol.initialValue).toBe("1024");
@@ -66,7 +83,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.initialValue).toBe("0xDEADBEEF");
     });
@@ -79,7 +100,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([256]);
@@ -91,7 +116,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([4, 4]);
@@ -107,7 +136,7 @@ describe("VariableCollector", () => {
       const symbol = VariableCollector.collect(
         varCtx,
         "test.cnx",
-        undefined,
+        TestScopeUtils.getGlobalScope(),
         true,
         constValues,
       );
@@ -126,7 +155,7 @@ describe("VariableCollector", () => {
       const symbol = VariableCollector.collect(
         varCtx,
         "test.cnx",
-        undefined,
+        TestScopeUtils.getGlobalScope(),
         true,
         constValues,
       );
@@ -148,7 +177,7 @@ describe("VariableCollector", () => {
       const symbol = VariableCollector.collect(
         varCtx,
         "test.cnx",
-        undefined,
+        TestScopeUtils.getGlobalScope(),
         true,
         constValues,
       );
@@ -163,7 +192,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([8]);
@@ -175,7 +208,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([4, 4]);
@@ -191,7 +228,7 @@ describe("VariableCollector", () => {
       const symbol = VariableCollector.collect(
         varCtx,
         "test.cnx",
-        undefined,
+        TestScopeUtils.getGlobalScope(),
         true,
         constValues,
       );
@@ -206,7 +243,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual(["BUFFER_SIZE"]);
@@ -214,15 +255,19 @@ describe("VariableCollector", () => {
   });
 
   describe("scoped variables", () => {
-    it("prefixes name with scope when scopeName is provided", () => {
+    it("stores scope reference when scope is provided", () => {
       const code = `
         u32 position;
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const symbol = VariableCollector.collect(varCtx, "motor.cnx", motorScope);
 
-      expect(symbol.name).toBe("Motor_position");
+      // With new IScopeSymbol-based design, name is just "position" (not prefixed)
+      // The prefixing happens in TSymbolAdapter for backwards compatibility
+      expect(symbol.name).toBe("position");
+      expect(symbol.scope.name).toBe("Motor");
     });
 
     it("respects isPublic parameter", () => {
@@ -231,10 +276,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const symbol = VariableCollector.collect(
         varCtx,
         "motor.cnx",
-        "Motor",
+        motorScope,
         false,
       );
 
@@ -249,9 +295,13 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
-      expect(symbol.type).toBe("Point");
+      expect(TypeResolver.getTypeName(symbol.type)).toBe("Point");
     });
   });
 
@@ -263,7 +313,11 @@ describe("VariableCollector", () => {
       `;
       const tree = parse(code);
       const varCtx = tree.declaration(0)!.variableDeclaration()!;
-      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.sourceLine).toBe(3);
     });

package/src/transpiler/logic/symbols/cnext/__tests__/testUtils.ts

@@ -0,0 +1,53 @@
+/**
+ * Test utilities for symbol collector tests.
+ *
+ * Provides mock IScopeSymbol instances for testing collectors
+ * that now require proper scope references.
+ *
+ * Note: Delegates to ScopeUtils to avoid code duplication.
+ */
+
+import ScopeUtils from "../../../../../utils/ScopeUtils";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+
+/**
+ * Static utility class for creating mock scopes in tests.
+ *
+ * Note: Each call creates a fresh scope instance to avoid test pollution.
+ * Tests should use SymbolRegistry.reset() in beforeEach for state isolation.
+ */
+class TestScopeUtils {
+  /**
+   * Create the global scope singleton for tests.
+   * The global scope has a self-reference for parent.
+   */
+  static createMockGlobalScope(): IScopeSymbol {
+    return ScopeUtils.createGlobalScope();
+  }
+
+  /**
+   * Create a named scope for tests.
+   */
+  static createMockScope(name: string, parent?: IScopeSymbol): IScopeSymbol {
+    const actualParent = parent ?? ScopeUtils.createGlobalScope();
+    return ScopeUtils.createScope(name, actualParent);
+  }
+
+  /**
+   * Get a fresh global scope instance.
+   * Returns a new instance each time to avoid test pollution.
+   */
+  static getGlobalScope(): IScopeSymbol {
+    return ScopeUtils.createGlobalScope();
+  }
+
+  /**
+   * Reset global scope (no-op, kept for backwards compatibility).
+   * @deprecated Use SymbolRegistry.reset() instead for test isolation.
+   */
+  static resetGlobalScope(): void {
+    // No-op - each call to getGlobalScope() now returns a fresh instance
+  }
+}
+
+export default TestScopeUtils;

package/src/transpiler/logic/symbols/cnext/adapters/TSymbolInfoAdapter.ts

@@ -10,15 +10,16 @@
 
 import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
 import CNEXT_TO_C_TYPE_MAP from "../../../../../utils/constants/TypeMappings";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import TSymbol from "../../types/TSymbol";
-import IBitmapSymbol from "../../types/IBitmapSymbol";
-import IEnumSymbol from "../../types/IEnumSymbol";
-import IFunctionSymbol from "../../types/IFunctionSymbol";
-import IStructSymbol from "../../types/IStructSymbol";
-import IRegisterSymbol from "../../types/IRegisterSymbol";
-import IScopeSymbol from "../../types/IScopeSymbol";
-import IVariableSymbol from "../../types/IVariableSymbol";
+import TSymbol from "../../../../types/symbols/TSymbol";
+import IBitmapSymbol from "../../../../types/symbols/IBitmapSymbol";
+import IEnumSymbol from "../../../../types/symbols/IEnumSymbol";
+import IFunctionSymbol from "../../../../types/symbols/IFunctionSymbol";
+import IStructSymbol from "../../../../types/symbols/IStructSymbol";
+import IRegisterSymbol from "../../../../types/symbols/IRegisterSymbol";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import IVariableSymbol from "../../../../types/symbols/IVariableSymbol";
+import TypeResolver from "../../../../../utils/TypeResolver";
+import SymbolNameUtils from "../utils/SymbolNameUtils";
 
 /**
  * Groups register-related maps for processRegister method.
@@ -94,7 +95,7 @@ class TSymbolInfoAdapter {
     // Process each symbol
     for (const symbol of symbols) {
       switch (symbol.kind) {
-        case ESymbolKind.Struct:
+        case "struct":
           TSymbolInfoAdapter.processStruct(
             symbol,
             knownStructs,
@@ -104,11 +105,11 @@ class TSymbolInfoAdapter {
           );
           break;
 
-        case ESymbolKind.Enum:
+        case "enum":
           TSymbolInfoAdapter.processEnum(symbol, knownEnums, enumMembers);
           break;
 
-        case ESymbolKind.Bitmap:
+        case "bitmap":
           TSymbolInfoAdapter.processBitmap(
             symbol,
             knownBitmaps,
@@ -118,7 +119,7 @@ class TSymbolInfoAdapter {
           );
           break;
 
-        case ESymbolKind.Namespace:
+        case "scope":
           TSymbolInfoAdapter.processScope(
             symbol,
             knownScopes,
@@ -127,7 +128,7 @@ class TSymbolInfoAdapter {
           );
           break;
 
-        case ESymbolKind.Register:
+        case "register":
           TSymbolInfoAdapter.processRegister(symbol, knownBitmaps, {
             knownRegisters,
             scopedRegisters,
@@ -139,13 +140,17 @@ class TSymbolInfoAdapter {
           });
           break;
 
-        case ESymbolKind.Variable:
-          // Issue #282: Track private const values for inlining
-          TSymbolInfoAdapter.processVariable(symbol, scopePrivateConstValues);
+        case "variable":
+          // Track scope membership and private const values
+          TSymbolInfoAdapter.processVariable(
+            symbol,
+            scopeMembers,
+            scopePrivateConstValues,
+          );
           break;
 
         // Track function return types for enum validation
-        case ESymbolKind.Function:
+        case "function":
           TSymbolInfoAdapter.processFunction(symbol, functionReturnTypes);
           break;
       }
@@ -226,6 +231,9 @@ class TSymbolInfoAdapter {
 
   // === Private Processing Methods ===
 
+  // Use shared utility for name mangling
+  private static readonly getMangledName = SymbolNameUtils.getMangledName;
+
   private static processStruct(
     struct: IStructSymbol,
     knownStructs: Set<string>,
@@ -233,28 +241,38 @@ class TSymbolInfoAdapter {
     structFieldArrays: Map<string, Set<string>>,
     structFieldDimensions: Map<string, Map<string, number[]>>,
   ): void {
-    knownStructs.add(struct.name);
+    // Use mangled name for lookups (e.g., "Geometry_Point")
+    const mangledName = TSymbolInfoAdapter.getMangledName(struct);
+    knownStructs.add(mangledName);
 
     const fields = new Map<string, string>();
     const arrayFields = new Set<string>();
     const dimensions = new Map<string, number[]>();
 
     for (const [fieldName, fieldInfo] of struct.fields) {
-      fields.set(fieldName, fieldInfo.type);
+      // Convert TType to string for legacy ISymbolInfo format
+      const typeStr = TypeResolver.getTypeName(fieldInfo.type);
+      fields.set(fieldName, typeStr);
 
       if (fieldInfo.isArray) {
         arrayFields.add(fieldName);
 
         if (fieldInfo.dimensions && fieldInfo.dimensions.length > 0) {
-          dimensions.set(fieldName, fieldInfo.dimensions);
+          // Filter to only include numeric dimensions
+          const numericDims = fieldInfo.dimensions.filter(
+            (d): d is number => typeof d === "number",
+          );
+          if (numericDims.length > 0) {
+            dimensions.set(fieldName, numericDims);
+          }
         }
       }
     }
 
-    structFields.set(struct.name, fields);
-    structFieldArrays.set(struct.name, arrayFields);
+    structFields.set(mangledName, fields);
+    structFieldArrays.set(mangledName, arrayFields);
     if (dimensions.size > 0) {
-      structFieldDimensions.set(struct.name, dimensions);
+      structFieldDimensions.set(mangledName, dimensions);
     }
   }
 
@@ -263,8 +281,9 @@ class TSymbolInfoAdapter {
     knownEnums: Set<string>,
     enumMembers: Map<string, Map<string, number>>,
   ): void {
-    knownEnums.add(enumSym.name);
-    enumMembers.set(enumSym.name, new Map(enumSym.members));
+    const mangledName = TSymbolInfoAdapter.getMangledName(enumSym);
+    knownEnums.add(mangledName);
+    enumMembers.set(mangledName, new Map(enumSym.members));
   }
 
   private static processBitmap(
@@ -274,9 +293,10 @@ class TSymbolInfoAdapter {
     bitmapBackingType: Map<string, string>,
     bitmapBitWidth: Map<string, number>,
   ): void {
-    knownBitmaps.add(bitmap.name);
-    bitmapBackingType.set(bitmap.name, bitmap.backingType);
-    bitmapBitWidth.set(bitmap.name, bitmap.bitWidth);
+    const mangledName = TSymbolInfoAdapter.getMangledName(bitmap);
+    knownBitmaps.add(mangledName);
+    bitmapBackingType.set(mangledName, bitmap.backingType);
+    bitmapBitWidth.set(mangledName, bitmap.bitWidth);
 
     const fields = new Map<string, { offset: number; width: number }>();
     for (const [fieldName, fieldInfo] of bitmap.fields) {
@@ -285,7 +305,7 @@ class TSymbolInfoAdapter {
         width: fieldInfo.width,
       });
     }
-    bitmapFields.set(bitmap.name, fields);
+    bitmapFields.set(mangledName, fields);
   }
 
   private static processScope(
@@ -296,8 +316,10 @@ class TSymbolInfoAdapter {
   ): void {
     knownScopes.add(scope.name);
 
-    // Convert members array to Set
-    scopeMembers.set(scope.name, new Set(scope.members));
+    // Use scope.members as the authoritative list of member names
+    // This includes functions, variables, enums, structs, etc.
+    const members = new Set<string>(scope.members);
+    scopeMembers.set(scope.name, members);
 
     // Copy visibility map
     scopeMemberVisibility.set(scope.name, new Map(scope.memberVisibility));
@@ -308,16 +330,18 @@ class TSymbolInfoAdapter {
     knownBitmaps: Set<string>,
     maps: IRegisterMaps,
   ): void {
-    maps.knownRegisters.add(register.name);
-    maps.registerBaseAddresses.set(register.name, register.baseAddress);
-
-    // Check if this is a scoped register (name contains underscore)
-    if (register.name.includes("_")) {
-      maps.scopedRegisters.set(register.name, register.baseAddress);
+    const mangledName = TSymbolInfoAdapter.getMangledName(register);
+    maps.knownRegisters.add(mangledName);
+    maps.registerBaseAddresses.set(mangledName, register.baseAddress);
+
+    // Check if this is a scoped register (has non-global scope)
+    const isScoped = register.scope.name !== "";
+    if (isScoped) {
+      maps.scopedRegisters.set(mangledName, register.baseAddress);
     }
 
     for (const [memberName, memberInfo] of register.members) {
-      const fullName = `${register.name}_${memberName}`;
+      const fullName = `${mangledName}_${memberName}`;
 
       maps.registerMemberAccess.set(fullName, memberInfo.access);
       maps.registerMemberOffsets.set(fullName, memberInfo.offset);
@@ -335,11 +359,24 @@ class TSymbolInfoAdapter {
 
   private static processVariable(
     variable: IVariableSymbol,
+    scopeMembers: Map<string, Set<string>>,
     scopePrivateConstValues: Map<string, string>,
   ): void {
+    const mangledName = TSymbolInfoAdapter.getMangledName(variable);
+    const scopeName = variable.scope.name;
+    const isScoped = scopeName !== "";
+
+    // Track scoped variables as scope members (needed for name resolution)
+    if (isScoped) {
+      let members = scopeMembers.get(scopeName);
+      if (!members) {
+        members = new Set<string>();
+        scopeMembers.set(scopeName, members);
+      }
+      members.add(variable.name); // Add local name (e.g., "value"), not mangled
+    }
+
     // Issue #282: Track private const values for inlining
-    // A scoped variable has an underscore in its name (e.g., "Motor_MAX_SPEED")
-    const isScoped = variable.name.includes("_");
     const isPrivate = !variable.isExported;
 
     // Issue #500: Only inline SCALAR consts, not arrays - arrays must be emitted
@@ -350,7 +387,7 @@ class TSymbolInfoAdapter {
       variable.initialValue &&
       !variable.isArray
     ) {
-      scopePrivateConstValues.set(variable.name, variable.initialValue);
+      scopePrivateConstValues.set(mangledName, variable.initialValue);
     }
   }
 
@@ -360,7 +397,10 @@ class TSymbolInfoAdapter {
   ): void {
     // Track function return types for enum validation in assignments
     // This enables recognizing that Motor.getMode() returns Motor_EMode
-    functionReturnTypes.set(func.name, func.returnType);
+    // Use mangled name (e.g., "Motor_getMode") for lookup consistency
+    const mangledName = TSymbolInfoAdapter.getMangledName(func);
+    const returnTypeStr = TypeResolver.getTypeName(func.returnType);
+    functionReturnTypes.set(mangledName, returnTypeStr);
   }
 
   private static cnextTypeToCType(typeName: string): string {

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

@@ -1,15 +1,17 @@
 /**
  * BitmapCollector - Extracts bitmap type declarations from parse trees.
  * ADR-034: Bitmaps provide named access to bit regions within an integer backing type.
+ *
+ * Produces TType-based IBitmapSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IBitmapSymbol from "../../types/IBitmapSymbol";
-import IBitmapFieldInfo from "../../types/IBitmapFieldInfo";
-import BITMAP_SIZE from "../../../../types/BITMAP_SIZE";
-import BITMAP_BACKING_TYPE from "../../../../types/BITMAP_BACKING_TYPE";
+import IBitmapSymbol from "../../../../types/symbols/IBitmapSymbol";
+import IBitmapFieldInfo from "../../../../types/symbols/IBitmapFieldInfo";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import BITMAP_SIZE from "../../../../constants/BITMAP_SIZE";
+import BITMAP_BACKING_TYPE from "../../../../constants/BITMAP_BACKING_TYPE";
 
 class BitmapCollector {
   /**
@@ -17,17 +19,16 @@ class BitmapCollector {
    *
    * @param ctx The bitmap declaration context
    * @param sourceFile Source file path
-   * @param scopeName Optional scope name for nested bitmaps
-   * @returns The bitmap symbol
+   * @param scope The scope this bitmap belongs to (IScopeSymbol)
+   * @returns The bitmap symbol with proper scope reference
    * @throws Error if total bits don't match bitmap size
    */
   static collect(
     ctx: Parser.BitmapDeclarationContext,
     sourceFile: string,
-    scopeName?: string,
+    scope: IScopeSymbol,
   ): IBitmapSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const bitmapType = ctx.bitmapType().getText();
     const expectedBits = BITMAP_SIZE[bitmapType];
     const backingType = BITMAP_BACKING_TYPE[bitmapType];
@@ -51,18 +52,18 @@ class BitmapCollector {
     // Validate total bits equals bitmap size
     if (totalBits !== expectedBits) {
       throw new Error(
-        `Error: Bitmap '${fullName}' has ${totalBits} bits but ${bitmapType} requires exactly ${expectedBits} bits`,
+        `Error: Bitmap '${name}' has ${totalBits} bits but ${bitmapType} requires exactly ${expectedBits} bits`,
       );
     }
 
     return {
-      name: fullName,
-      parent: scopeName,
+      kind: "bitmap",
+      name,
+      scope,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
-      kind: ESymbolKind.Bitmap,
       backingType,
       bitWidth: expectedBits,
       fields,