c-next 0.1.62 → 0.1.63

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

@@ -7,10 +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 CodeGenState from "../CodeGenState.js";
 
 /**
  * Result of analyzing a member chain for bit access.
@@ -27,20 +29,9 @@ 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 {
@@ -57,12 +48,6 @@ interface IChainState {
  * 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.
    *
@@ -70,9 +55,13 @@ class MemberChainAnalyzer {
    * 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 {
+  static analyze(
+    targetCtx: Parser.AssignmentTargetContext,
+    generateExpression: GenerateExpressionFn,
+  ): IBitAccessAnalysisResult {
     const baseId = targetCtx.IDENTIFIER()?.getText();
     const postfixOps = targetCtx.postfixTargetOp();
 
@@ -94,7 +83,7 @@ class MemberChainAnalyzer {
     ).length;
 
     // Walk through the chain to find the type and array status before the last subscript
-    const targetInfo = this.resolveTargetTypeAndArrayStatus(
+    const targetInfo = MemberChainAnalyzer.resolveTargetTypeAndArrayStatus(
       baseId,
       postfixOps.slice(0, -1),
       subscriptCount - 1, // subscripts before the last one
@@ -109,13 +98,17 @@ class MemberChainAnalyzer {
     }
 
     // Check if the type is an integer (bit access only works on integers)
-    if (!this.isIntegerType(targetInfo.type)) {
+    if (!MemberChainAnalyzer.isIntegerType(targetInfo.type)) {
       return { isBitAccess: false };
     }
 
     // Build the base target expression (everything except the last subscript)
-    const baseTarget = this.buildBaseTarget(baseId, postfixOps.slice(0, -1));
-    const bitIndex = this.deps.generateExpression(lastExprs[0]);
+    const baseTarget = MemberChainAnalyzer.buildBaseTarget(
+      baseId,
+      postfixOps.slice(0, -1),
+      generateExpression,
+    );
+    const bitIndex = generateExpression(lastExprs[0]);
 
     return {
       isBitAccess: true,
@@ -129,19 +122,19 @@ class MemberChainAnalyzer {
    * 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 resolveTargetTypeAndArrayStatus(
+  private static resolveTargetTypeAndArrayStatus(
     baseId: string,
     ops: Parser.PostfixTargetOpContext[],
     _subscriptsSoFar: number,
   ): { type: string; isArray: boolean } | undefined {
-    const baseTypeInfo = this.deps.typeRegistry.get(baseId);
+    const baseTypeInfo = CodeGenState.typeRegistry.get(baseId);
     if (!baseTypeInfo) {
       return undefined;
     }
 
     const state: IChainState = {
       currentType: baseTypeInfo.baseType,
-      currentStructType: this.deps.isKnownStruct(baseTypeInfo.baseType)
+      currentStructType: CodeGenState.isKnownStruct(baseTypeInfo.baseType)
         ? baseTypeInfo.baseType
         : undefined,
       isCurrentArray: baseTypeInfo.isArray,
@@ -151,12 +144,12 @@ class MemberChainAnalyzer {
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
       if (op.IDENTIFIER()) {
-        const result = this.processMemberOp(op, ops, i, state);
+        const result = MemberChainAnalyzer.processMemberOp(op, ops, i, state);
         if (!result) {
           return undefined;
         }
       } else {
-        this.processSubscriptOp(state);
+        MemberChainAnalyzer.processSubscriptOp(state);
       }
     }
 
@@ -167,7 +160,7 @@ class MemberChainAnalyzer {
    * Process a member access operation (.fieldName) and update chain state.
    * Returns false if the access is invalid.
    */
-  private processMemberOp(
+  private static processMemberOp(
     op: Parser.PostfixTargetOpContext,
     ops: Parser.PostfixTargetOpContext[],
     opIndex: number,
@@ -178,7 +171,9 @@ class MemberChainAnalyzer {
       return false;
     }
 
-    const structFields = this.deps.structFields.get(state.currentStructType);
+    const structFields = CodeGenState.symbols?.structFields.get(
+      state.currentStructType,
+    );
     if (!structFields) {
       return false;
     }
@@ -191,19 +186,19 @@ class MemberChainAnalyzer {
     state.currentType = fieldType;
 
     // Check if this field is an array
-    const arrayFields = this.deps.structFieldArrays.get(
+    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 = this.deps.isKnownStruct(state.currentType)
+    state.currentStructType = CodeGenState.isKnownStruct(state.currentType)
       ? state.currentType
       : undefined;
 
     // Calculate array dimensions remaining based on remaining subscripts
     state.arrayDimsRemaining = state.isCurrentArray
-      ? this.countRemainingSubscripts(ops, opIndex) + 1
+      ? MemberChainAnalyzer.countRemainingSubscripts(ops, opIndex) + 1
       : 0;
 
     return true;
@@ -212,7 +207,7 @@ class MemberChainAnalyzer {
   /**
    * Count remaining subscript operations after the given index.
    */
-  private countRemainingSubscripts(
+  private static countRemainingSubscripts(
     ops: Parser.PostfixTargetOpContext[],
     afterIndex: number,
   ): number {
@@ -224,7 +219,7 @@ class MemberChainAnalyzer {
   /**
    * Process a subscript operation ([expr]) and update chain state.
    */
-  private processSubscriptOp(state: IChainState): void {
+  private static processSubscriptOp(state: IChainState): void {
     if (!state.isCurrentArray || state.arrayDimsRemaining <= 0) {
       return;
     }
@@ -232,7 +227,7 @@ class MemberChainAnalyzer {
     state.arrayDimsRemaining--;
     if (state.arrayDimsRemaining === 0) {
       state.isCurrentArray = false;
-      state.currentStructType = this.deps.isKnownStruct(state.currentType)
+      state.currentStructType = CodeGenState.isKnownStruct(state.currentType)
         ? state.currentType
         : undefined;
     }
@@ -241,7 +236,7 @@ class MemberChainAnalyzer {
   /**
    * Check if a type is an integer type.
    */
-  private isIntegerType(typeName: string): boolean {
+  private static isIntegerType(typeName: string): boolean {
     const intTypes = new Set([
       "u8",
       "u16",
@@ -258,9 +253,10 @@ class MemberChainAnalyzer {
   /**
    * Build the target expression string from base identifier and postfix operations.
    */
-  private buildBaseTarget(
+  private static buildBaseTarget(
     baseId: string,
     ops: Parser.PostfixTargetOpContext[],
+    generateExpression: GenerateExpressionFn,
   ): string {
     let result = baseId;
 
@@ -270,13 +266,13 @@ class MemberChainAnalyzer {
       } else {
         const exprs = op.expression();
         if (exprs.length === 1) {
-          result += "[" + this.deps.generateExpression(exprs[0]) + "]";
+          result += "[" + generateExpression(exprs[0]) + "]";
         } else if (exprs.length === 2) {
           result +=
             "[" +
-            this.deps.generateExpression(exprs[0]) +
+            generateExpression(exprs[0]) +
             ", " +
-            this.deps.generateExpression(exprs[1]) +
+            generateExpression(exprs[1]) +
             "]";
         }
       }

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,21 +201,21 @@ 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 {
@@ -232,26 +226,29 @@ class StringLengthCounter {
       const target = assign.assignmentTarget();
       for (const op of target.postfixTargetOp()) {
         for (const expr of op.expression()) {
-          this.walkExpression(expr, counts);
+          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
   }