c-next 0.1.65 → 0.1.67

package/src/transpiler/output/codegen/assignment/handlers/RegisterHandlers.ts

@@ -10,56 +10,22 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import BitUtils from "../../../../../utils/BitUtils";
-import TypeCheckUtils from "../../../../../utils/TypeCheckUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
 import RegisterUtils from "./RegisterUtils";
 import AssignmentHandlerUtils from "./AssignmentHandlerUtils";
+import CodeGenState from "../../../../state/CodeGenState";
+import type ICodeGenApi from "../../types/ICodeGenApi";
 
-/**
- * Try to generate MMIO-optimized memory access for byte-aligned writes.
- * Returns null if optimization not applicable.
- */
-function tryGenerateMMIO(
-  fullName: string,
-  regName: string,
-  startExpr: ReturnType<IHandlerDeps["tryEvaluateConstant"]>,
-  widthExpr: ReturnType<IHandlerDeps["tryEvaluateConstant"]>,
-  value: string,
-  deps: IHandlerDeps,
-): string | null {
-  if (
-    startExpr === undefined ||
-    widthExpr === undefined ||
-    startExpr % 8 !== 0 ||
-    !TypeCheckUtils.isStandardWidth(widthExpr)
-  ) {
-    return null;
-  }
-
-  const baseAddr = deps.symbols.registerBaseAddresses.get(regName);
-  const memberOffset = deps.symbols.registerMemberOffsets.get(fullName);
-
-  if (baseAddr === undefined || memberOffset === undefined) {
-    return null;
-  }
-
-  const byteOffset = startExpr / 8;
-  const accessType = `uint${widthExpr}_t`;
-  const totalOffset =
-    byteOffset === 0 ? memberOffset : `${memberOffset} + ${byteOffset}`;
-
-  return `*((volatile ${accessType}*)(${baseAddr} + ${totalOffset})) = (${value});`;
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
 }
 
 /**
  * Handle register single bit: GPIO7.DR_SET[LED_BIT] <- true
  */
