c-next 0.1.61 → 0.1.63

package/src/transpiler/output/codegen/analysis/MemberChainAnalyzer.ts

@@ -7,11 +7,12 @@
  * Used to detect bit access at the end of member chains, e.g.:
  * - grid[2][3].flags[0] - detects that [0] is bit access on flags
  * - point.x[3, 4] - detects bit range access on integer field
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import TTypeInfo from "../types/TTypeInfo.js";
-import memberAccessChain from "../memberAccessChain.js";
+import CodeGenState from "../CodeGenState.js";
 
 /**
  * Result of analyzing a member chain for bit access.
@@ -28,19 +29,16 @@ interface IBitAccessAnalysisResult {
 }
 
 /**
- * Dependencies required for member chain analysis.
+ * Callback type for generating expression code.
  */
-interface IMemberChainAnalyzerDeps {
-  /** Type registry for looking up variable types */
-  typeRegistry: ReadonlyMap<string, TTypeInfo>;
-  /** Struct field types by struct name */
-  structFields: ReadonlyMap<string, ReadonlyMap<string, string>>;
-  /** Struct field array flags by struct name */
-  structFieldArrays: ReadonlyMap<string, ReadonlySet<string>>;
-  /** Function to check if a type name is a known struct */
-  isKnownStruct: (name: string) => boolean;
-  /** Function to generate expression code */
-  generateExpression: (ctx: Parser.ExpressionContext) => string;
+type GenerateExpressionFn = (ctx: Parser.ExpressionContext) => string;
+
+/** Mutable state for tracking types through a member chain. */
+interface IChainState {
+  currentType: string;
+  currentStructType: string | undefined;
+  isCurrentArray: boolean;
+  arrayDimsRemaining: number;
 }
 
 /**
@@ -50,74 +48,237 @@ interface IMemberChainAnalyzerDeps {
  * detection callbacks to determine if the final subscript is bit access.
  */
 class MemberChainAnalyzer {
-  private readonly deps: IMemberChainAnalyzerDeps;
-
-  constructor(deps: IMemberChainAnalyzerDeps) {
-    this.deps = deps;
-  }
-
   /**
    * Analyze a member chain target to detect bit access at the end.
    *
    * For patterns like grid[2][3].flags[0], detects that [0] is bit access.
-   * Delegates to buildMemberAccessChain which handles the tree-walking and
-   * type tracking logic.
+   * Uses direct postfixTargetOp analysis with type tracking.
    *
    * @param targetCtx - The assignment target context to analyze
+   * @param generateExpression - Callback to generate expression code
    * @returns Analysis result with bit access information
    */
-  analyze(targetCtx: Parser.AssignmentTargetContext): IBitAccessAnalysisResult {
-    const memberAccessCtx = targetCtx.memberAccess();
-    if (!memberAccessCtx) {
+  static analyze(
+    targetCtx: Parser.AssignmentTargetContext,
+    generateExpression: GenerateExpressionFn,
+  ): IBitAccessAnalysisResult {
+    const baseId = targetCtx.IDENTIFIER()?.getText();
+    const postfixOps = targetCtx.postfixTargetOp();
+
+    if (!baseId || postfixOps.length === 0) {
+      return { isBitAccess: false };
+    }
+
+    // Check if the last postfix op is a single-expression subscript (potential bit access)
+    const lastOp = postfixOps.at(-1)!;
+    const lastExprs = lastOp.expression();
+    if (lastExprs.length !== 1 || lastOp.IDENTIFIER()) {
+      // Last op is member access or multi-expression subscript, not bit access
+      return { isBitAccess: false };
+    }
+
+    // Count total subscript operations
+    const subscriptCount = postfixOps.filter(
+      (op) => !op.IDENTIFIER() && op.expression().length > 0,
+    ).length;
+
+    // Walk through the chain to find the type and array status before the last subscript
+    const targetInfo = MemberChainAnalyzer.resolveTargetTypeAndArrayStatus(
+      baseId,
+      postfixOps.slice(0, -1),
+      subscriptCount - 1, // subscripts before the last one
+    );
+    if (!targetInfo) {
       return { isBitAccess: false };
     }
 
-    const parts = memberAccessCtx.IDENTIFIER().map((id) => id.getText());
-    const expressions = memberAccessCtx.expression();
-    const children = memberAccessCtx.children;
+    // If the target is still an array, the last subscript is array access, not bit access
+    if (targetInfo.isArray) {
+      return { isBitAccess: false };
+    }
 
-    if (!children || parts.length < 1 || expressions.length === 0) {
+    // Check if the type is an integer (bit access only works on integers)
+    if (!MemberChainAnalyzer.isIntegerType(targetInfo.type)) {
       return { isBitAccess: false };
     }
 
-    const firstPart = parts[0];
-    const firstTypeInfo = this.deps.typeRegistry.get(firstPart);
-
-    // Track bit access result via callback
-    let bitAccessResult: IBitAccessAnalysisResult | null = null;
-
-    memberAccessChain.buildMemberAccessChain({
-      firstId: firstPart,
-      identifiers: parts,
-      expressions,
-      children,
-      separatorOptions: {
-        isStructParam: false,
-        isCrossScope: false,
-      },
-      generateExpression: this.deps.generateExpression,
-      initialTypeInfo: firstTypeInfo
-        ? { isArray: firstTypeInfo.isArray, baseType: firstTypeInfo.baseType }
+    // Build the base target expression (everything except the last subscript)
+    const baseTarget = MemberChainAnalyzer.buildBaseTarget(
+      baseId,
+      postfixOps.slice(0, -1),
+      generateExpression,
+    );
+    const bitIndex = generateExpression(lastExprs[0]);
+
+    return {
+      isBitAccess: true,
+      baseTarget,
+      bitIndex,
+      baseType: targetInfo.type,
+    };
+  }
+
+  /**
+   * Resolve the type and array status of the target by walking through postfix operations.
+   * Returns the type and whether it's still an array before the last subscript.
+   */
+  private static resolveTargetTypeAndArrayStatus(
+    baseId: string,
+    ops: Parser.PostfixTargetOpContext[],
+    _subscriptsSoFar: number,
+  ): { type: string; isArray: boolean } | undefined {
+    const baseTypeInfo = CodeGenState.typeRegistry.get(baseId);
+    if (!baseTypeInfo) {
+      return undefined;
+    }
+
+    const state: IChainState = {
+      currentType: baseTypeInfo.baseType,
+      currentStructType: CodeGenState.isKnownStruct(baseTypeInfo.baseType)
+        ? baseTypeInfo.baseType
         : undefined,
-      typeTracking: {
-        getStructFields: (structType) => this.deps.structFields.get(structType),
-        getStructArrayFields: (structType) =>
-          this.deps.structFieldArrays.get(structType),
-        isKnownStruct: this.deps.isKnownStruct,
-      },
-      onBitAccess: (baseTarget, bitIndex, memberType) => {
-        bitAccessResult = {
-          isBitAccess: true,
-          baseTarget,
-          bitIndex,
-          baseType: memberType,
-        };
-        // Return non-null to signal early exit from buildMemberAccessChain
-        return baseTarget;
-      },
-    });
-
-    return bitAccessResult ?? { isBitAccess: false };
+      isCurrentArray: baseTypeInfo.isArray,
+      arrayDimsRemaining: baseTypeInfo.arrayDimensions?.length ?? 0,
+    };
+
+    for (let i = 0; i < ops.length; i++) {
+      const op = ops[i];
+      if (op.IDENTIFIER()) {
+        const result = MemberChainAnalyzer.processMemberOp(op, ops, i, state);
+        if (!result) {
+          return undefined;
+        }
+      } else {
+        MemberChainAnalyzer.processSubscriptOp(state);
+      }
+    }
+
+    return { type: state.currentType, isArray: state.isCurrentArray };
+  }
+
+  /**
+   * Process a member access operation (.fieldName) and update chain state.
+   * Returns false if the access is invalid.
+   */
+  private static processMemberOp(
+    op: Parser.PostfixTargetOpContext,
+    ops: Parser.PostfixTargetOpContext[],
+    opIndex: number,
+    state: IChainState,
+  ): boolean {
+    const fieldName = op.IDENTIFIER()!.getText();
+    if (!state.currentStructType) {
+      return false;
+    }
+
+    const structFields = CodeGenState.symbols?.structFields.get(
+      state.currentStructType,
+    );
+    if (!structFields) {
+      return false;
+    }
+
+    const fieldType = structFields.get(fieldName);
+    if (!fieldType) {
+      return false;
+    }
+
+    state.currentType = fieldType;
+
+    // Check if this field is an array
+    const arrayFields = CodeGenState.symbols?.structFieldArrays.get(
+      state.currentStructType,
+    );
+    state.isCurrentArray = arrayFields?.has(fieldName) ?? false;
+
+    // If the field type is a struct, update currentStructType
+    state.currentStructType = CodeGenState.isKnownStruct(state.currentType)
+      ? state.currentType
+      : undefined;
+
+    // Calculate array dimensions remaining based on remaining subscripts
+    state.arrayDimsRemaining = state.isCurrentArray
+      ? MemberChainAnalyzer.countRemainingSubscripts(ops, opIndex) + 1
+      : 0;
+
+    return true;
+  }
+
+  /**
+   * Count remaining subscript operations after the given index.
+   */
+  private static countRemainingSubscripts(
+    ops: Parser.PostfixTargetOpContext[],
+    afterIndex: number,
+  ): number {
+    return ops
+      .slice(afterIndex + 1)
+      .filter((o) => !o.IDENTIFIER() && o.expression().length > 0).length;
+  }
+
+  /**
+   * Process a subscript operation ([expr]) and update chain state.
+   */
+  private static processSubscriptOp(state: IChainState): void {
+    if (!state.isCurrentArray || state.arrayDimsRemaining <= 0) {
+      return;
+    }
+
+    state.arrayDimsRemaining--;
+    if (state.arrayDimsRemaining === 0) {
+      state.isCurrentArray = false;
+      state.currentStructType = CodeGenState.isKnownStruct(state.currentType)
+        ? state.currentType
+        : undefined;
+    }
+  }
+
+  /**
+   * Check if a type is an integer type.
+   */
+  private static isIntegerType(typeName: string): boolean {
+    const intTypes = new Set([
+      "u8",
+      "u16",
+      "u32",
+      "u64",
+      "i8",
+      "i16",
+      "i32",
+      "i64",
+    ]);
+    return intTypes.has(typeName);
+  }
+
+  /**
+   * Build the target expression string from base identifier and postfix operations.
+   */
+  private static buildBaseTarget(
+    baseId: string,
+    ops: Parser.PostfixTargetOpContext[],
+    generateExpression: GenerateExpressionFn,
+  ): string {
+    let result = baseId;
+
+    for (const op of ops) {
+      if (op.IDENTIFIER()) {
+        result += "." + op.IDENTIFIER()!.getText();
+      } else {
+        const exprs = op.expression();
+        if (exprs.length === 1) {
+          result += "[" + generateExpression(exprs[0]) + "]";
+        } else if (exprs.length === 2) {
+          result +=
+            "[" +
+            generateExpression(exprs[0]) +
+            ", " +
+            generateExpression(exprs[1]) +
+            "]";
+        }
+      }
+    }
+
+    return result;
   }
 }
 

package/src/transpiler/output/codegen/analysis/StringLengthCounter.ts

@@ -4,43 +4,34 @@
  * Issue #644: Extracted from CodeGenerator to reduce code duplication.
  * Used for strlen caching optimization - when a string's .length is accessed
  * multiple times, we cache the strlen result in a temp variable.
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
-import TTypeInfo from "../types/TTypeInfo";
-
-/**
- * Type registry lookup function signature.
- */
-type TypeRegistryLookup = (name: string) => TTypeInfo | undefined;
+import CodeGenState from "../CodeGenState";
 
 /**
  * Counts .length accesses on string variables in an expression tree.
  * This enables strlen caching optimization.
  */
 class StringLengthCounter {
-  private readonly typeRegistry: TypeRegistryLookup;
-
-  constructor(typeRegistry: TypeRegistryLookup) {
-    this.typeRegistry = typeRegistry;
-  }
-
   /**
    * Count .length accesses in an expression.
    */
-  countExpression(ctx: Parser.ExpressionContext): Map<string, number> {
+  static countExpression(ctx: Parser.ExpressionContext): Map<string, number> {
     const counts = new Map<string, number>();
-    this.walkExpression(ctx, counts);
+    StringLengthCounter.walkExpression(ctx, counts);
     return counts;
   }
 
   /**
    * Count .length accesses in a block.
    */
-  countBlock(ctx: Parser.BlockContext): Map<string, number> {
+  static countBlock(ctx: Parser.BlockContext): Map<string, number> {
     const counts = new Map<string, number>();
     for (const stmt of ctx.statement()) {
-      this.walkStatement(stmt, counts);
+      StringLengthCounter.walkStatement(stmt, counts);
     }
     return counts;
   }
@@ -48,9 +39,12 @@ class StringLengthCounter {
   /**
    * Count .length accesses in a block, adding to existing counts.
    */
-  countBlockInto(ctx: Parser.BlockContext, counts: Map<string, number>): void {
+  static countBlockInto(
+    ctx: Parser.BlockContext,
+    counts: Map<string, number>,
+  ): void {
     for (const stmt of ctx.statement()) {
-      this.walkStatement(stmt, counts);
+      StringLengthCounter.walkStatement(stmt, counts);
     }
   }
 
@@ -58,134 +52,134 @@ class StringLengthCounter {
    * Walk an expression tree, counting .length accesses.
    * Uses generic traversal - only postfix expressions need special handling.
    */
-  private walkExpression(
+  private static walkExpression(
     ctx: Parser.ExpressionContext,
     counts: Map<string, number>,
   ): void {
     const ternary = ctx.ternaryExpression();
     if (ternary) {
-      this.walkTernary(ternary, counts);
+      StringLengthCounter.walkTernary(ternary, counts);
     }
   }
 
-  private walkTernary(
+  private static walkTernary(
     ctx: Parser.TernaryExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const orExpr of ctx.orExpression()) {
-      this.walkOrExpr(orExpr, counts);
+      StringLengthCounter.walkOrExpr(orExpr, counts);
     }
   }
 
-  private walkOrExpr(
+  private static walkOrExpr(
     ctx: Parser.OrExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const andExpr of ctx.andExpression()) {
-      this.walkAndExpr(andExpr, counts);
+      StringLengthCounter.walkAndExpr(andExpr, counts);
     }
   }
 
-  private walkAndExpr(
+  private static walkAndExpr(
     ctx: Parser.AndExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const eqExpr of ctx.equalityExpression()) {
-      this.walkEqualityExpr(eqExpr, counts);
+      StringLengthCounter.walkEqualityExpr(eqExpr, counts);
     }
   }
 
-  private walkEqualityExpr(
+  private static walkEqualityExpr(
     ctx: Parser.EqualityExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const relExpr of ctx.relationalExpression()) {
-      this.walkRelationalExpr(relExpr, counts);
+      StringLengthCounter.walkRelationalExpr(relExpr, counts);
     }
   }
 
-  private walkRelationalExpr(
+  private static walkRelationalExpr(
     ctx: Parser.RelationalExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const borExpr of ctx.bitwiseOrExpression()) {
-      this.walkBitwiseOrExpr(borExpr, counts);
+      StringLengthCounter.walkBitwiseOrExpr(borExpr, counts);
     }
   }
 
-  private walkBitwiseOrExpr(
+  private static walkBitwiseOrExpr(
     ctx: Parser.BitwiseOrExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const bxorExpr of ctx.bitwiseXorExpression()) {
-      this.walkBitwiseXorExpr(bxorExpr, counts);
+      StringLengthCounter.walkBitwiseXorExpr(bxorExpr, counts);
     }
   }
 
-  private walkBitwiseXorExpr(
+  private static walkBitwiseXorExpr(
     ctx: Parser.BitwiseXorExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const bandExpr of ctx.bitwiseAndExpression()) {
-      this.walkBitwiseAndExpr(bandExpr, counts);
+      StringLengthCounter.walkBitwiseAndExpr(bandExpr, counts);
     }
   }
 
-  private walkBitwiseAndExpr(
+  private static walkBitwiseAndExpr(
     ctx: Parser.BitwiseAndExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const shiftExpr of ctx.shiftExpression()) {
-      this.walkShiftExpr(shiftExpr, counts);
+      StringLengthCounter.walkShiftExpr(shiftExpr, counts);
     }
   }
 
-  private walkShiftExpr(
+  private static walkShiftExpr(
     ctx: Parser.ShiftExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const addExpr of ctx.additiveExpression()) {
-      this.walkAdditiveExpr(addExpr, counts);
+      StringLengthCounter.walkAdditiveExpr(addExpr, counts);
     }
   }
 
-  private walkAdditiveExpr(
+  private static walkAdditiveExpr(
     ctx: Parser.AdditiveExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const multExpr of ctx.multiplicativeExpression()) {
-      this.walkMultiplicativeExpr(multExpr, counts);
+      StringLengthCounter.walkMultiplicativeExpr(multExpr, counts);
     }
   }
 
-  private walkMultiplicativeExpr(
+  private static walkMultiplicativeExpr(
     ctx: Parser.MultiplicativeExpressionContext,
     counts: Map<string, number>,
   ): void {
     for (const unaryExpr of ctx.unaryExpression()) {
-      this.walkUnaryExpr(unaryExpr, counts);
+      StringLengthCounter.walkUnaryExpr(unaryExpr, counts);
     }
   }
 
-  private walkUnaryExpr(
+  private static walkUnaryExpr(
     ctx: Parser.UnaryExpressionContext,
     counts: Map<string, number>,
   ): void {
     const postfix = ctx.postfixExpression();
     if (postfix) {
-      this.walkPostfixExpr(postfix, counts);
+      StringLengthCounter.walkPostfixExpr(postfix, counts);
     }
     // Also check nested unary expressions
     const nestedUnary = ctx.unaryExpression();
     if (nestedUnary) {
-      this.walkUnaryExpr(nestedUnary, counts);
+      StringLengthCounter.walkUnaryExpr(nestedUnary, counts);
     }
   }
 
   /**
    * Walk a postfix expression - this is where we detect .length accesses.
    */
-  private walkPostfixExpr(
+  private static walkPostfixExpr(
     ctx: Parser.PostfixExpressionContext,
     counts: Map<string, number>,
   ): void {
@@ -199,7 +193,7 @@ class StringLengthCounter {
         const memberName = op.IDENTIFIER()?.getText();
         if (memberName === "length") {
           // Check if this is a string type
-          const typeInfo = this.typeRegistry(primaryId);
+          const typeInfo = CodeGenState.typeRegistry.get(primaryId);
           if (typeInfo?.isString) {
             const currentCount = counts.get(primaryId) || 0;
             counts.set(primaryId, currentCount + 1);
@@ -207,51 +201,54 @@ class StringLengthCounter {
         }
         // Walk any nested expressions in array accesses or function calls
         for (const expr of op.expression()) {
-          this.walkExpression(expr, counts);
+          StringLengthCounter.walkExpression(expr, counts);
         }
       }
     }
 
     // Walk nested expression in primary if present
     if (primary.expression()) {
-      this.walkExpression(primary.expression()!, counts);
+      StringLengthCounter.walkExpression(primary.expression()!, counts);
     }
   }
 
   /**
    * Walk a statement, counting .length accesses.
    */
-  private walkStatement(
+  private static walkStatement(
     ctx: Parser.StatementContext,
     counts: Map<string, number>,
   ): void {
     // Assignment statement
     if (ctx.assignmentStatement()) {
       const assign = ctx.assignmentStatement()!;
-      // Count in target (array index expressions)
+      // Count in target (array index expressions from postfix ops)
       const target = assign.assignmentTarget();
-      if (target.arrayAccess()) {
-        for (const expr of target.arrayAccess()!.expression()) {
-          this.walkExpression(expr, counts);
+      for (const op of target.postfixTargetOp()) {
+        for (const expr of op.expression()) {
+          StringLengthCounter.walkExpression(expr, counts);
         }
       }
       // Count in value expression
-      this.walkExpression(assign.expression(), counts);
+      StringLengthCounter.walkExpression(assign.expression(), counts);
     }
     // Expression statement
     if (ctx.expressionStatement()) {
-      this.walkExpression(ctx.expressionStatement()!.expression(), counts);
+      StringLengthCounter.walkExpression(
+        ctx.expressionStatement()!.expression(),
+        counts,
+      );
     }
     // Variable declaration
     if (ctx.variableDeclaration()) {
       const varDecl = ctx.variableDeclaration()!;
       if (varDecl.expression()) {
-        this.walkExpression(varDecl.expression()!, counts);
+        StringLengthCounter.walkExpression(varDecl.expression()!, counts);
       }
     }
     // Nested block
     if (ctx.block()) {
-      this.countBlockInto(ctx.block()!, counts);
+      StringLengthCounter.countBlockInto(ctx.block()!, counts);
     }
     // Note: Could add recursion for if/while/for bodies if deeper analysis needed
   }