c-next 0.1.62 → 0.1.63

package/src/transpiler/output/codegen/generators/declarationGenerators/__tests__/ScopeGenerator.test.ts

@@ -42,10 +42,35 @@ function createMockConstModifier(
   return isConst ? ({} as Parser.ConstModifierContext) : null;
 }
 
+/**
+ * Create a mock array type context.
+ */
+function createMockArrayType(sizeExpr?: string | null) {
+  if (sizeExpr === null) {
+    // Empty brackets - no expression
+    return {
+      expression: () => null,
+    };
+  }
+  return {
+    expression: () =>
+      sizeExpr
+        ? {
+            getText: () => sizeExpr,
+            __mockValue: sizeExpr,
+          }
+        : null,
+  };
+}
+
 /**
  * Create a mock type context.
  */
-function createMockType(typeName: string, hasStringType = false) {
+function createMockType(
+  typeName: string,
+  hasStringType = false,
+  arrayTypeSize?: string | null,
+) {
   return {
     getText: () => typeName,
     stringType: () =>
@@ -54,6 +79,8 @@ function createMockType(typeName: string, hasStringType = false) {
             INTEGER_LITERAL: () => ({ getText: () => "32" }),
           }
         : null,
+    arrayType: () =>
+      arrayTypeSize !== undefined ? createMockArrayType(arrayTypeSize) : null,
   };
 }
 
@@ -99,10 +126,16 @@ function createMockVariableDecl(options: {
   hasStringType?: boolean;
   constructorArgs?: string[];
   startLine?: number;
+  arrayTypeSize?: string | null; // C-Next style: u16[8] name
 }) {
   return {
     IDENTIFIER: () => ({ getText: () => options.name }),
-    type: () => createMockType(options.type, options.hasStringType),
+    type: () =>
+      createMockType(
+        options.type,
+        options.hasStringType,
+        options.arrayTypeSize,
+      ),
     constModifier: () => createMockConstModifier(options.isConst ?? false),
     expression: () =>
       options.initialValue ? createMockExpression(options.initialValue) : null,
@@ -207,10 +240,11 @@ function createMockStructMember(
   type: string,
   arrayDims?: string[],
   hasStringType = false,
+  arrayTypeSize?: string | null,
 ) {
   return {
     IDENTIFIER: () => ({ getText: () => name }),
-    type: () => createMockType(type, hasStringType),
+    type: () => createMockType(type, hasStringType, arrayTypeSize),
     arrayDimension: () => (arrayDims ?? []).map(createMockArrayDimension),
   };
 }
@@ -225,13 +259,20 @@ function createMockStructDecl(
     type: string;
     arrayDims?: string[];
     hasStringType?: boolean;
+    arrayTypeSize?: string | null;
   }>,
 ) {
   return {
     IDENTIFIER: () => ({ getText: () => name }),
     structMember: () =>
       members.map((m) =>
-        createMockStructMember(m.name, m.type, m.arrayDims, m.hasStringType),
+        createMockStructMember(
+          m.name,
+          m.type,
+          m.arrayDims,
+          m.hasStringType,
+          m.arrayTypeSize,
+        ),
       ),
   };
 }
@@ -579,6 +620,66 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("static uint8_t Serial_buffer[256] = {0};");
     });
 
