c-next 0.1.64 → 0.1.66

package/src/transpiler/logic/parser/grammar/CNextVisitor.ts

@@ -89,6 +89,7 @@ import { TemplateArgumentListContext } from "./CNextParser.js";
 import { TemplateArgumentContext } from "./CNextParser.js";
 import { StringTypeContext } from "./CNextParser.js";
 import { ArrayTypeContext } from "./CNextParser.js";
+import { ArrayTypeDimensionContext } from "./CNextParser.js";
 import { LiteralContext } from "./CNextParser.js";
 
 
@@ -616,6 +617,12 @@ export class CNextVisitor<Result> extends AbstractParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitArrayType?: (ctx: ArrayTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by `CNextParser.arrayTypeDimension`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitArrayTypeDimension?: (ctx: ArrayTypeDimensionContext) => Result;
     /**
      * Visit a parse tree produced by `CNextParser.literal`.
      * @param ctx the parse tree

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

@@ -77,9 +77,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].isConst).toBe(true);
     });
 
-    it("handles array parameters", () => {
+    it("handles array parameters (C-Next style)", () => {
       const code = `
-        void processArray(u8 data[]) {
+        void processArray(u8[] data) {
         }
       `;
       const tree = parse(code);
@@ -90,9 +90,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].arrayDimensions).toEqual([""]);
     });
 
-    it("handles sized array parameters", () => {
+    it("handles sized array parameters (C-Next style)", () => {
       const code = `
-        void processBuffer(u8 buffer[256]) {
+        void processBuffer(u8[256] buffer) {
         }
       `;
       const tree = parse(code);
@@ -103,9 +103,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].arrayDimensions).toEqual(["256"]);
     });
 
-    it("handles multi-dimensional array parameters", () => {
+    it("handles multi-dimensional array parameters (C-Next style)", () => {
       const code = `
-        void processMatrix(f32 matrix[4][4]) {
+        void processMatrix(f32[4][4] matrix) {
         }
       `;
       const tree = parse(code);

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

@@ -463,4 +463,183 @@ describe("TSymbolAdapter", () => {
       expect(symbolTable.getStructFieldType("Point", "x")).toBe("i32");
     });
   });
+
+  describe("enum member resolution in array dimensions", () => {
+    it("resolves unqualified enum member in variable array dimension", () => {
+      const enumSym: IEnumSymbol = {
+        kind: ESymbolKind.Enum,
+        name: "EColor",
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        members: new Map([
+          ["RED", 0],
+          ["GREEN", 1],
+          ["BLUE", 2],
+          ["COUNT", 3],
+        ]),
+      };
+
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: ["COUNT"], // Unqualified enum member
+      };
+
+      const result = TSymbolAdapter.toISymbols(
+        [enumSym, variable],
+        symbolTable,
+      );
+
+      // Find the variable symbol
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym).toBeDefined();
+      expect(varSym!.arrayDimensions).toEqual(["EColor_COUNT"]);
+    });
+
+    it("resolves enum member in function parameter array dimension", () => {
+      const enumSym: IEnumSymbol = {
+        kind: ESymbolKind.Enum,
+        name: "Size",
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        members: new Map([
+          ["SMALL", 10],
+          ["MEDIUM", 20],
+          ["LARGE", 30],
+        ]),
+      };
+
+      const funcSym: IFunctionSymbol = {
+        kind: ESymbolKind.Function,
+        name: "process",
+        sourceFile: "test.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: "void",
+        visibility: "public",
+        parameters: [
+          {
+            name: "buffer",
+            type: "u8",
+            isConst: false,
+            isArray: true,
+            arrayDimensions: ["MEDIUM"], // Unqualified enum member
+          },
+        ],
+      };
+
+      const result = TSymbolAdapter.toISymbols([enumSym, funcSym], symbolTable);
+
+      // Find the function symbol
+      const funcResult = result.find(
+        (s) => s.kind === ESymbolKind.Function && s.name === "process",
+      );
+      expect(funcResult).toBeDefined();
+      expect(funcResult!.parameters).toBeDefined();
+      expect(funcResult!.parameters![0].arrayDimensions).toEqual([
+        "Size_MEDIUM",
+      ]);
+    });
+
+    it("does not resolve ambiguous enum member (exists in multiple enums)", () => {
+      const enum1: IEnumSymbol = {
+        kind: ESymbolKind.Enum,
+        name: "EColor",
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        members: new Map([["COUNT", 3]]),
+      };
+
+      const enum2: IEnumSymbol = {
+        kind: ESymbolKind.Enum,
+        name: "ESize",
+        sourceFile: "test.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        members: new Map([
+          ["COUNT", 5], // Same member name in different enum
+        ]),
+      };
+
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: ["COUNT"], // Ambiguous - exists in both enums
+      };
+
+      const result = TSymbolAdapter.toISymbols(
+        [enum1, enum2, variable],
+        symbolTable,
+      );
+
+      // Find the variable symbol - dimension should NOT be resolved
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym).toBeDefined();
+      expect(varSym!.arrayDimensions).toEqual(["COUNT"]); // Left as-is
+    });
+
+    it("preserves numeric array dimensions", () => {
+      const enumSym: IEnumSymbol = {
+        kind: ESymbolKind.Enum,
+        name: "EColor",
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        members: new Map([["COUNT", 3]]),
+      };
+
+      const variable: IVariableSymbol = {
+        kind: ESymbolKind.Variable,
+        name: "DATA",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: "u8",
+        isConst: true,
+        isAtomic: false,
+        isArray: true,
+        arrayDimensions: [256], // Numeric dimension
+      };
+
+      const result = TSymbolAdapter.toISymbols(
+        [enumSym, variable],
+        symbolTable,
+      );
+
+      const varSym = result.find(
+        (s) => s.kind === ESymbolKind.Variable && s.name === "DATA",
+      );
+      expect(varSym!.arrayDimensions).toEqual(["256"]);
+    });
+  });
 });

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

@@ -156,6 +156,61 @@ describe("VariableCollector", () => {
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([10, 20]);
     });
+
+    it("collects C-Next style array with dimensions in type (u8[8] arr)", () => {
+      const code = `
+        u8[8] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([8]);
+    });
+
+    it("collects C-Next style multi-dimensional array (u8[4][4] arr)", () => {
+      const code = `
+        u8[4][4] matrix;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([4, 4]);
+    });
+
+    it("collects C-Next style array with const reference dimension", () => {
+      const code = `
+        u8[SIZE] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const constValues = new Map<string, number>([["SIZE", 16]]);
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        undefined,
+        true,
+        constValues,
+      );
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([16]);
+    });
+
+    it("preserves unresolved macro as string in C-Next style array", () => {
+      const code = `
+        u8[BUFFER_SIZE] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual(["BUFFER_SIZE"]);
+    });
   });
 
   describe("scoped variables", () => {

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

@@ -40,6 +40,9 @@ class TSymbolAdapter {
    * @returns Array of flat ISymbol objects for Pipeline consumption
    */
   static toISymbols(symbols: TSymbol[], symbolTable: SymbolTable): ISymbol[] {
+    // First pass: Build enum member lookup for array dimension resolution
+    const enumMemberLookup = TSymbolAdapter.buildEnumMemberLookup(symbols);
+
     const result: ISymbol[] = [];
 
     for (const symbol of symbols) {
@@ -54,10 +57,12 @@ class TSymbolAdapter {
           result.push(TSymbolAdapter.convertStruct(symbol, symbolTable));
           break;
         case ESymbolKind.Function:
-          result.push(...TSymbolAdapter.convertFunction(symbol));
+          result.push(
+            ...TSymbolAdapter.convertFunction(symbol, enumMemberLookup),
+          );
           break;
         case ESymbolKind.Variable:
-          result.push(TSymbolAdapter.convertVariable(symbol));
+          result.push(TSymbolAdapter.convertVariable(symbol, enumMemberLookup));
           break;
         case ESymbolKind.Register:
           result.push(...TSymbolAdapter.convertRegister(symbol));
@@ -71,6 +76,57 @@ class TSymbolAdapter {
     return result;
   }
 
+  /**
+   * Build a lookup map from enum member names to their fully-qualified enum names.
+   * Used to resolve unqualified enum members in array dimensions.
+   *
+   * If a member name exists in multiple enums, it's marked as ambiguous (null value)
+   * and will not be resolved (the header will fail to compile, surfacing the issue).
+   */
+  private static buildEnumMemberLookup(
+    symbols: TSymbol[],
+  ): Map<string, string | null> {
+    const lookup = new Map<string, string | null>();
+
+    for (const symbol of symbols) {
+      if (symbol.kind !== ESymbolKind.Enum) continue;
+
+      for (const memberName of symbol.members.keys()) {
+        if (lookup.has(memberName)) {
+          // Ambiguous: member exists in multiple enums
+          lookup.set(memberName, null);
+        } else {
+          lookup.set(memberName, symbol.name);
+        }
+      }
+    }
+
+    return lookup;
+  }
+
+  /**
+   * Resolve an array dimension string, adding enum prefix if it's an unqualified enum member.
+   */
+  private static resolveArrayDimension(
+    dim: number | string,
+    enumMemberLookup: Map<string, string | null>,
+  ): string {
+    // Numeric dimensions don't need resolution
+    if (typeof dim === "number") {
+      return String(dim);
+    }
+
+    // Check if this is an unqualified enum member
+    const enumName = enumMemberLookup.get(dim);
+    if (enumName) {
+      // Found in exactly one enum - add the prefix
+      return `${enumName}_${dim}`;
+    }
+
+    // Not an enum member, or ambiguous - return as-is
+    return dim;
+  }
+
   /**
    * Convert IBitmapSymbol to ISymbol + BitmapField symbols.
    */
@@ -180,21 +236,27 @@ class TSymbolAdapter {
 
   /**
    * Convert IFunctionSymbol to ISymbol + parameter symbols for hover support.
+   * Resolves unqualified enum members in parameter array dimensions.
    */
-  private static convertFunction(func: IFunctionSymbol): ISymbol[] {
+  private static convertFunction(
+    func: IFunctionSymbol,
+    enumMemberLookup: Map<string, string | null>,
+  ): ISymbol[] {
     const result: ISymbol[] = [];
 
     // Build parameter types for signature
     const paramTypes = func.parameters.map((p) => p.type);
     const signature = `${func.returnType} ${func.name}(${paramTypes.join(", ")})`;
 
-    // Build parameter info for header generation
+    // Build parameter info for header generation, resolving enum members in dimensions
     const parameters = func.parameters.map((p) => ({
       name: p.name,
       type: p.type,
       isConst: p.isConst,
       isArray: p.isArray,
-      arrayDimensions: p.arrayDimensions,
+      arrayDimensions: p.arrayDimensions?.map((dim) =>
+        TSymbolAdapter.resolveArrayDimension(dim, enumMemberLookup),
+      ),
       isAutoConst: p.isAutoConst,
     }));
 
@@ -233,10 +295,16 @@ class TSymbolAdapter {
 
   /**
    * Convert IVariableSymbol to ISymbol.
+   * Resolves unqualified enum members in array dimensions.
    */
-  private static convertVariable(variable: IVariableSymbol): ISymbol {
-    // Convert dimensions to string dimensions for ISymbol
-    const arrayDimensions = variable.arrayDimensions?.map(String);
+  private static convertVariable(
+    variable: IVariableSymbol,
+    enumMemberLookup: Map<string, string | null>,
+  ): ISymbol {
+    // Convert dimensions to string dimensions, resolving enum member references
+    const arrayDimensions = variable.arrayDimensions?.map((dim) =>
+      TSymbolAdapter.resolveArrayDimension(dim, enumMemberLookup),
+    );
 
     // Get first dimension for legacy size field (only if numeric)
     const firstDim = variable.arrayDimensions?.[0];

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

@@ -70,17 +70,16 @@ class FunctionCollector {
       const type = TypeUtils.getTypeName(typeCtx, scopeName);
       const isConst = p.constModifier() !== null;
 
-      const arrayDims = p.arrayDimension();
-      const isArray = arrayDims.length > 0;
+      // Check for C-Next style array type (u8[8] param, u8[4][4] param, u8[] param)
+      const arrayTypeCtx = typeCtx.arrayType();
+      const hasArrayType = arrayTypeCtx !== null;
 
-      // Extract array dimensions as strings (can contain expressions like SIZE)
+      // Extract array dimensions from arrayType syntax (supports multi-dimensional)
       const arrayDimensions: string[] = [];
-      if (isArray) {
-        for (const dim of arrayDims) {
-          const text = dim.getText();
-          const regex = /\[([^\]]*)\]/;
-          const match = regex.exec(text);
-          arrayDimensions.push(match ? match[1] : ""); // "" means unbounded
+      if (hasArrayType) {
+        for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+          const sizeExpr = dim.expression();
+          arrayDimensions.push(sizeExpr ? sizeExpr.getText() : "");
         }
       }
 
@@ -88,7 +87,7 @@ class FunctionCollector {
         name,
         type,
         isConst,
-        isArray,
+        isArray: hasArrayType,
       };
 
       if (arrayDimensions.length > 0) {

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

@@ -30,7 +30,13 @@ function processArrayTypeSyntax(
     return { isArray: false, dimension: undefined };
   }
 
-  const sizeExpr = arrayTypeCtx.expression();
+  // Get the first dimension (for backwards compatibility with single-dimension code)
+  const dims = arrayTypeCtx.arrayTypeDimension();
+  if (dims.length === 0) {
+    return { isArray: true, dimension: undefined };
+  }
+
+  const sizeExpr = dims[0].expression();
   if (!sizeExpr) {
     return { isArray: true, dimension: undefined };
   }

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

@@ -71,6 +71,32 @@ class VariableCollector {
     return dimensions;
   }
 
+  /**
+   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr).
+   */
+  private static collectArrayTypeDimensions(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    constValues: Map<string, number> | undefined,
+  ): (number | string)[] {
+    const dimensions: (number | string)[] = [];
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const sizeExpr = dim.expression();
+      if (!sizeExpr) continue;
+
+      const dimText = sizeExpr.getText();
+      const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
+      if (literalSize !== undefined) {
+        dimensions.push(literalSize);
+      } else if (constValues?.has(dimText)) {
+        dimensions.push(constValues.get(dimText)!);
+      } else {
+        // Keep as string for macro/enum references
+        dimensions.push(dimText);
+      }
+    }
+    return dimensions;
+  }
+
   /**
    * Collect a variable declaration and return an IVariableSymbol.
    *
@@ -110,21 +136,14 @@ class VariableCollector {
     const initExpr = ctx.expression();
     const arrayDimensions: (number | string)[] = [];
 
-    // Collect dimension from arrayType syntax (u16[8] arr)
+    // Collect dimensions from arrayType syntax (u16[8] arr, u16[4][4] arr, u16[] arr)
     if (hasArrayTypeSyntax) {
-      const sizeExpr = arrayTypeCtx.expression();
-      if (sizeExpr) {
-        const dimText = sizeExpr.getText();
-        const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
-        if (literalSize !== undefined) {
-          arrayDimensions.push(literalSize);
-        } else if (constValues?.has(dimText)) {
-          arrayDimensions.push(constValues.get(dimText)!);
-        } else {
-          // Keep as string for macro/enum references
-          arrayDimensions.push(dimText);
-        }
-      }
+      arrayDimensions.push(
+        ...VariableCollector.collectArrayTypeDimensions(
+          arrayTypeCtx,
+          constValues,
+        ),
+      );
     }
 
     // Collect additional dimensions from arrayDimension syntax