c-next 0.1.69 → 0.1.71

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

@@ -1,12 +1,14 @@
 /**
  * EnumCollector - Extracts enum type declarations from parse trees.
  * ADR-017: Enums provide named integer constants with auto-increment support.
+ *
+ * Produces TType-based IEnumSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IEnumSymbol from "../../types/IEnumSymbol";
+import IEnumSymbol from "../../../../types/symbols/IEnumSymbol";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
 import ExpressionEvaluator from "../utils/ExpressionEvaluator";
 
 class EnumCollector {
@@ -15,17 +17,16 @@ class EnumCollector {
    *
    * @param ctx The enum declaration context
    * @param sourceFile Source file path
-   * @param scopeName Optional scope name for nested enums
-   * @returns The enum symbol
+   * @param scope The scope this enum belongs to (IScopeSymbol)
+   * @returns The enum symbol with proper scope reference
    * @throws Error if any member has a negative value
    */
   static collect(
     ctx: Parser.EnumDeclarationContext,
     sourceFile: string,
-    scopeName?: string,
+    scope: IScopeSymbol,
   ): IEnumSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const line = ctx.start?.line ?? 0;
 
     // Collect member values with auto-increment
@@ -42,7 +43,7 @@ class EnumCollector {
 
         if (value < 0) {
           throw new Error(
-            `Error: Negative values not allowed in enum (found ${value} in ${fullName}.${memberName})`,
+            `Error: Negative values not allowed in enum (found ${value} in ${name}.${memberName})`,
           );
         }
 
@@ -54,13 +55,13 @@ class EnumCollector {
     }
 
     return {
-      name: fullName,
-      parent: scopeName,
+      kind: "enum",
+      name,
+      scope,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
-      kind: ESymbolKind.Enum,
       members,
     };
   }

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

@@ -1,14 +1,18 @@
 /**
  * FunctionCollector - Extracts function declarations from parse trees.
  * Handles return types, parameters, visibility, and signature generation.
+ *
+ * Produces TType-based IFunctionSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IFunctionSymbol from "../../types/IFunctionSymbol";
-import IParameterInfo from "../../types/IParameterInfo";
+import IFunctionSymbol from "../../../../types/symbols/IFunctionSymbol";
+import IParameterInfo from "../../../../types/symbols/IParameterInfo";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import TypeResolver from "../../../../../utils/TypeResolver";
 import TypeUtils from "../utils/TypeUtils";
+import SymbolRegistry from "../../../../state/SymbolRegistry";
 
 class FunctionCollector {
   /**
@@ -16,49 +20,89 @@ class FunctionCollector {
    *
    * @param ctx The function declaration context
    * @param sourceFile Source file path
-   * @param scopeName Optional scope name for nested functions
+   * @param scope The scope this function belongs to (IScopeSymbol)
+   * @param body AST reference for the function body
    * @param visibility Visibility for scope functions (default "private")
-   * @returns The function symbol
+   * @returns The function symbol with TType-based types and scope reference
    */
   static collect(
     ctx: Parser.FunctionDeclarationContext,
     sourceFile: string,
-    scopeName?: string,
+    scope: IScopeSymbol,
+    body: Parser.BlockContext | null,
     visibility: "public" | "private" = "private",
   ): IFunctionSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const line = ctx.start?.line ?? 0;
 
-    // Get return type
+    // Get return type string and convert to TType
     const returnTypeCtx = ctx.type();
-    const returnType = TypeUtils.getTypeName(returnTypeCtx, scopeName);
+    const scopeName = scope.name === "" ? undefined : scope.name;
+    const returnTypeStr = TypeUtils.getTypeName(returnTypeCtx, scopeName);
+    const returnType = TypeResolver.resolve(returnTypeStr);
 
-    // Collect parameters
+    // Collect parameters with TType
     const params = ctx.parameterList()?.parameter() ?? [];
     const parameters = FunctionCollector.collectParameters(params, scopeName);
 
-    // Generate signature for overload detection
-    const paramTypes = parameters.map((p) => p.type);
-    const signature = `${returnType} ${fullName}(${paramTypes.join(", ")})`;
-
     return {
-      name: fullName,
-      parent: scopeName,
+      kind: "function",
+      name,
+      scope,
+      parameters,
+      returnType,
+      visibility,
+      body,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: visibility === "public",
-      kind: ESymbolKind.Function,
-      returnType,
-      parameters,
-      visibility,
-      signature,
     };
   }
 