+    it("generates C-Next style array variable with constant size", () => {
+      const varDecl = createMockVariableDecl({
+        name: "data",
+        type: "u16[8]",
+        arrayTypeSize: "8",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Buffer", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => 8),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("static u16[8] Buffer_data[8] = {0};");
+    });
+
+    it("generates C-Next style array variable with non-constant expression (fallback)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "items",
+        type: "u16[BUFFER_SIZE]",
+        arrayTypeSize: "BUFFER_SIZE",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Storage", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => undefined), // Can't resolve macro
+        generateExpression: vi.fn(() => "BUFFER_SIZE"),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain(
+        "static u16[BUFFER_SIZE] Storage_items[BUFFER_SIZE] = {0};",
+      );
+    });
+
+    it("generates C-Next style array variable with no size (empty brackets)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "flexible",
+        type: "u8[]",
+        arrayTypeSize: null, // No size expression
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Dynamic", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("static u8[] Dynamic_flexible[] = {0};");
+    });
+
     it("generates string variable with capacity dimension (ADR-045)", () => {
       const varDecl = createMockVariableDecl({
         name: "message",
@@ -1036,6 +1137,58 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("uint8_t data[256];");
     });
 
+    it("generates struct field with C-Next array type constant size", () => {
+      const structDecl = createMockStructDecl("Container", [
+        { name: "items", type: "u16[4]", arrayTypeSize: "4" },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Data", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => 4),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u16[4] items[4];");
+    });
+
+    it("generates struct field with C-Next array type non-constant (fallback)", () => {
+      const structDecl = createMockStructDecl("FlexContainer", [
+        { name: "buffer", type: "u8[MAX_SIZE]", arrayTypeSize: "MAX_SIZE" },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Flex", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => undefined), // Can't resolve macro
+        generateExpression: vi.fn(() => "MAX_SIZE"),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u8[MAX_SIZE] buffer[MAX_SIZE];");
+    });
+
+    it("generates struct field with C-Next array type no size (empty brackets)", () => {
+      const structDecl = createMockStructDecl("DynamicContainer", [
+        { name: "data", type: "u8[]", arrayTypeSize: null },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Dyn", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u8[] data[];");
+    });
+
     it("generates struct field with string capacity", () => {
       const structDecl = createMockStructDecl("Message", [
         { name: "text", type: "string<64>", hasStringType: true },

package/src/transpiler/output/codegen/generators/support/HelperGenerator.ts

@@ -11,6 +11,27 @@
 import TYPE_MAP from "../../types/TYPE_MAP";
 import OverflowHelperTemplates from "./OverflowHelperTemplates";
 
+/**
+ * Generate a safe arithmetic helper function (div or mod).
+ * Extracted to eliminate duplication between safe_div and safe_mod generation.
+ */
+const generateSafeArithmeticHelper = (
+  opName: string,
+  opSymbol: string,
+  cnxType: string,
+  cType: string,
+): string[] => [
+  `static inline bool cnx_safe_${opName}_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
+  `    if (divisor == 0) {`,
+  `        *output = defaultValue;`,
+  `        return true;  // Error occurred`,
+  `    }`,
+  `    *output = numerator ${opSymbol} divisor;`,
+  `    return false;  // Success`,
+  `}`,
+  "",
+];
+
 /**
  * Generate all needed overflow helper functions
  * ADR-044: Overflow helper functions with clamping or panic behavior
@@ -90,32 +111,12 @@ const generateSafeDivHelpers = (
 
     // Generate safe_div helper if needed
     if (needsDiv) {
-      lines.push(
-        `static inline bool cnx_safe_div_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
-        `    if (divisor == 0) {`,
-        `        *output = defaultValue;`,
-        `        return true;  // Error occurred`,
-        `    }`,
-        `    *output = numerator / divisor;`,
-        `    return false;  // Success`,
-        `}`,
-        "",
-      );
+      lines.push(...generateSafeArithmeticHelper("div", "/", cnxType, cType));
     }
 
     // Generate safe_mod helper if needed
     if (needsMod) {
-      lines.push(
-        `static inline bool cnx_safe_mod_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
-        `    if (divisor == 0) {`,
-        `        *output = defaultValue;`,
-        `        return true;  // Error occurred`,
-        `    }`,
-        `    *output = numerator % divisor;`,
-        `    return false;  // Success`,
-        `}`,
-        "",
-      );
+      lines.push(...generateSafeArithmeticHelper("mod", "%", cnxType, cType));
     }
   }
 

package/src/transpiler/output/codegen/helpers/ArrayInitHelper.ts

@@ -7,18 +7,12 @@
  * - Array initializers with size inference: u8 data[] <- [1, 2, 3]
  * - Fill-all syntax: u8 data[10] <- [0*]
  * - Array size validation
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import TTypeInfo from "../types/TTypeInfo.js";
-
-/**
- * Array initialization tracking state.
- */
-interface IArrayInitState {
-  lastArrayInitCount: number;
-  lastArrayFillValue: string | undefined;
-}
+import CodeGenState from "../CodeGenState.js";
 
 /**
  * Result from processing array initialization.
@@ -33,18 +27,10 @@ interface IArrayInitResult {
 }
 
 /**
- * Dependencies required for array initialization.
+ * Callbacks required for array initialization.
+ * These need CodeGenerator context and cannot be replaced with static state.
  */
-interface IArrayInitHelperDeps {
-  /** Type registry for updating inferred dimensions */
-  typeRegistry: Map<string, TTypeInfo>;
-  /** Local arrays set for tracking */
-  localArrays: Set<string>;
-  /** Array initialization tracking state */
-  arrayInitState: IArrayInitState;
-  /** Get/set expected type context */
-  getExpectedType: () => string | null;
-  setExpectedType: (type: string | null) => void;
+interface IArrayInitCallbacks {
   /** Generate expression code */
   generateExpression: (ctx: Parser.ExpressionContext) => string;
   /** Get type name from type context */
@@ -57,12 +43,6 @@ interface IArrayInitHelperDeps {
  * Handles array initialization with size inference and fill-all syntax.
  */
 class ArrayInitHelper {
-  private readonly deps: IArrayInitHelperDeps;
-
-  constructor(deps: IArrayInitHelperDeps) {
-    this.deps = deps;
-  }
-
   /**
    * Process array initialization expression.
    * Returns null if not an array initializer pattern.
@@ -73,33 +53,46 @@ class ArrayInitHelper {
    * @param arrayDims - Array dimension contexts
    * @param hasEmptyArrayDim - Whether any dimension is empty (for inference)
    * @param declaredSize - First dimension size if explicit, null otherwise
+   * @param callbacks - Callbacks to CodeGenerator methods
    */
-  processArrayInit(
+  static processArrayInit(
     name: string,
     typeCtx: Parser.TypeContext,
     expression: Parser.ExpressionContext,
     arrayDims: Parser.ArrayDimensionContext[],
     hasEmptyArrayDim: boolean,
     declaredSize: number | null,
+    callbacks: IArrayInitCallbacks,
   ): IArrayInitResult | null {
     // Reset and generate initializer
-    this.deps.arrayInitState.lastArrayInitCount = 0;
-    this.deps.arrayInitState.lastArrayFillValue = undefined;
+    CodeGenState.lastArrayInitCount = 0;
+    CodeGenState.lastArrayFillValue = undefined;
 
-    const initValue = this._generateArrayInitValue(typeCtx, expression);
+    const initValue = ArrayInitHelper._generateArrayInitValue(
+      typeCtx,
+      expression,
+      callbacks,
+    );
 
     // Check if it was an array initializer
-    if (!this._isArrayInitializer()) {
+    if (!ArrayInitHelper._isArrayInitializer()) {
       return null;
     }
 
-    this.deps.localArrays.add(name);
+    CodeGenState.localArrays.add(name);
 
     const dimensionSuffix = hasEmptyArrayDim
-      ? this._processSizeInference(name)
-      : this._processExplicitSize(arrayDims, declaredSize);
-
-    const finalInitValue = this._expandFillAllSyntax(initValue, declaredSize);
+      ? ArrayInitHelper._processSizeInference(name)
+      : ArrayInitHelper._processExplicitSize(
+          arrayDims,
+          declaredSize,
+          callbacks,
+        );
+
+    const finalInitValue = ArrayInitHelper._expandFillAllSyntax(
+      initValue,
+      declaredSize,
+    );
 
     return { isArrayInit: true, dimensionSuffix, initValue: finalInitValue };
   }
@@ -107,66 +100,66 @@ class ArrayInitHelper {
   /**
    * Generate the array initializer value with proper expected type
    */
-  private _generateArrayInitValue(
+  private static _generateArrayInitValue(
     typeCtx: Parser.TypeContext,
     expression: Parser.ExpressionContext,
+    callbacks: IArrayInitCallbacks,
   ): string {
-    const typeName = this.deps.getTypeName(typeCtx);
-    const savedExpectedType = this.deps.getExpectedType();
-    this.deps.setExpectedType(typeName);
-    const initValue = this.deps.generateExpression(expression);
-    this.deps.setExpectedType(savedExpectedType);
+    const typeName = callbacks.getTypeName(typeCtx);
+    const savedExpectedType = CodeGenState.expectedType;
+    CodeGenState.expectedType = typeName;
+    const initValue = callbacks.generateExpression(expression);
+    CodeGenState.expectedType = savedExpectedType;
     return initValue;
   }
 
   /**
    * Check if the last expression was an array initializer
    */
-  private _isArrayInitializer(): boolean {
+  private static _isArrayInitializer(): boolean {
     return (
-      this.deps.arrayInitState.lastArrayInitCount > 0 ||
-      this.deps.arrayInitState.lastArrayFillValue !== undefined
+      CodeGenState.lastArrayInitCount > 0 ||
+      CodeGenState.lastArrayFillValue !== undefined
     );
   }
 
   /**
    * Process size inference for empty array dimension (u8 data[] <- [1, 2, 3])
    */
-  private _processSizeInference(name: string): string {
-    if (this.deps.arrayInitState.lastArrayFillValue !== undefined) {
+  private static _processSizeInference(name: string): string {
+    if (CodeGenState.lastArrayFillValue !== undefined) {
       throw new Error(
-        `Error: Fill-all syntax [${this.deps.arrayInitState.lastArrayFillValue}*] requires explicit array size`,
+        `Error: Fill-all syntax [${CodeGenState.lastArrayFillValue}*] requires explicit array size`,
       );
     }
 
     // Update type registry with inferred size for .length support
-    const existingType = this.deps.typeRegistry.get(name);
+    const existingType = CodeGenState.typeRegistry.get(name);
     if (existingType) {
-      existingType.arrayDimensions = [
-        this.deps.arrayInitState.lastArrayInitCount,
-      ];
+      existingType.arrayDimensions = [CodeGenState.lastArrayInitCount];
     }
 
-    return `[${this.deps.arrayInitState.lastArrayInitCount}]`;
+    return `[${CodeGenState.lastArrayInitCount}]`;
   }
 
   /**
    * Process explicit array size with validation
    */
-  private _processExplicitSize(
+  private static _processExplicitSize(
     arrayDims: Parser.ArrayDimensionContext[],
     declaredSize: number | null,
+    callbacks: IArrayInitCallbacks,
   ): string {
-    const dimensionSuffix = this.deps.generateArrayDimensions(arrayDims);
+    const dimensionSuffix = callbacks.generateArrayDimensions(arrayDims);
 
     // Validate size matches if not using fill-all
     if (
       declaredSize !== null &&
-      this.deps.arrayInitState.lastArrayFillValue === undefined &&
-      this.deps.arrayInitState.lastArrayInitCount !== declaredSize
+      CodeGenState.lastArrayFillValue === undefined &&
+      CodeGenState.lastArrayInitCount !== declaredSize
     ) {
       throw new Error(
-        `Error: Array size mismatch - declared [${declaredSize}] but got ${this.deps.arrayInitState.lastArrayInitCount} elements`,
+        `Error: Array size mismatch - declared [${declaredSize}] but got ${CodeGenState.lastArrayInitCount} elements`,
       );
     }
 
@@ -176,18 +169,18 @@ class ArrayInitHelper {
   /**
    * Expand fill-all syntax (e.g., [0*] with size 5 -> {0, 0, 0, 0, 0})
    */
-  private _expandFillAllSyntax(
+  private static _expandFillAllSyntax(
     initValue: string,
     declaredSize: number | null,
   ): string {
     if (
-      this.deps.arrayInitState.lastArrayFillValue === undefined ||
+      CodeGenState.lastArrayFillValue === undefined ||
       declaredSize === null
     ) {
       return initValue;
     }
 
-    const fillVal = this.deps.arrayInitState.lastArrayFillValue;
+    const fillVal = CodeGenState.lastArrayFillValue;
     // C handles {0} correctly, no need to expand
     if (fillVal === "0") {
       return initValue;

package/src/transpiler/output/codegen/helpers/AssignmentExpectedTypeResolver.ts

@@ -5,12 +5,14 @@
  *
  * Sets up expectedType and assignmentContext for expression generation,
  * enabling type-aware resolution of unqualified enum members and overflow behavior.
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import TTypeInfo from "../types/TTypeInfo.js";
 import TOverflowBehavior from "../types/TOverflowBehavior.js";
 import analyzePostfixOps from "../../../../utils/PostfixAnalysisUtils.js";
+import CodeGenState from "../CodeGenState.js";
 
 /**
  * Result of resolving expected type for an assignment target.
@@ -31,41 +33,25 @@ interface IAssignmentContext {
   overflowBehavior: TOverflowBehavior;
 }
 
-/**
- * Dependencies required for expected type resolution.
- */
-interface IExpectedTypeResolverDeps {
-  /** Type registry for looking up variable types */
-  readonly typeRegistry: ReadonlyMap<string, TTypeInfo>;
-  /** Struct field types: structName -> (fieldName -> fieldType) */
-  readonly structFields: ReadonlyMap<string, ReadonlyMap<string, string>>;
-  /** Check if a type is a known struct */
-  isKnownStruct: (typeName: string) => boolean;
-}
-
 /**
  * Resolves expected type for assignment targets.
  */
 class AssignmentExpectedTypeResolver {
-  private readonly deps: IExpectedTypeResolverDeps;
-
-  constructor(deps: IExpectedTypeResolverDeps) {
-    this.deps = deps;
-  }
-
   /**
    * Resolve expected type for an assignment target.
    *
    * @param targetCtx - The assignment target context
    * @returns The resolved expected type and assignment context
    */
-  resolve(targetCtx: Parser.AssignmentTargetContext): IExpectedTypeResult {
+  static resolve(
+    targetCtx: Parser.AssignmentTargetContext,
+  ): IExpectedTypeResult {
     const postfixOps = targetCtx.postfixTargetOp();
     const baseId = targetCtx.IDENTIFIER()?.getText();
 
     // Case 1: Simple identifier (x <- value) - no postfix ops
     if (baseId && postfixOps.length === 0) {
-      return this.resolveForSimpleIdentifier(baseId);
+      return AssignmentExpectedTypeResolver.resolveForSimpleIdentifier(baseId);
     }
 
     // Case 2: Has member access - extract identifiers from postfix chain
@@ -77,7 +63,9 @@ class AssignmentExpectedTypeResolver {
 
       // If we have member access (multiple identifiers), resolve for member chain
       if (identifiers.length >= 2 && !hasSubscript) {
-        return this.resolveForMemberChain(identifiers);
+        return AssignmentExpectedTypeResolver.resolveForMemberChain(
+          identifiers,
+        );
       }
     }
 
@@ -88,8 +76,8 @@ class AssignmentExpectedTypeResolver {
   /**
    * Resolve expected type for a simple identifier target.
    */
-  private resolveForSimpleIdentifier(id: string): IExpectedTypeResult {
-    const typeInfo = this.deps.typeRegistry.get(id);
+  private static resolveForSimpleIdentifier(id: string): IExpectedTypeResult {
+    const typeInfo = CodeGenState.typeRegistry.get(id);
     if (!typeInfo) {
       return { expectedType: null, assignmentContext: null };
     }
@@ -111,15 +99,17 @@ class AssignmentExpectedTypeResolver {
    * Issue #452: Enables type-aware resolution of unqualified enum members
    * for nested access (e.g., config.nested.field).
    */
-  private resolveForMemberChain(identifiers: string[]): IExpectedTypeResult {
+  private static resolveForMemberChain(
+    identifiers: string[],
+  ): IExpectedTypeResult {
     if (identifiers.length < 2) {
       return { expectedType: null, assignmentContext: null };
     }
 
     const rootName = identifiers[0];
-    const rootTypeInfo = this.deps.typeRegistry.get(rootName);
+    const rootTypeInfo = CodeGenState.typeRegistry.get(rootName);
 
-    if (!rootTypeInfo || !this.deps.isKnownStruct(rootTypeInfo.baseType)) {
+    if (!rootTypeInfo || !CodeGenState.isKnownStruct(rootTypeInfo.baseType)) {
       return { expectedType: null, assignmentContext: null };
     }
 
@@ -128,18 +118,19 @@ class AssignmentExpectedTypeResolver {
     // Walk through each member in the chain to find the final field's type
     for (let i = 1; i < identifiers.length && currentStructType; i++) {
       const memberName = identifiers[i];
-      const structFieldTypes = this.deps.structFields.get(currentStructType);
+      const structFieldTypes: ReadonlyMap<string, string> | undefined =
+        CodeGenState.symbols?.structFields.get(currentStructType);
 
       if (!structFieldTypes?.has(memberName)) {
         break;
       }
 
-      const memberType = structFieldTypes.get(memberName)!;
+      const memberType: string = structFieldTypes.get(memberName)!;
 
       if (i === identifiers.length - 1) {
         // Last field in chain - this is the assignment target's type
         return { expectedType: memberType, assignmentContext: null };
-      } else if (this.deps.isKnownStruct(memberType)) {
+      } else if (CodeGenState.isKnownStruct(memberType)) {
         // Intermediate field - continue walking if it's a struct
         currentStructType = memberType;
       } else {