c-next 0.1.65 → 0.1.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",
@@ -118,5 +118,9 @@
     "*.ts": [
       "oxlint --fix"
     ]
+  },
+  "volta": {
+    "node": "24.13.1",
+    "npm": "11.8.0"
   }
 }

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/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/output/codegen/CodeGenerator.ts

@@ -134,6 +134,9 @@ import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 import CastValidator from "./helpers/CastValidator";
 // Global state for code generation (simplifies debugging, eliminates DI complexity)
 import CodeGenState from "./CodeGenState";
+// Unified parameter generation (Phase 1)
+import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
+import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
 // Extracted resolvers that use CodeGenState
 import SizeofResolver from "./resolution/SizeofResolver";
 import EnumTypeResolver from "./resolution/EnumTypeResolver";
@@ -802,30 +805,54 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #137: Check for array element access (e.g., names[0], arr[i])
+    return this._isArrayAccessStringExpression(text);
+  }
+
+  /**
+   * Check if array access expression evaluates to a string.
+   * Extracted from isStringExpression to reduce cognitive complexity.
+   */
+  private _isArrayAccessStringExpression(text: string): boolean {
     // Pattern: identifier[expression] or identifier[expression][expression]...
     // BUT NOT if accessing .length/.capacity/.size (those return numbers, not strings)
     const arrayAccessMatch = /^([a-zA-Z_]\w*)\[/.exec(text);
-    if (arrayAccessMatch) {
-      // ADR-045: String properties return numeric values, not strings
-      if (
-        text.endsWith(".length") ||
-        text.endsWith(".capacity") ||
-        text.endsWith(".size")
-      ) {
-        return false;
-      }
-      const arrayName = arrayAccessMatch[1];
-      const typeInfo = CodeGenState.typeRegistry.get(arrayName);
-      // Check if base type is a string type
-      if (
-        typeInfo?.isString ||
-        (typeInfo?.baseType && TypeCheckUtils.isString(typeInfo.baseType))
-      ) {
-        return true;
-      }
+    if (!arrayAccessMatch) {
+      return false;
     }
 
-    return false;
+    // ADR-045: String properties return numeric values, not strings
+    if (
+      text.endsWith(".length") ||
+      text.endsWith(".capacity") ||
+      text.endsWith(".size")
+    ) {
+      return false;
+    }
+
+    const arrayName = arrayAccessMatch[1];
+    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    if (!typeInfo) {
+      return false;
+    }
+
+    // Check if it's an ARRAY OF STRINGS (not a single string being indexed)
+    // A single string<50> has arrayDimensions=[51] (just the char buffer)
+    // An array of strings string<50>[10] has arrayDimensions=[10, 51]
+    // Single string indexing (e.g., userName[i]) returns a char, not a string
+    // Array of strings indexing (e.g., names[0]) returns a string
+    if (typeInfo.isString) {
+      // For strings, only treat as string expression if it's an array of strings
+      // (arrayDimensions.length > 1 means it's string<N>[M], not just string<N>)
+      const dims = typeInfo.arrayDimensions;
+      return Array.isArray(dims) && dims.length > 1;
+    }
+
+    // Non-string array with string base type
+    return Boolean(
+      typeInfo.isArray &&
+      typeInfo.baseType &&
+      TypeCheckUtils.isString(typeInfo.baseType),
+    );
   }
 
   /**
@@ -1505,7 +1532,9 @@ export default class CodeGenerator implements IOrchestrator {
                 return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
               } else if (p.isPointer) {
                 // ADR-006: Non-array, non-callback parameters become pointers
-                return `${constMod}${p.type}*`;
+                // In C++ mode, use reference (&) instead of pointer (*)
+                const ptrOrRef = this.isCppMode() ? "&" : "*";
+                return `${constMod}${p.type}${ptrOrRef}`;
               } else {
                 // ADR-029: Callback parameters are already function pointers
                 return `${p.type}`;
@@ -2373,9 +2402,13 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private addGeneratedHelpers(output: string[]): void {
     if (CodeGenState.needsFloatStaticAssert) {
+      // Use static_assert for C++ (standard), _Static_assert for C11
+      const assertKeyword = this.isCppMode()
+        ? "static_assert"
+        : "_Static_assert";
       output.push(
-        '_Static_assert(sizeof(float) == 4, "Float bit indexing requires 32-bit float");',
-        '_Static_assert(sizeof(double) == 8, "Float bit indexing requires 64-bit double");',
+        `${assertKeyword}(sizeof(float) == 4, "Float bit indexing requires 32-bit float");`,
+        `${assertKeyword}(sizeof(double) == 8, "Float bit indexing requires 64-bit double");`,
         "",
       );
     }
@@ -5273,16 +5306,47 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   private generateParameter(ctx: Parser.ParameterContext): string {
-    const constMod = ctx.constModifier() ? "const " : "";
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
-    const dims = ctx.arrayDimension();
 
-    // Reject ALL C-style array parameters - require C-Next style (dimensions in type)
-    // C-style: u8 data[8], u8 data[4][4], u8 data[]
-    // C-Next:  u8[8] data, u8[4][4] data, u8[] data
+    // Validate: Reject C-style array parameters
+    this._validateCStyleArrayParam(ctx, typeName, name);
+
+    // Validate: Reject unbounded array dimensions
+    this._validateUnboundedArrayParam(ctx);
+
+    // Pre-compute CodeGenState-dependent values
+    const isModified = this._isCurrentParameterModified(name);
+    const isPassByValue = this._isPassByValueType(typeName, name);
+
+    // Build normalized input using adapter
+    const input = ParameterInputAdapter.fromAST(ctx, {
+      getTypeName: (t) => this.getTypeName(t),
+      generateType: (t) => this.generateType(t),
+      generateExpression: (e) => this.generateExpression(e),
+      callbackTypes: CodeGenState.callbackTypes,
+      isKnownStruct: (t) => this.isKnownStruct(t),
+      typeMap: TYPE_MAP,
+      isModified,
+      isPassByValue,
+    });
+
+    // Use shared builder with C/C++ mode
+    return ParameterSignatureBuilder.build(input, CppModeHelper.refOrPtr());
+  }
+
+  /**
+   * Validate: Reject C-style array parameters
+   * C-style: u8 data[8], u8 data[4][4], u8 data[]
+   * C-Next:  u8[8] data, u8[4][4] data, u8[] data
+   */
+  private _validateCStyleArrayParam(
+    ctx: Parser.ParameterContext,
+    typeName: string,
+    name: string,
+  ): void {
+    const dims = ctx.arrayDimension();
     if (dims.length > 0) {
-      const baseType = typeName;
       const dimensions = dims
         .map((dim) => `[${dim.expression()?.getText() ?? ""}]`)
         .join("");
@@ -5290,73 +5354,28 @@ export default class CodeGenerator implements IOrchestrator {
       const col = ctx.start?.column ?? 0;
       throw new Error(
         `${line}:${col} C-style array parameter is not allowed. ` +
-          `Use '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`,
+          `Use '${typeName}${dimensions} ${name}' instead of '${typeName} ${name}${dimensions}'`,
       );
     }
+  }
 
-    // ADR-029: Check if this is a callback type parameter
-    if (CodeGenState.callbackTypes.has(typeName)) {
-      const callbackInfo = CodeGenState.callbackTypes.get(typeName)!;
-      return `${callbackInfo.typedefName} ${name}`;
-    }
-
-    const type = this.generateType(ctx.type());
-
-    // Handle C-Next style array type in parameter (e.g., u8[8] param, u8[4][4] param, string<32>[5] param)
+  /**
+   * Validate: Reject unbounded array dimensions for memory safety
+   */
+  private _validateUnboundedArrayParam(ctx: Parser.ParameterContext): void {
     const arrayTypeCtx = ctx.type().arrayType();
-    if (arrayTypeCtx) {
-      // Check for unbounded dimensions - reject for memory safety
-      const allDims = arrayTypeCtx.arrayTypeDimension();
-      const hasUnboundedDim = allDims.some((d) => !d.expression());
-      if (hasUnboundedDim) {
-        const line = ctx.start?.line ?? 0;
-        const col = ctx.start?.column ?? 0;
-        throw new Error(
-          `${line}:${col} Unbounded array parameters are not allowed. ` +
-            `All dimensions must have explicit sizes for memory safety.`,
-        );
-      }
-
-      let dims = allDims
-        .map((d) => {
-          const expr = d.expression();
-          return expr ? `[${this.generateExpression(expr)}]` : "[]";
-        })
-        .join("");
-      // For string arrays, add the string capacity dimension (string<32>[5] -> char[5][33])
-      if (arrayTypeCtx.stringType()) {
-        const stringCtx = arrayTypeCtx.stringType()!;
-        const intLiteral = stringCtx.INTEGER_LITERAL();
-        if (intLiteral) {
-          const capacity = Number.parseInt(intLiteral.getText(), 10);
-          dims += `[${capacity + 1}]`;
-        }
-      }
-      const wasModified = this._isCurrentParameterModified(name);
-      const autoConst = !wasModified && !constMod ? "const " : "";
-      return `${autoConst}${constMod}${type} ${name}${dims}`;
-    }
+    if (!arrayTypeCtx) return;
 
-    // Pass-by-value types
-    if (this._isPassByValueType(typeName, name)) {
-      return `${constMod}${type} ${name}`;
+    const allDims = arrayTypeCtx.arrayTypeDimension();
+    const hasUnboundedDim = allDims.some((d) => !d.expression());
+    if (hasUnboundedDim) {
+      const line = ctx.start?.line ?? 0;
+      const col = ctx.start?.column ?? 0;
+      throw new Error(
+        `${line}:${col} Unbounded array parameters are not allowed. ` +
+          `All dimensions must have explicit sizes for memory safety.`,
+      );
     }
-
-    // Non-array string parameters
-    const stringResult = this._tryGenerateStringParam(
-      ctx,
-      constMod,
-      name,
-      dims,
-    );
-    if (stringResult) return stringResult;
-
-    // Pass-by-reference types
-    const refResult = this._tryGenerateRefParam(constMod, type, typeName, name);
-    if (refResult) return refResult;
-
-    // Unknown types use pass-by-value (standard C semantics)
-    return `${constMod}${type} ${name}`;
   }
 
   /**
@@ -5366,7 +5385,7 @@ export default class CodeGenerator implements IOrchestrator {
     // ISR, float, enum types
     if (typeName === "ISR") return true;
     if (this._isFloatType(typeName)) return true;
-    if (CodeGenState.symbols!.knownEnums.has(typeName)) return true;
+    if (CodeGenState.symbols?.knownEnums.has(typeName)) return true;
 
     // Small unmodified primitives
     if (
@@ -5379,43 +5398,6 @@ export default class CodeGenerator implements IOrchestrator {
     return false;
   }
 
-  /**
-   * Try to generate non-array string parameter: string<N> -> char*
-   */
-  private _tryGenerateStringParam(
-    ctx: Parser.ParameterContext,
-    constMod: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (!ctx.type().stringType() || dims.length !== 0) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    return `${autoConst}${constMod}char* ${name}`;
-  }
-
-  /**
-   * Try to generate pass-by-reference parameter for known types
-   */
-  private _tryGenerateRefParam(
-    constMod: string,
-    type: string,
-    typeName: string,
-    name: string,
-  ): string | null {
-    if (!this.isKnownStruct(typeName) && !this._isKnownPrimitive(typeName)) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    const refOrPtr = CppModeHelper.refOrPtr();
-    return `${autoConst}${constMod}${type}${refOrPtr} ${name}`;
-  }
-
   // ========================================================================
   // Variables
   // ========================================================================