c-next 0.1.61 → 0.1.63

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

@@ -0,0 +1,129 @@
+/**
+ * Helper utilities for generating array access code.
+ * Extracted from CodeGenerator to improve testability.
+ */
+import IArrayAccessInfo from "../types/IArrayAccessInfo";
+import IArrayAccessDeps from "../types/IArrayAccessDeps";
+import BitRangeHelper from "./BitRangeHelper";
+import CodeGenErrors from "./CodeGenErrors";
+
+/**
+ * Helper class for array access code generation.
+ * Works with an intermediate representation (IArrayAccessInfo)
+ * instead of ANTLR parser contexts for testability.
+ */
+class ArrayAccessHelper {
+  /**
+   * Generate the complete array access expression.
+   * Routes to single-index or bit-range based on accessType.
+   */
+  static generate(info: IArrayAccessInfo, deps: IArrayAccessDeps): string {
+    if (info.accessType === "single-index") {
+      return ArrayAccessHelper.generateSingleIndex(info);
+    }
+    return ArrayAccessHelper.generateBitRange(info, deps);
+  }
+
+  /**
+   * Generate single-index access: array[i]
+   * Validates that bitmap types don't use bracket notation.
+   */
+  static generateSingleIndex(info: IArrayAccessInfo): string {
+    ArrayAccessHelper.validateNotBitmap(info);
+    return `${info.resolvedName}[${info.indexExpr}]`;
+  }
+
+  /**
+   * Validate bitmap access is not using bracket notation.
+   * Bitmaps must use named field access (e.g., flags.FIELD_NAME).
+   * @throws Error if attempting bracket indexing on a bitmap type
+   */
+  static validateNotBitmap(info: IArrayAccessInfo): void {
+    if (info.typeInfo?.isBitmap && info.typeInfo.bitmapTypeName) {
+      throw CodeGenErrors.bitmapBracketIndexing(
+        info.line,
+        info.typeInfo.bitmapTypeName,
+        info.rawName,
+      );
+    }
+  }
+
+  /**
+   * Generate bit range access: value[start, width]
+   * Handles both integer and float types.
+   */
+  static generateBitRange(
+    info: IArrayAccessInfo,
+    deps: IArrayAccessDeps,
+  ): string {
+    if (ArrayAccessHelper.isFloatBitRange(info.typeInfo)) {
+      return ArrayAccessHelper.generateFloatBitRange(info, deps);
+    }
+    return ArrayAccessHelper.generateIntegerBitRange(info, deps);
+  }
+
+  /**
+   * Determine if this is a float bit range (needs shadow variable).
+   */
+  static isFloatBitRange(typeInfo: { baseType?: string } | undefined): boolean {
+    return typeInfo?.baseType === "f32" || typeInfo?.baseType === "f64";
+  }
+
+  /**
+   * Generate float bit range read with shadow variable.
+   * Uses memcpy pattern to safely reinterpret float bits.
+   */
+  static generateFloatBitRange(
+    info: IArrayAccessInfo,
+    deps: IArrayAccessDeps,
+  ): string {
+    if (!deps.isInFunctionBody()) {
+      throw CodeGenErrors.floatBitIndexingAtGlobalScope(
+        info.rawName,
+        info.startExpr ?? "0",
+        info.widthExpr ?? "0",
+      );
+    }
+
+    deps.requireInclude("string");
+    deps.requireInclude("float_static_assert");
+
+    const isF64 = info.typeInfo?.baseType === "f64";
+    const shadowType = BitRangeHelper.getShadowType(
+      info.typeInfo?.baseType ?? "f32",
+    );
+    const shadowName = BitRangeHelper.getShadowVarName(info.rawName);
+    const mask = deps.generateBitMask(info.widthExpr ?? "0", isF64);
+
+    // Register shadow variable if not already declared
+    deps.registerFloatShadow(shadowName, shadowType);
+
+    const shadowIsCurrent = deps.isShadowCurrent(shadowName);
+    deps.markShadowCurrent(shadowName);
+
+    return BitRangeHelper.buildFloatBitReadExpr({
+      shadowName,
+      varName: info.resolvedName,
+      start: info.startExpr ?? "0",
+      mask,
+      shadowIsCurrent,
+    });
+  }
+
+  /**
+   * Generate integer bit range read: ((value >> start) & mask)
+   */
+  static generateIntegerBitRange(
+    info: IArrayAccessInfo,
+    deps: IArrayAccessDeps,
+  ): string {
+    const mask = deps.generateBitMask(info.widthExpr ?? "0");
+    return BitRangeHelper.buildIntegerBitReadExpr({
+      varName: info.resolvedName,
+      start: info.startExpr ?? "0",
+      mask,
+    });
+  }
+}
+
+export default ArrayAccessHelper;

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,11 +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.
@@ -30,58 +33,51 @@ 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 {
-    // Case 1: Simple identifier (x <- value)
-    if (
-      targetCtx.IDENTIFIER() &&
-      !targetCtx.memberAccess() &&
-      !targetCtx.arrayAccess()
-    ) {
-      return this.resolveForSimpleIdentifier(targetCtx.IDENTIFIER()!.getText());
+  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 AssignmentExpectedTypeResolver.resolveForSimpleIdentifier(baseId);
     }
 
-    // Case 2: Member access (config.status <- value)
-    if (targetCtx.memberAccess()) {
-      return this.resolveForMemberAccess(targetCtx.memberAccess()!);
+    // Case 2: Has member access - extract identifiers from postfix chain
+    if (baseId && postfixOps.length > 0) {
+      const { identifiers, hasSubscript } = analyzePostfixOps(
+        baseId,
+        postfixOps,
+      );
+
+      // If we have member access (multiple identifiers), resolve for member chain
+      if (identifiers.length >= 2 && !hasSubscript) {
+        return AssignmentExpectedTypeResolver.resolveForMemberChain(
+          identifiers,
+        );
+      }
     }
 
-    // Case 3: Array access - no expected type resolution needed
+    // Case 3: Array access or complex patterns - no expected type resolution
     return { expectedType: null, assignmentContext: null };
   }
 
   /**
    * 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 };
     }
@@ -97,24 +93,23 @@ class AssignmentExpectedTypeResolver {
   }
 
   /**
-   * Resolve expected type for a member access target.
+   * Resolve expected type for a member access chain.
    * Walks the chain of struct types to find the final field's type.
    *
    * Issue #452: Enables type-aware resolution of unqualified enum members
    * for nested access (e.g., config.nested.field).
    */
-  private resolveForMemberAccess(
-    memberAccessCtx: Parser.MemberAccessContext,
+  private static resolveForMemberChain(
+    identifiers: string[],
   ): IExpectedTypeResult {
-    const identifiers = memberAccessCtx.IDENTIFIER();
     if (identifiers.length < 2) {
       return { expectedType: null, assignmentContext: null };
     }
 
-    const rootName = identifiers[0].getText();
-    const rootTypeInfo = this.deps.typeRegistry.get(rootName);
+    const rootName = identifiers[0];
+    const rootTypeInfo = CodeGenState.typeRegistry.get(rootName);
 
-    if (!rootTypeInfo || !this.deps.isKnownStruct(rootTypeInfo.baseType)) {
+    if (!rootTypeInfo || !CodeGenState.isKnownStruct(rootTypeInfo.baseType)) {
       return { expectedType: null, assignmentContext: null };
     }
 
@@ -122,19 +117,20 @@ 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].getText();
-      const structFieldTypes = this.deps.structFields.get(currentStructType);
+      const memberName = identifiers[i];
+      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 {

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

@@ -16,6 +16,7 @@ interface IAssignmentTargetResult {
 
 /**
  * Extracts base identifier from various assignment target patterns.
+ * With unified grammar, all patterns use IDENTIFIER postfixTargetOp*.
  */
 class AssignmentTargetExtractor {
   /**
@@ -33,53 +34,24 @@ class AssignmentTargetExtractor {
       return { baseIdentifier: null, hasSingleIndexSubscript: false };
     }
 
-    // Simple identifier: x <- value
-    if (target.IDENTIFIER()) {
-      return {
-        baseIdentifier: target.IDENTIFIER()!.getText(),
-        hasSingleIndexSubscript: false,
-      };
+    // All patterns have base IDENTIFIER
+    const baseIdentifier = target.IDENTIFIER()?.getText() ?? null;
+
+    // Check postfixTargetOp for subscripts
+    const postfixOps = target.postfixTargetOp();
+    let hasSingleIndexSubscript = false;
+
+    for (const op of postfixOps) {
+      const exprs = op.expression();
+      if (exprs.length === 1) {
+        // Single-index subscript (array access)
+        hasSingleIndexSubscript = true;
+        break;
+      }
+      // Two-index subscript (bit extraction) doesn't set the flag
     }
 
-    // Member access: x.field <- value
-    if (target.memberAccess()) {
-      return this.extractFromMemberAccess(target.memberAccess()!);
-    }
-
-    // Array access: x[i] <- value
-    if (target.arrayAccess()) {
-      return this.extractFromArrayAccess(target.arrayAccess()!);
-    }
-
-    return { baseIdentifier: null, hasSingleIndexSubscript: false };
-  }
-
-  /**
-   * Extract from member access pattern.
-   */
-  private static extractFromMemberAccess(
-    memberAccess: Parser.MemberAccessContext,
-  ): IAssignmentTargetResult {
-    const identifiers = memberAccess.IDENTIFIER();
-    return {
-      baseIdentifier: identifiers.length > 0 ? identifiers[0].getText() : null,
-      hasSingleIndexSubscript: false,
-    };
-  }
-
-  /**
-   * Extract from array access pattern.
-   * Single-index subscript (x[i]) is array access.
-   * Two-index subscript (x[0, 8]) is bit extraction.
-   */
-  private static extractFromArrayAccess(
-    arrayAccess: Parser.ArrayAccessContext,
-  ): IAssignmentTargetResult {
-    const isSingleIndex = arrayAccess.expression().length === 1;
-    return {
-      baseIdentifier: arrayAccess.IDENTIFIER()?.getText() ?? null,
-      hasSingleIndexSubscript: isSingleIndex,
-    };
+    return { baseIdentifier, hasSingleIndexSubscript };
   }
 }