+  /**
+   * Collect a function declaration and register it in SymbolRegistry.
+   *
+   * This method:
+   * 1. Gets or creates the appropriate scope in SymbolRegistry
+   * 2. Collects the function with TType-based types
+   * 3. Registers the function in that scope
+   *
+   * @param ctx The function declaration context
+   * @param sourceFile Source file path
+   * @param scopeName Optional scope name for nested functions
+   * @param body AST reference for the function body
+   * @param visibility Visibility for scope functions (default "private")
+   * @returns The function symbol
+   */
+  static collectAndRegister(
+    ctx: Parser.FunctionDeclarationContext,
+    sourceFile: string,
+    scopeName: string | undefined,
+    body: Parser.BlockContext,
+    visibility: "public" | "private" = "private",
+  ): IFunctionSymbol {
+    // 1. Get or create the scope in SymbolRegistry
+    const scope = SymbolRegistry.getOrCreateScope(scopeName ?? "");
+
+    // 2. Collect function with TType-based types and scope reference
+    const symbol = FunctionCollector.collect(
+      ctx,
+      sourceFile,
+      scope,
+      body,
+      visibility,
+    );
+
+    // 3. Register in SymbolRegistry
+    SymbolRegistry.registerFunction(symbol);
+
+    return symbol;
+  }
+
   /**
    * Extract parameter information from parameter contexts.
+   * Converts type strings to TType.
    */
   private static collectParameters(
     params: Parser.ParameterContext[],
@@ -67,34 +111,39 @@ class FunctionCollector {
     return params.map((p) => {
       const name = p.IDENTIFIER().getText();
       const typeCtx = p.type();
-      const type = TypeUtils.getTypeName(typeCtx, scopeName);
+      const typeStr = TypeUtils.getTypeName(typeCtx, scopeName);
+      const type = TypeResolver.resolve(typeStr);
       const isConst = p.constModifier() !== null;
 
       // Check for C-Next style array type (u8[8] param, u8[4][4] param, u8[] param)
       const arrayTypeCtx = typeCtx.arrayType();
-      const hasArrayType = arrayTypeCtx !== null;
+      const isArray = arrayTypeCtx !== null;
 
       // Extract array dimensions from arrayType syntax (supports multi-dimensional)
-      const arrayDimensions: string[] = [];
-      if (hasArrayType) {
+      const arrayDimensions: (number | string)[] = [];
+      if (isArray) {
         for (const dim of arrayTypeCtx.arrayTypeDimension()) {
           const sizeExpr = dim.expression();
-          arrayDimensions.push(sizeExpr ? sizeExpr.getText() : "");
+          if (sizeExpr) {
+            const dimStr = sizeExpr.getText();
+            const dimNum = Number.parseInt(dimStr, 10);
+            // Convert numeric strings to numbers, keep others as strings
+            arrayDimensions.push(Number.isNaN(dimNum) ? dimStr : dimNum);
+          } else {
+            // Unbounded array dimension
+            arrayDimensions.push("");
+          }
         }
       }
 
-      const paramInfo: IParameterInfo = {
+      return {
         name,
         type,
         isConst,
-        isArray: hasArrayType,
+        isArray,
+        arrayDimensions:
+          arrayDimensions.length > 0 ? arrayDimensions : undefined,
       };
-
-      if (arrayDimensions.length > 0) {
-        paramInfo.arrayDimensions = arrayDimensions;
-      }
-
-      return paramInfo;
     });
   }
 }

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

@@ -1,13 +1,15 @@
 /**
  * RegisterCollector - Extracts register block declarations from parse trees.
  * Registers provide typed access to memory-mapped I/O locations.
+ *
+ * Produces TType-based IRegisterSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IRegisterSymbol from "../../types/IRegisterSymbol";
-import IRegisterMemberInfo from "../../types/IRegisterMemberInfo";
+import IRegisterSymbol from "../../../../types/symbols/IRegisterSymbol";
+import IRegisterMemberInfo from "../../../../types/symbols/IRegisterMemberInfo";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
 import TypeUtils from "../utils/TypeUtils";
 
 /** Access mode type for register members */
@@ -20,18 +22,18 @@ class RegisterCollector {
    * @param ctx The register declaration context
    * @param sourceFile Source file path
    * @param knownBitmaps Set of known bitmap type names for reference resolution
-   * @param scopeName Optional scope name for nested registers
-   * @returns The register symbol
+   * @param scope The scope this register belongs to (IScopeSymbol)
+   * @returns The register symbol with proper scope reference
    */
   static collect(
     ctx: Parser.RegisterDeclarationContext,
     sourceFile: string,
     knownBitmaps: Set<string>,
-    scopeName?: string,
+    scope: IScopeSymbol,
   ): IRegisterSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const line = ctx.start?.line ?? 0;
+    const scopeName = scope.name === "" ? undefined : scope.name;
 
     // Get base address
     const baseAddress = ctx.expression().getText();
@@ -48,32 +50,34 @@ class RegisterCollector {
       const typeName = TypeUtils.getTypeName(member.type(), scopeName);
       const cType = TypeUtils.cnextTypeToCType(typeName);
 
-      const memberInfo: IRegisterMemberInfo = {
-        offset,
-        cType,
-        access: accessMod,
-      };
-
       // Check if member type is a bitmap
       // Try both scoped name and plain name for bitmap lookup
       const scopedTypeName = scopeName ? `${scopeName}_${typeName}` : typeName;
+      let bitmapType: string | undefined;
       if (knownBitmaps.has(scopedTypeName)) {
-        memberInfo.bitmapType = scopedTypeName;
+        bitmapType = scopedTypeName;
       } else if (knownBitmaps.has(typeName)) {
-        memberInfo.bitmapType = typeName;
+        bitmapType = typeName;
       }
 
+      const memberInfo: IRegisterMemberInfo = {
+        offset,
+        cType,
+        access: accessMod,
+        bitmapType,
+      };
+
       members.set(memberName, memberInfo);
     }
 
     return {
-      name: fullName,
-      parent: scopeName,
+      kind: "register",
+      name,
+      scope,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
-      kind: ESymbolKind.Register,
       baseAddress,
       members,
     };

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

@@ -1,14 +1,17 @@
 /**
  * ScopeCollector - Extracts scope declarations and their nested members.
  * ADR-016: Scopes group related functions and control member visibility.
+ *
+ * Produces TType-based symbols with proper IScopeSymbol references.
+ * Uses SymbolRegistry for scope management.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IScopeSymbol from "../../types/IScopeSymbol";
-import TSymbol from "../../types/TSymbol";
+import TSymbol from "../../../../types/symbols/TSymbol";
+import TVisibility from "../../../../types/TVisibility";
 import IScopeCollectorResult from "../types/IScopeCollectorResult";
+import SymbolRegistry from "../../../../state/SymbolRegistry";
 import BitmapCollector from "./BitmapCollector";
 import EnumCollector from "./EnumCollector";
 import StructCollector from "./StructCollector";
@@ -20,6 +23,13 @@ class ScopeCollector {
   /**
    * Collect a scope declaration and all its nested members.
    *
+   * Uses SymbolRegistry to get/create the scope, ensuring proper scope
+   * references in all member symbols.
+   *
+   * **Side-effect**: This method calls SymbolRegistry.getOrCreateScope(),
+   * which creates the scope in global state if it doesn't exist. Tests
+   * should call SymbolRegistry.reset() in beforeEach to ensure isolation.
+   *
    * @param ctx The scope declaration context
    * @param sourceFile Source file path
    * @param knownBitmaps Set of known bitmap type names for register resolution
@@ -35,28 +45,47 @@ class ScopeCollector {
     const scopeName = ctx.IDENTIFIER().getText();
     const line = ctx.start?.line ?? 0;
 
-    const memberNames: string[] = [];
-    const memberVisibility = new Map<string, "public" | "private">();
+    // Get or create the scope via SymbolRegistry
+    const scope = SymbolRegistry.getOrCreateScope(scopeName);
+
+    // Update scope metadata (cast to mutable for initialization)
+    const mutableScope = scope as {
+      sourceFile: string;
+      sourceLine: number;
+      sourceLanguage: ESourceLanguage;
+      isExported: boolean;
+    };
+    mutableScope.sourceFile = sourceFile;
+    mutableScope.sourceLine = line;
+    mutableScope.sourceLanguage = ESourceLanguage.CNext;
+    mutableScope.isExported = true;
+
+    // Cast readonly collections to mutable (scope is being populated)
+    const memberVisibility = scope.memberVisibility as unknown as Map<
+      string,
+      TVisibility
+    >;
+    const members = scope.members as unknown as string[];
     const memberSymbols: TSymbol[] = [];
 
     for (const member of ctx.scopeMember()) {
       // ADR-016: Extract visibility (private by default)
       const visibilityMod = member.visibilityModifier();
-      const visibility: "public" | "private" =
-        (visibilityMod?.getText() as "public" | "private") ?? "private";
+      const visibility: TVisibility =
+        (visibilityMod?.getText() as TVisibility) ?? "private";
       const isPublic = visibility === "public";
 
       // Handle variable declarations
       if (member.variableDeclaration()) {
         const varDecl = member.variableDeclaration()!;
         const varName = varDecl.IDENTIFIER().getText();
-        memberNames.push(varName);
         memberVisibility.set(varName, visibility);
+        members.push(varName);
 
         const varSymbol = VariableCollector.collect(
           varDecl,
           sourceFile,
-          scopeName,
+          scope,
           isPublic,
           constValues,
         );
@@ -67,13 +96,16 @@ class ScopeCollector {
       if (member.functionDeclaration()) {
         const funcDecl = member.functionDeclaration()!;
         const funcName = funcDecl.IDENTIFIER().getText();
-        memberNames.push(funcName);
         memberVisibility.set(funcName, visibility);
+        members.push(funcName);
 
-        const funcSymbol = FunctionCollector.collect(
+        // Use collectAndRegister to populate both memberSymbols and SymbolRegistry
+        const body = funcDecl.block();
+        const funcSymbol = FunctionCollector.collectAndRegister(
           funcDecl,
           sourceFile,
           scopeName,
+          body,
           visibility,
         );
         memberSymbols.push(funcSymbol);
@@ -83,14 +115,10 @@ class ScopeCollector {
       if (member.enumDeclaration()) {
         const enumDecl = member.enumDeclaration()!;
         const enumName = enumDecl.IDENTIFIER().getText();
-        memberNames.push(enumName);
         memberVisibility.set(enumName, visibility);
+        members.push(enumName);
 
-        const enumSymbol = EnumCollector.collect(
-          enumDecl,
-          sourceFile,
-          scopeName,
-        );
+        const enumSymbol = EnumCollector.collect(enumDecl, sourceFile, scope);
         memberSymbols.push(enumSymbol);
       }
 
@@ -98,13 +126,13 @@ class ScopeCollector {
       if (member.bitmapDeclaration()) {
         const bitmapDecl = member.bitmapDeclaration()!;
         const bitmapName = bitmapDecl.IDENTIFIER().getText();
-        memberNames.push(bitmapName);
         memberVisibility.set(bitmapName, visibility);
+        members.push(bitmapName);
 
         const bitmapSymbol = BitmapCollector.collect(
           bitmapDecl,
           sourceFile,
-          scopeName,
+          scope,
         );
         memberSymbols.push(bitmapSymbol);
       }
@@ -113,13 +141,14 @@ class ScopeCollector {
       if (member.structDeclaration()) {
         const structDecl = member.structDeclaration()!;
         const structName = structDecl.IDENTIFIER().getText();
-        memberNames.push(structName);
         memberVisibility.set(structName, visibility);
+        members.push(structName);
 
         const structSymbol = StructCollector.collect(
           structDecl,
           sourceFile,
-          scopeName,
+          scope,
+          constValues,
         );
         memberSymbols.push(structSymbol);
       }
@@ -128,31 +157,20 @@ class ScopeCollector {
       if (member.registerDeclaration()) {
         const regDecl = member.registerDeclaration()!;
         const regName = regDecl.IDENTIFIER().getText();
-        memberNames.push(regName);
         memberVisibility.set(regName, visibility);
+        members.push(regName);
 
         const regSymbol = RegisterCollector.collect(
           regDecl,
           sourceFile,
           knownBitmaps,
-          scopeName,
+          scope,
         );
         memberSymbols.push(regSymbol);
       }
     }
 
-    const scopeSymbol: IScopeSymbol = {
-      name: scopeName,
-      sourceFile,
-      sourceLine: line,
-      sourceLanguage: ESourceLanguage.CNext,
-      isExported: true,
-      kind: ESymbolKind.Namespace,
-      members: memberNames,
-      memberVisibility,
-    };
-
-    return { scopeSymbol, memberSymbols };
+    return { scopeSymbol: scope, memberSymbols };
   }
 }
 

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

@@ -1,13 +1,16 @@
 /**
  * StructCollector - Extracts struct type declarations from parse trees.
  * Handles fields with types, arrays, and const modifiers.
+ *
+ * Produces TType-based IStructSymbol with proper IScopeSymbol references.
  */
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import IStructSymbol from "../../types/IStructSymbol";
-import IFieldInfo from "../../types/IFieldInfo";
+import IStructSymbol from "../../../../types/symbols/IStructSymbol";
+import IFieldInfo from "../../../../types/symbols/IFieldInfo";
+import IScopeSymbol from "../../../../types/symbols/IScopeSymbol";
+import TypeResolver from "../../../../../utils/TypeResolver";
 import TypeUtils from "../utils/TypeUtils";
 import LiteralUtils from "../../../../../utils/LiteralUtils";
 
@@ -51,7 +54,7 @@ function processArrayTypeSyntax(
 function processStringField(
   stringCtx: Parser.StringTypeContext,
   arrayDims: Parser.ArrayDimensionContext[],
-  dimensions: number[],
+  dimensions: (number | string)[],
   constValues?: Map<string, number>,
 ): boolean {
   const intLiteral = stringCtx.INTEGER_LITERAL();
@@ -94,7 +97,7 @@ function tryResolveExpressionDimension(
  */
 function parseArrayDimensions(
   arrayDims: Parser.ArrayDimensionContext[],
-  dimensions: number[],
+  dimensions: (number | string)[],
   constValues?: Map<string, number>,
 ): void {
   for (const dim of arrayDims) {
@@ -114,58 +117,65 @@ class StructCollector {
    *
    * @param ctx The struct declaration context
    * @param sourceFile Source file path
-   * @param scopeName Optional scope name for nested structs
+   * @param scope The scope this struct belongs to (IScopeSymbol)
    * @param constValues Map of constant names to their numeric values (for resolving array dimensions)
-   * @returns The struct symbol
+   * @returns The struct symbol with TType-based types and scope reference
    */
   static collect(
     ctx: Parser.StructDeclarationContext,
     sourceFile: string,
-    scopeName?: string,
+    scope: IScopeSymbol,
     constValues?: Map<string, number>,
   ): IStructSymbol {
     const name = ctx.IDENTIFIER().getText();
-    const fullName = scopeName ? `${scopeName}_${name}` : name;
     const line = ctx.start?.line ?? 0;
+    const scopeName = scope.name === "" ? undefined : scope.name;
 
     const fields = new Map<string, IFieldInfo>();
 
     for (const member of ctx.structMember()) {
+      const fieldName = member.IDENTIFIER().getText();
       const fieldInfo = StructCollector.collectField(
         member,
+        fieldName,
         scopeName,
         constValues,
       );
-      fields.set(member.IDENTIFIER().getText(), fieldInfo);
+      fields.set(fieldName, fieldInfo);
     }
 
     return {
-      name: fullName,
-      parent: scopeName,
+      kind: "struct",
+      name,
+      scope,
       sourceFile,
       sourceLine: line,
       sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
-      kind: ESymbolKind.Struct,
       fields,
     };
   }
 
   /**
    * Collect a single struct field and return its IFieldInfo.
+   * Now includes name and TType-based type.
    */
   private static collectField(
     member: Parser.StructMemberContext,
+    fieldName: string,
     scopeName?: string,
     constValues?: Map<string, number>,
   ): IFieldInfo {
     const typeCtx = member.type();
-    const fieldType = TypeUtils.getTypeName(typeCtx, scopeName);
+    const fieldTypeStr = TypeUtils.getTypeName(typeCtx, scopeName);
+    const fieldType = TypeResolver.resolve(fieldTypeStr);
     // Note: C-Next struct members don't have const modifier in grammar
     const isConst = false;
+    // C-Next struct members don't have atomic modifier
+    const isAtomic = false;
 
     const arrayDims = member.arrayDimension();
-    const dimensions: number[] = [];
+    const dimensions: (number | string)[] = [];
     let isArray = false;
 
     // Check for C-Next style arrayType syntax: Item[3] items -> typeCtx.arrayType()
@@ -200,17 +210,14 @@ class StructCollector {
       parseArrayDimensions(arrayDims, dimensions, constValues);
     }
 
-    const fieldInfo: IFieldInfo = {
+    return {
+      name: fieldName,
       type: fieldType,
-      isArray,
       isConst,
+      isAtomic,
+      isArray,
+      dimensions: dimensions.length > 0 ? dimensions : undefined,
     };
-
-    if (dimensions.length > 0) {
-      fieldInfo.dimensions = dimensions;
-    }
-
-    return fieldInfo;
   }
 }