-function handleRegisterBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleRegisterBit(ctx: IAssignmentContext): string {
   // Issue #707: Use shared validation utility
   AssignmentHandlerUtils.validateNoCompoundForBitAccess(
     ctx.isCompound,
@@ -69,12 +35,12 @@ function handleRegisterBit(
   const { fullName } =
     AssignmentHandlerUtils.buildRegisterNameWithScopeDetection(
       ctx.identifiers,
-      deps.isKnownScope,
+      (name) => CodeGenState.isKnownScope(name),
     );
-  const accessMod = deps.symbols.registerMemberAccess.get(fullName);
+  const accessMod = CodeGenState.symbols!.registerMemberAccess.get(fullName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);
 
-  const bitIndex = deps.generateExpression(ctx.subscripts[0]);
+  const bitIndex = gen().generateExpression(ctx.subscripts[0]);
 
   if (isWriteOnly) {
     AssignmentHandlerUtils.validateWriteOnlyValue(
@@ -92,10 +58,7 @@ function handleRegisterBit(
 /**
  * Handle register bit range: GPIO7.DR_SET[0, 8] <- value
  */
-function handleRegisterBitRange(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleRegisterBitRange(ctx: IAssignmentContext): string {
   // Issue #707: Use shared validation utility
   AssignmentHandlerUtils.validateNoCompoundForBitAccess(
     ctx.isCompound,
@@ -105,14 +68,14 @@ function handleRegisterBitRange(
   const { fullName, regName } =
     AssignmentHandlerUtils.buildRegisterNameWithScopeDetection(
       ctx.identifiers,
-      deps.isKnownScope,
+      (name) => CodeGenState.isKnownScope(name),
     );
-  const accessMod = deps.symbols.registerMemberAccess.get(fullName);
+  const accessMod = CodeGenState.symbols!.registerMemberAccess.get(fullName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);
 
-  const start = deps.generateExpression(ctx.subscripts[0]);
-  const width = deps.generateExpression(ctx.subscripts[1]);
-  const mask = BitUtils.generateMask(width);
+  const { start, width, mask } = RegisterUtils.extractBitRangeParams(
+    ctx.subscripts,
+  );
 
   if (isWriteOnly) {
     AssignmentHandlerUtils.validateWriteOnlyValue(
@@ -123,18 +86,14 @@ function handleRegisterBitRange(
     );
 
     // Try MMIO optimization
-    const startConst = deps.tryEvaluateConstant(ctx.subscripts[0]);
-    const widthConst = deps.tryEvaluateConstant(ctx.subscripts[1]);
-    const mmio = tryGenerateMMIO(
+    const mmio = RegisterUtils.tryGenerateMMIO(
       fullName,
       regName,
-      startConst,
-      widthConst,
+      ctx.subscripts,
       ctx.generatedValue,
-      deps,
     );
-    if (mmio) {
-      return mmio;
+    if (mmio.success) {
+      return mmio.statement!;
     }
 
     // Fallback: write shifted value
@@ -158,12 +117,9 @@ function handleRegisterBitRange(
 /**
  * Handle scoped register single bit: this.GPIO7.DR_SET[bit] <- true
  */
-function handleScopedRegisterBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleScopedRegisterBit(ctx: IAssignmentContext): string {
   // Issue #707: Use shared validation utilities
-  AssignmentHandlerUtils.validateScopeContext(deps.currentScope);
+  AssignmentHandlerUtils.validateScopeContext(CodeGenState.currentScope);
   AssignmentHandlerUtils.validateNoCompoundForBitAccess(
     ctx.isCompound,
     ctx.cnextOp,
@@ -171,14 +127,14 @@ function handleScopedRegisterBit(
 
   // Build scoped name: Scope_Register_Member
   const regName = AssignmentHandlerUtils.buildScopedRegisterName(
-    deps.currentScope!,
+    CodeGenState.currentScope!,
     ctx.identifiers,
   );
 
-  const accessMod = deps.symbols.registerMemberAccess.get(regName);
+  const accessMod = CodeGenState.symbols!.registerMemberAccess.get(regName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);
 
-  const bitIndex = deps.generateExpression(ctx.subscripts[0]);
+  const bitIndex = gen().generateExpression(ctx.subscripts[0]);
 
   if (isWriteOnly) {
     AssignmentHandlerUtils.validateWriteOnlyValue(
@@ -196,18 +152,15 @@ function handleScopedRegisterBit(
 /**
  * Handle scoped register bit range: this.GPIO7.ICR1[6, 2] <- value
  */
-function handleScopedRegisterBitRange(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleScopedRegisterBitRange(ctx: IAssignmentContext): string {
   // Issue #707: Use shared validation utilities
-  AssignmentHandlerUtils.validateScopeContext(deps.currentScope);
+  AssignmentHandlerUtils.validateScopeContext(CodeGenState.currentScope);
   AssignmentHandlerUtils.validateNoCompoundForBitAccess(
     ctx.isCompound,
     ctx.cnextOp,
   );
 
-  const scopeName = deps.currentScope!;
+  const scopeName = CodeGenState.currentScope!;
   const parts = ctx.identifiers;
   const regName = AssignmentHandlerUtils.buildScopedRegisterName(
     scopeName,
@@ -215,12 +168,12 @@ function handleScopedRegisterBitRange(
   );
   const scopedRegName = `${scopeName}_${parts[0]}`;
 
-  const accessMod = deps.symbols.registerMemberAccess.get(regName);
+  const accessMod = CodeGenState.symbols!.registerMemberAccess.get(regName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);
 
-  const start = deps.generateExpression(ctx.subscripts[0]);
-  const width = deps.generateExpression(ctx.subscripts[1]);
-  const mask = `((1U << ${width}) - 1)`;
+  const { start, width, mask } = RegisterUtils.extractBitRangeParams(
+    ctx.subscripts,
+  );
 
   if (isWriteOnly) {
     AssignmentHandlerUtils.validateWriteOnlyValue(
@@ -231,25 +184,14 @@ function handleScopedRegisterBitRange(
     );
 
     // Try MMIO optimization
-    const startConst = deps.tryEvaluateConstant(ctx.subscripts[0]);
-    const widthConst = deps.tryEvaluateConstant(ctx.subscripts[1]);
-
-    if (
-      startConst !== undefined &&
-      widthConst !== undefined &&
-      startConst % 8 === 0 &&
-      TypeCheckUtils.isStandardWidth(widthConst)
-    ) {
-      const baseAddr = deps.symbols.registerBaseAddresses.get(scopedRegName);
-      const memberOffset = deps.symbols.registerMemberOffsets.get(regName);
-
-      if (baseAddr !== undefined && memberOffset !== undefined) {
-        const byteOffset = startConst / 8;
-        const accessType = `uint${widthConst}_t`;
-        const totalOffset =
-          byteOffset === 0 ? memberOffset : `${memberOffset} + ${byteOffset}`;
-        return `*((volatile ${accessType}*)(${baseAddr} + ${totalOffset})) = (${ctx.generatedValue});`;
-      }
+    const mmio = RegisterUtils.tryGenerateMMIO(
+      regName,
+      scopedRegName,
+      ctx.subscripts,
+      ctx.generatedValue,
+    );
+    if (mmio.success) {
+      return mmio.statement!;
     }
 
     return RegisterUtils.generateWriteOnlyBitRange(

package/src/transpiler/output/codegen/assignment/handlers/RegisterUtils.ts

@@ -4,11 +4,86 @@
  *
  * Extracted from AccessPatternHandlers.ts and RegisterHandlers.ts to reduce duplication.
  */
+import BitUtils from "../../../../../utils/BitUtils";
+import TypeCheckUtils from "../../../../../utils/TypeCheckUtils";
+import CodeGenState from "../../../../state/CodeGenState";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
+
+/** Result from extracting bit range expressions */
+interface IBitRangeParams {
+  start: string;
+  width: string;
+  mask: string;
+}
+
+/** Result from MMIO optimization attempt */
+interface IOptimizationResult {
+  success: boolean;
+  statement?: string;
+}
 
 /**
  * Utilities for register access patterns
  */
 class RegisterUtils {
+  /**
+   * Extract start, width, and mask from bit range subscripts.
+   * Consolidates the common pattern of getting expressions and generating mask.
+   */
+  static extractBitRangeParams(
+    subscripts: readonly unknown[],
+  ): IBitRangeParams {
+    const start = gen().generateExpression(subscripts[0]);
+    const width = gen().generateExpression(subscripts[1]);
+    const mask = BitUtils.generateMask(width);
+    return { start, width, mask };
+  }
+
+  /**
+   * Try to generate MMIO-optimized memory access for byte-aligned writes.
+   * Returns success: true with statement if optimization applicable, false otherwise.
+   */
+  static tryGenerateMMIO(
+    fullName: string,
+    regName: string,
+    subscripts: readonly unknown[],
+    value: string,
+  ): IOptimizationResult {
+    const startConst = gen().tryEvaluateConstant(subscripts[0]);
+    const widthConst = gen().tryEvaluateConstant(subscripts[1]);
+
+    if (
+      startConst === undefined ||
+      widthConst === undefined ||
+      startConst % 8 !== 0 ||
+      !TypeCheckUtils.isStandardWidth(widthConst)
+    ) {
+      return { success: false };
+    }
+
+    const baseAddr = CodeGenState.symbols!.registerBaseAddresses.get(regName);
+    const memberOffset =
+      CodeGenState.symbols!.registerMemberOffsets.get(fullName);
+
+    if (baseAddr === undefined || memberOffset === undefined) {
+      return { success: false };
+    }
+
+    const byteOffset = startConst / 8;
+    const accessType = `uint${widthConst}_t`;
+    const totalOffset =
+      byteOffset === 0 ? memberOffset : `${memberOffset} + ${byteOffset}`;
+
+    return {
+      success: true,
+      statement: `*((volatile ${accessType}*)(${baseAddr} + ${totalOffset})) = (${value});`,
+    };
+  }
   /**
    * Check if register is write-only based on access modifier.
    *

package/src/transpiler/output/codegen/assignment/handlers/SimpleHandler.ts

@@ -5,7 +5,13 @@
  * Used when no special handling is needed.
  */
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
+import CodeGenState from "../../../../state/CodeGenState";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /**
  * Handle simple variable assignment.
@@ -14,11 +20,8 @@ import IHandlerDeps from "./IHandlerDeps";
  * x <- 5           =>  x = 5;
  * counter +<- 1    =>  counter += 1;
  */
-function handleSimpleAssignment(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+function handleSimpleAssignment(ctx: IAssignmentContext): string {
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 

package/src/transpiler/output/codegen/assignment/handlers/SpecialHandlers.ts

@@ -7,9 +7,16 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import TypeCheckUtils from "../../../../../utils/TypeCheckUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
+import CodeGenState from "../../../../state/CodeGenState";
+import TTypeInfo from "../../types/TTypeInfo";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /** Maps C operators to clamp helper operation names */
 const CLAMP_OP_MAP: Record<string, string> = {
@@ -22,30 +29,29 @@ const CLAMP_OP_MAP: Record<string, string> = {
  * Get typeInfo for assignment target.
  * Handles simple identifiers, this.member, and global.member patterns.
  */
-function getTargetTypeInfo(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): { typeInfo: ReturnType<typeof deps.typeRegistry.get> } {
+function getTargetTypeInfo(ctx: IAssignmentContext): {
+  typeInfo: TTypeInfo | undefined;
+} {
   const id = ctx.identifiers[0];
 
   // Simple identifier
   if (ctx.isSimpleIdentifier) {
-    return { typeInfo: deps.typeRegistry.get(id) };
+    return { typeInfo: CodeGenState.typeRegistry.get(id) };
   }
 
   // this.member: lookup using scoped name
-  if (ctx.isSimpleThisAccess && deps.currentScope) {
-    const scopedName = `${deps.currentScope}_${id}`;
-    return { typeInfo: deps.typeRegistry.get(scopedName) };
+  if (ctx.isSimpleThisAccess && CodeGenState.currentScope) {
+    const scopedName = `${CodeGenState.currentScope}_${id}`;
+    return { typeInfo: CodeGenState.typeRegistry.get(scopedName) };
   }
 
   // global.member: lookup using direct name
   if (ctx.isSimpleGlobalAccess) {
-    return { typeInfo: deps.typeRegistry.get(id) };
+    return { typeInfo: CodeGenState.typeRegistry.get(id) };
   }
 
   // Fallback to direct lookup
-  return { typeInfo: deps.typeRegistry.get(id) };
+  return { typeInfo: CodeGenState.typeRegistry.get(id) };
 }
 
 /**
@@ -54,11 +60,16 @@ function getTargetTypeInfo(
  * Delegates to CodeGenerator's generateAtomicRMW which uses
  * LDREX/STREX on supported platforms or PRIMASK otherwise.
  */
-function handleAtomicRMW(ctx: IAssignmentContext, deps: IHandlerDeps): string {
-  const { typeInfo } = getTargetTypeInfo(ctx, deps);
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+function handleAtomicRMW(ctx: IAssignmentContext): string {
+  const { typeInfo } = getTargetTypeInfo(ctx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
 
-  return deps.generateAtomicRMW(target, ctx.cOp, ctx.generatedValue, typeInfo!);
+  return gen().generateAtomicRMW(
+    target,
+    ctx.cOp,
+    ctx.generatedValue,
+    typeInfo!,
+  );
 }
 
 /**
@@ -67,12 +78,9 @@ function handleAtomicRMW(ctx: IAssignmentContext, deps: IHandlerDeps): string {
  * Generates calls to cnx_clamp_add_u8, cnx_clamp_sub_u8, etc.
  * Only applies to integers (floats use native C arithmetic with infinity).
  */
-function handleOverflowClamp(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
-  const { typeInfo } = getTargetTypeInfo(ctx, deps);
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+function handleOverflowClamp(ctx: IAssignmentContext): string {
+  const { typeInfo } = getTargetTypeInfo(ctx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
 
   // Floats use native C arithmetic (overflow to infinity)
   if (TypeCheckUtils.usesNativeArithmetic(typeInfo!.baseType)) {
@@ -82,7 +90,7 @@ function handleOverflowClamp(
   const helperOp = CLAMP_OP_MAP[ctx.cOp];
 
   if (helperOp) {
-    deps.markClampOpUsed(helperOp, typeInfo!.baseType);
+    CodeGenState.markClampOpUsed(helperOp, typeInfo!.baseType);
     return `${target} = cnx_clamp_${helperOp}_${typeInfo!.baseType}(${target}, ${ctx.generatedValue});`;
   }
 

package/src/transpiler/output/codegen/assignment/handlers/StringHandlers.ts

@@ -11,10 +11,16 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import StringUtils from "../../../../../utils/StringUtils";
 import TypeCheckUtils from "../../../../../utils/TypeCheckUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
+import CodeGenState from "../../../../state/CodeGenState";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /**
  * Validate compound operators are not used with strings.
@@ -32,19 +38,16 @@ function validateNotCompound(ctx: IAssignmentContext): void {
  *
  * Gets capacity from typeRegistry and generates strncpy with null terminator.
  */
-function handleSimpleStringAssignment(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleSimpleStringAssignment(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const id = ctx.identifiers[0];
-  const typeInfo = deps.typeRegistry.get(id);
+  const typeInfo = CodeGenState.typeRegistry.get(id);
   const capacity = typeInfo!.stringCapacity!;
 
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return StringUtils.copyWithNull(target, ctx.generatedValue, capacity);
 }
 
@@ -53,14 +56,10 @@ function handleSimpleStringAssignment(
  *
  * Shared helper for struct field string handlers.
  */
-function getStructFieldType(
-  structName: string,
-  fieldName: string,
-  deps: IHandlerDeps,
-): string {
-  const structTypeInfo = deps.typeRegistry.get(structName);
+function getStructFieldType(structName: string, fieldName: string): string {
+  const structTypeInfo = CodeGenState.typeRegistry.get(structName);
   const structType = structTypeInfo!.baseType;
-  const structFields = deps.symbols.structFields.get(structType);
+  const structFields = CodeGenState.symbols!.structFields.get(structType);
   return structFields!.get(fieldName)!;
 }
 
@@ -69,51 +68,45 @@ function getStructFieldType(
  *
  * Shared helper for struct field handlers.
  */
-function getStructType(structName: string, deps: IHandlerDeps): string {
-  const structTypeInfo = deps.typeRegistry.get(structName);
+function getStructType(structName: string): string {
+  const structTypeInfo = CodeGenState.typeRegistry.get(structName);
   return structTypeInfo!.baseType;
 }
 
 /**
  * Handle this.member string: this.name <- "value"
  */
-function handleStringThisMember(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
-  if (!deps.currentScope) {
+function handleStringThisMember(ctx: IAssignmentContext): string {
+  if (!CodeGenState.currentScope) {
     throw new Error("Error: 'this' can only be used inside a scope");
   }
 
   validateNotCompound(ctx);
 
   const memberName = ctx.identifiers[0];
-  const scopedName = `${deps.currentScope}_${memberName}`;
-  const typeInfo = deps.typeRegistry.get(scopedName);
+  const scopedName = `${CodeGenState.currentScope}_${memberName}`;
+  const typeInfo = CodeGenState.typeRegistry.get(scopedName);
   const capacity = typeInfo!.stringCapacity!;
 
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return StringUtils.copyWithNull(target, ctx.generatedValue, capacity);
 }
 
 /**
  * Handle struct.field string: person.name <- "Alice"
  */
-function handleStringStructField(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStringStructField(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const structName = ctx.identifiers[0];
   const fieldName = ctx.identifiers[1];
 
-  const fieldType = getStructFieldType(structName, fieldName, deps);
+  const fieldType = getStructFieldType(structName, fieldName);
   const capacity = TypeCheckUtils.getStringCapacity(fieldType)!;
 
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
   return StringUtils.copyToStructField(
     structName,
@@ -126,19 +119,16 @@ function handleStringStructField(
 /**
  * Handle string array element: names[0] <- "first"
  */
-function handleStringArrayElement(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStringArrayElement(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const name = ctx.identifiers[0];
-  const typeInfo = deps.typeRegistry.get(name);
+  const typeInfo = CodeGenState.typeRegistry.get(name);
   const capacity = typeInfo!.stringCapacity!;
 
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
-  const index = deps.generateExpression(ctx.subscripts[0]);
+  const index = gen().generateExpression(ctx.subscripts[0]);
   return StringUtils.copyToArrayElement(
     name,
     index,
@@ -150,27 +140,29 @@ function handleStringArrayElement(
 /**
  * Handle struct field string array element: config.items[0] <- "value"
  */
-function handleStringStructArrayElement(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStringStructArrayElement(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const structName = ctx.identifiers[0];
   const fieldName = ctx.identifiers[1];
 
-  const structType = getStructType(structName, deps);
-  const dimensions = deps.symbols.structFieldDimensions
-    .get(structType)
-    ?.get(fieldName);
+  const structType = getStructType(structName);
+  const dimensions =
+    CodeGenState.symbols!.structFieldDimensions.get(structType)?.get(fieldName);
+
+  if (!dimensions || dimensions.length === 0) {
+    throw new Error(
+      `Error: Cannot determine string capacity for struct field '${structType}.${fieldName}'`,
+    );
+  }
 
   // String arrays: dimensions are [array_size, string_capacity+1]
   // -1 because we added +1 for null terminator during symbol collection
-  const capacity = dimensions![dimensions!.length - 1] - 1;
+  const capacity = dimensions.at(-1)! - 1;
 
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
-  const index = deps.generateExpression(ctx.subscripts[0]);
+  const index = gen().generateExpression(ctx.subscripts[0]);
   return StringUtils.copyToStructFieldArrayElement(
     structName,
     fieldName,

package/src/transpiler/output/codegen/assignment/handlers/TAssignmentHandler.ts

@@ -1,15 +1,16 @@
 /**
  * Type for assignment handler functions (ADR-109).
+ *
+ * Handlers access state via CodeGenState and CodeGenState.generator
+ * instead of receiving deps as a parameter.
  */
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 
 /**
  * Handler function that generates C code for an assignment kind.
+ * Accesses CodeGenState directly for symbol information and
+ * CodeGenState.generator for CodeGenerator methods.
  */
-type TAssignmentHandler = (
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-) => string;
+type TAssignmentHandler = (ctx: IAssignmentContext) => string;
 
 export default TAssignmentHandler;