c-next 0.1.65 → 0.1.67

package/src/transpiler/output/codegen/__tests__/TypeResolver.test.ts

@@ -5,7 +5,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import TypeResolver from "../TypeResolver";
 import SymbolTable from "../../../logic/symbols/SymbolTable";
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 import TTypeInfo from "../types/TTypeInfo";
 
 describe("TypeResolver", () => {

package/src/transpiler/output/codegen/__tests__/TypeValidator.resolution.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import TypeValidator from "../TypeValidator";
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 import type ICodeGenSymbols from "../../../types/ICodeGenSymbols";
 
 describe("TypeValidator.resolveBareIdentifier", () => {

package/src/transpiler/output/codegen/__tests__/TypeValidator.test.ts

@@ -6,7 +6,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import TypeValidator from "../TypeValidator";
 import TypeResolver from "../TypeResolver";
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 import type ICodeGenSymbols from "../../../types/ICodeGenSymbols";
 import type TTypeInfo from "../types/TTypeInfo";
 import type TParameterInfo from "../types/TParameterInfo";

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

@@ -12,7 +12,7 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 
 /**
  * Result of analyzing a member chain for bit access.

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

@@ -9,7 +9,7 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 
 /**
  * Counts .length accesses on string variables in an expression tree.

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

@@ -8,7 +8,7 @@
 
 import { describe, it, expect, beforeEach } from "vitest";
 import MemberChainAnalyzer from "../MemberChainAnalyzer.js";
-import CodeGenState from "../../CodeGenState.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
 import type * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
 
 /** Mock type for PostfixTargetOpContext */

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

@@ -6,7 +6,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import StringLengthCounter from "../StringLengthCounter";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser";
-import CodeGenState from "../../CodeGenState";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Parse a C-Next expression and return the expression context.

package/src/transpiler/output/codegen/assignment/AssignmentClassifier.ts

@@ -9,7 +9,7 @@
  */
 import AssignmentKind from "./AssignmentKind";
 import IAssignmentContext from "./IAssignmentContext";
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 import SubscriptClassifier from "../subscript/SubscriptClassifier";
 import TTypeInfo from "../types/TTypeInfo";
 import TypeCheckUtils from "../../../../utils/TypeCheckUtils";

package/src/transpiler/output/codegen/assignment/__tests__/AssignmentClassifier.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from "vitest";
 import AssignmentClassifier from "../AssignmentClassifier";
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import CodeGenState from "../../CodeGenState";
+import CodeGenState from "../../../../state/CodeGenState";
 import TTypeInfo from "../../types/TTypeInfo";
 
 // ========================================================================

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

@@ -11,28 +11,31 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import BitUtils from "../../../../../utils/BitUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
 import RegisterUtils from "./RegisterUtils";
+import CodeGenState from "../../../../state/CodeGenState";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /**
  * Common handler for global access patterns (GLOBAL_MEMBER and GLOBAL_ARRAY).
  *
  * Validates cross-scope visibility and generates standard assignment.
  */
-function handleGlobalAccess(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleGlobalAccess(ctx: IAssignmentContext): string {
   const firstId = ctx.identifiers[0];
 
   // Validate cross-scope visibility if first id is a scope
-  if (deps.isKnownScope(firstId) && ctx.identifiers.length >= 2) {
-    deps.validateCrossScopeVisibility(firstId, ctx.identifiers[1]);
+  if (CodeGenState.isKnownScope(firstId) && ctx.identifiers.length >= 2) {
+    gen().validateCrossScopeVisibility(firstId, ctx.identifiers[1]);
   }
 
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
@@ -41,22 +44,19 @@ function handleGlobalAccess(
  *
  * Validates scope context and generates standard assignment.
  */
-function handleThisAccess(ctx: IAssignmentContext, deps: IHandlerDeps): string {
-  if (!deps.currentScope) {
+function handleThisAccess(ctx: IAssignmentContext): string {
+  if (!CodeGenState.currentScope) {
     throw new Error("Error: 'this' can only be used inside a scope");
   }
 
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
 /**
  * Handle global.reg[bit]: global.GPIO7.DR_SET[bit] <- true
  */
-function handleGlobalRegisterBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleGlobalRegisterBit(ctx: IAssignmentContext): string {
   if (ctx.isCompound) {
     throw new Error(
       `Compound assignment operators not supported for bit field access: ${ctx.cnextOp}`,
@@ -67,15 +67,15 @@ function handleGlobalRegisterBit(
   const regName = parts.join("_");
 
   // Check for write-only register
-  const accessMod = deps.symbols.registerMemberAccess.get(regName);
+  const accessMod = CodeGenState.symbols!.registerMemberAccess.get(regName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);
 
   // Handle bit range vs single bit
   if (ctx.subscripts.length === 2) {
-    // Bit range
-    const start = deps.generateExpression(ctx.subscripts[0]);
-    const width = deps.generateExpression(ctx.subscripts[1]);
-    const mask = BitUtils.generateMask(width);
+    // Bit range - use shared utility
+    const { start, width, mask } = RegisterUtils.extractBitRangeParams(
+      ctx.subscripts,
+    );
 
     if (isWriteOnly) {
       if (ctx.generatedValue === "0") {
@@ -100,7 +100,7 @@ function handleGlobalRegisterBit(
   }
 
   // Single bit
-  const bitIndex = deps.generateExpression(ctx.subscripts[0]);
+  const bitIndex = gen().generateExpression(ctx.subscripts[0]);
 
   if (isWriteOnly) {
     if (ctx.generatedValue === "false" || ctx.generatedValue === "0") {
@@ -124,12 +124,9 @@ function handleGlobalRegisterBit(
  * Special case: Detects bit access at the end of chain
  * (e.g., grid[2][3].flags[0] <- true) and generates RMW.
  */
-function handleMemberChain(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleMemberChain(ctx: IAssignmentContext): string {
   // Check if this is bit access on a struct member
-  const bitAnalysis = deps.analyzeMemberChainForBitAccess(ctx.targetCtx);
+  const bitAnalysis = gen().analyzeMemberChainForBitAccess(ctx.targetCtx);
 
   if (bitAnalysis.isBitAccess) {
     // Validate compound operators not supported for bit access
@@ -147,7 +144,7 @@ function handleMemberChain(
   }
 
   // Normal member chain assignment
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 

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

@@ -8,18 +8,22 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import TAssignmentHandler from "./TAssignmentHandler";
+import CodeGenState from "../../../../state/CodeGenState";
+import TypeValidator from "../../TypeValidator";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /**
  * Handle simple array element: arr[i] <- value
  */
-function handleArrayElement(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleArrayElement(ctx: IAssignmentContext): string {
   const name = ctx.identifiers[0];
-  const index = deps.generateExpression(ctx.subscripts[0]);
+  const index = gen().generateExpression(ctx.subscripts[0]);
 
   return `${name}[${index}] ${ctx.cOp} ${ctx.generatedValue};`;
 }
@@ -27,21 +31,24 @@ function handleArrayElement(
 /**
  * Handle multi-dimensional array element: matrix[i][j] <- value
  */
-function handleMultiDimArrayElement(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleMultiDimArrayElement(ctx: IAssignmentContext): string {
   const name = ctx.identifiers[0];
-  const typeInfo = deps.typeRegistry.get(name);
+  const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // ADR-036: Compile-time bounds checking for constant indices
   if (typeInfo?.arrayDimensions) {
     const line = ctx.subscripts[0]?.start?.line ?? 0;
-    deps.checkArrayBounds(name, typeInfo.arrayDimensions, ctx.subscripts, line);
+    TypeValidator.checkArrayBounds(
+      name,
+      [...typeInfo.arrayDimensions],
+      [...ctx.subscripts],
+      line,
+      (expr) => gen().tryEvaluateConstant(expr),
+    );
   }
 
   const indices = ctx.subscripts
-    .map((e) => deps.generateExpression(e))
+    .map((e) => gen().generateExpression(e))
     .join("][");
 
   return `${name}[${indices}] ${ctx.cOp} ${ctx.generatedValue};`;
@@ -55,7 +62,7 @@ function handleMultiDimArrayElement(
  * - Only valid on 1D arrays
  * - Bounds checking at compile time
  */
-function handleArraySlice(ctx: IAssignmentContext, deps: IHandlerDeps): string {
+function handleArraySlice(ctx: IAssignmentContext): string {
   if (ctx.isCompound) {
     throw new Error(
       `Compound assignment operators not supported for slice assignment: ${ctx.cnextOp}`,
@@ -63,7 +70,7 @@ function handleArraySlice(ctx: IAssignmentContext, deps: IHandlerDeps): string {
   }
 
   const name = ctx.identifiers[0];
-  const typeInfo = deps.typeRegistry.get(name);
+  const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // Get line number for error messages
   const line = ctx.subscripts[0].start?.line ?? 0;
@@ -78,7 +85,7 @@ function handleArraySlice(ctx: IAssignmentContext, deps: IHandlerDeps): string {
   }
 
   // Validate offset is compile-time constant
-  const offsetValue = deps.tryEvaluateConstant(ctx.subscripts[0]);
+  const offsetValue = gen().tryEvaluateConstant(ctx.subscripts[0]);
   if (offsetValue === undefined) {
     throw new Error(
       `${line}:0 Error: Slice assignment offset must be a compile-time constant. ` +
@@ -87,7 +94,7 @@ function handleArraySlice(ctx: IAssignmentContext, deps: IHandlerDeps): string {
   }
 
   // Validate length is compile-time constant
-  const lengthValue = deps.tryEvaluateConstant(ctx.subscripts[1]);
+  const lengthValue = gen().tryEvaluateConstant(ctx.subscripts[1]);
   if (lengthValue === undefined) {
     throw new Error(
       `${line}:0 Error: Slice assignment length must be a compile-time constant. ` +
@@ -129,7 +136,7 @@ function handleArraySlice(ctx: IAssignmentContext, deps: IHandlerDeps): string {
   }
 
   // Mark that we need string.h for memcpy
-  deps.markNeedsString();
+  CodeGenState.needsString = true;
 
   return `memcpy(&${name}[${offsetValue}], &${ctx.generatedValue}, ${lengthValue});`;
 }

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

@@ -9,9 +9,15 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import BitUtils from "../../../../../utils/BitUtils";
 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 bit access.
@@ -28,16 +34,16 @@ function validateNotCompound(ctx: IAssignmentContext): void {
  * Handle single bit on integer variable: flags[3] <- true
  * Also handles float bit indexing: f32Var[3] <- true
  */
-function handleIntegerBit(ctx: IAssignmentContext, deps: IHandlerDeps): string {
+function handleIntegerBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const name = ctx.identifiers[0];
-  const bitIndex = deps.generateExpression(ctx.subscripts[0]);
-  const typeInfo = deps.typeRegistry.get(name);
+  const bitIndex = gen().generateExpression(ctx.subscripts[0]);
+  const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // Check for float bit indexing
   if (typeInfo) {
-    const floatResult = deps.generateFloatBitWrite(
+    const floatResult = gen().generateFloatBitWrite(
       name,
       typeInfo,
       bitIndex,
@@ -62,20 +68,17 @@ function handleIntegerBit(ctx: IAssignmentContext, deps: IHandlerDeps): string {
  * Handle bit range on integer variable: flags[0, 3] <- 5
  * Also handles float bit range: f32Var[0, 8] <- 0xFF
  */
-function handleIntegerBitRange(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleIntegerBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const name = ctx.identifiers[0];
-  const start = deps.generateExpression(ctx.subscripts[0]);
-  const width = deps.generateExpression(ctx.subscripts[1]);
-  const typeInfo = deps.typeRegistry.get(name);
+  const start = gen().generateExpression(ctx.subscripts[0]);
+  const width = gen().generateExpression(ctx.subscripts[1]);
+  const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // Check for float bit indexing
   if (typeInfo) {
-    const floatResult = deps.generateFloatBitWrite(
+    const floatResult = gen().generateFloatBitWrite(
       name,
       typeInfo,
       start,
@@ -101,20 +104,17 @@ function handleIntegerBitRange(
  * Handle bit on struct member: item.byte[7] <- true
  * This is handled through MEMBER_CHAIN with bit detection.
  */
-function handleStructMemberBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStructMemberBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   // The target up to the last subscript is the struct member path
   // The last subscript is the bit index
   // This pattern is complex - the target needs to be built from the member chain
   // For now, delegate to the existing target generator and build the bit op
-  const target = deps.generateAssignmentTarget(ctx.targetCtx);
+  const target = gen().generateAssignmentTarget(ctx.targetCtx);
 
   // Extract the bit index from the last subscript
-  const bitIndex = deps.generateExpression(ctx.subscripts.at(-1)!);
+  const bitIndex = gen().generateExpression(ctx.subscripts.at(-1)!);
 
   // Limitation: Uses literal "1" which works for types up to 32 bits.
   // For 64-bit struct members, would need to track member type through chain.
@@ -127,14 +127,11 @@ function handleStructMemberBit(
 /**
  * Handle bit on multi-dimensional array element: matrix[i][j][FIELD_BIT] <- false
  */
-function handleArrayElementBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleArrayElementBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   const arrayName = ctx.identifiers[0];
-  const typeInfo = deps.typeRegistry.get(arrayName);
+  const typeInfo = CodeGenState.typeRegistry.get(arrayName);
 
   if (!typeInfo?.arrayDimensions) {
     throw new Error(`Error: ${arrayName} is not an array`);
@@ -145,9 +142,9 @@ function handleArrayElementBit(
   // Array indices are subscripts[0..numDims-1], bit index is subscripts[numDims]
   const arrayIndices = ctx.subscripts
     .slice(0, numDims)
-    .map((e) => `[${deps.generateExpression(e)}]`)
+    .map((e) => `[${gen().generateExpression(e)}]`)
     .join("");
-  const bitIndex = deps.generateExpression(ctx.subscripts[numDims]);
+  const bitIndex = gen().generateExpression(ctx.subscripts[numDims]);
 
   const arrayElement = `${arrayName}${arrayIndices}`;
 
@@ -164,10 +161,7 @@ function handleArrayElementBit(
  * The target is a chain like array[idx].member or struct.field with a
  * bit range subscript [start, width] at the end.
  */
-function handleStructChainBitRange(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStructChainBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   // Build the base target from postfixOps, excluding the last one (the bit range)
@@ -182,7 +176,7 @@ function handleStructChainBitRange(
     } else {
       const exprs = op.expression();
       if (exprs.length > 0) {
-        baseTarget += "[" + deps.generateExpression(exprs[0]) + "]";
+        baseTarget += "[" + gen().generateExpression(exprs[0]) + "]";
       }
     }
   }
@@ -190,8 +184,8 @@ function handleStructChainBitRange(
   // Get start and width from the last postfixOp (the bit range)
   const lastOp = ctx.postfixOps.at(-1)!;
   const bitRangeExprs = lastOp.expression();
-  const start = deps.generateExpression(bitRangeExprs[0]);
-  const width = deps.generateExpression(bitRangeExprs[1]);
+  const start = gen().generateExpression(bitRangeExprs[0]);
+  const width = gen().generateExpression(bitRangeExprs[1]);
 
   // Generate bit range write
   // Limitation: assumes 32-bit types. For 64-bit struct members,

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

@@ -11,9 +11,16 @@
  */
 import AssignmentKind from "../AssignmentKind";
 import IAssignmentContext from "../IAssignmentContext";
-import IHandlerDeps from "./IHandlerDeps";
 import BitUtils from "../../../../../utils/BitUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
+import CodeGenState from "../../../../state/CodeGenState";
+import TypeValidator from "../../TypeValidator";
+import type ICodeGenApi from "../../types/ICodeGenApi";
+
+/** Get typed generator reference */
+function gen(): ICodeGenApi {
+  return CodeGenState.generator as ICodeGenApi;
+}
 
 /**
  * Calculate mask value and hex string for bitmap field.
@@ -31,9 +38,8 @@ function getBitmapFieldInfo(
   bitmapType: string,
   fieldName: string,
   ctx: IAssignmentContext,
-  deps: IHandlerDeps,
 ): { offset: number; width: number } {
-  const fields = deps.symbols.bitmapFields.get(bitmapType);
+  const fields = CodeGenState.symbols!.bitmapFields.get(bitmapType);
   if (!fields?.has(fieldName)) {
     throw new Error(
       `Error: Unknown bitmap field '${fieldName}' on type '${bitmapType}'`,
@@ -51,7 +57,11 @@ function getBitmapFieldInfo(
 
   // Validate compile-time literal overflow
   if (ctx.valueCtx) {
-    deps.validateBitmapFieldLiteral(ctx.valueCtx, fieldInfo.width, fieldName);
+    TypeValidator.validateBitmapFieldLiteral(
+      ctx.valueCtx,
+      fieldInfo.width,
+      fieldName,
+    );
   }
 
   return fieldInfo;
@@ -96,44 +106,35 @@ function generateWriteOnlyBitmapWrite(
 /**
  * Handle simple bitmap field: flags.Running <- true
  */
-function handleBitmapFieldSingleBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleBitmapFieldSingleBit(ctx: IAssignmentContext): string {
   const varName = ctx.identifiers[0];
   const fieldName = ctx.identifiers[1];
-  const typeInfo = deps.typeRegistry.get(varName);
+  const typeInfo = CodeGenState.typeRegistry.get(varName);
   const bitmapType = typeInfo!.bitmapTypeName!;
 
-  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx, deps);
+  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx);
   return generateBitmapWrite(varName, fieldInfo, ctx.generatedValue);
 }
 
 /**
  * Handle multi-bit bitmap field: flags.Mode <- 3
  */
-function handleBitmapFieldMultiBit(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleBitmapFieldMultiBit(ctx: IAssignmentContext): string {
   // Same logic as single bit, generateBitmapWrite handles width
-  return handleBitmapFieldSingleBit(ctx, deps);
+  return handleBitmapFieldSingleBit(ctx);
 }
 
 /**
  * Handle bitmap array element field: bitmapArr[i].Field <- value
  */
-function handleBitmapArrayElementField(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleBitmapArrayElementField(ctx: IAssignmentContext): string {
   const arrayName = ctx.identifiers[0];
   const fieldName = ctx.identifiers[1];
-  const typeInfo = deps.typeRegistry.get(arrayName);
+  const typeInfo = CodeGenState.typeRegistry.get(arrayName);
   const bitmapType = typeInfo!.bitmapTypeName!;
 
-  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx, deps);
-  const index = deps.generateExpression(ctx.subscripts[0]);
+  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx);
+  const index = gen().generateExpression(ctx.subscripts[0]);
   const arrayElement = `${arrayName}[${index}]`;
 
   return generateBitmapWrite(arrayElement, fieldInfo, ctx.generatedValue);
@@ -142,22 +143,19 @@ function handleBitmapArrayElementField(
 /**
  * Handle struct member bitmap field: device.flags.Active <- true
  */
-function handleStructMemberBitmapField(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleStructMemberBitmapField(ctx: IAssignmentContext): string {
   const structName = ctx.identifiers[0];
   const memberName = ctx.identifiers[1];
   const fieldName = ctx.identifiers[2];
 
-  const structTypeInfo = deps.typeRegistry.get(structName);
-  const memberInfo = deps.getMemberTypeInfo(
+  const structTypeInfo = CodeGenState.typeRegistry.get(structName);
+  const memberInfo = CodeGenState.getMemberTypeInfo(
     structTypeInfo!.baseType,
     memberName,
   );
   const bitmapType = memberInfo!.baseType;
 
-  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx, deps);
+  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx);
   const memberPath = `${structName}.${memberName}`;
 
   return generateBitmapWrite(memberPath, fieldInfo, ctx.generatedValue);
@@ -166,18 +164,16 @@ function handleStructMemberBitmapField(
 /**
  * Handle register member bitmap field: MOTOR.CTRL.Running <- true
  */
-function handleRegisterMemberBitmapField(
-  ctx: IAssignmentContext,
-  deps: IHandlerDeps,
-): string {
+function handleRegisterMemberBitmapField(ctx: IAssignmentContext): string {
   const regName = ctx.identifiers[0];
   const memberName = ctx.identifiers[1];
   const fieldName = ctx.identifiers[2];
 
   const fullRegMember = `${regName}_${memberName}`;
-  const bitmapType = deps.symbols.registerMemberTypes.get(fullRegMember)!;
+  const bitmapType =
+    CodeGenState.symbols!.registerMemberTypes.get(fullRegMember)!;
 
-  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx, deps);
+  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx);
   return generateBitmapWrite(fullRegMember, fieldInfo, ctx.generatedValue);
 }
 
@@ -189,7 +185,6 @@ function handleRegisterMemberBitmapField(
  */
 function handleScopedRegisterMemberBitmapField(
   ctx: IAssignmentContext,
-  deps: IHandlerDeps,
 ): string {
   let scopeName: string;
   let regName: string;
@@ -198,10 +193,10 @@ function handleScopedRegisterMemberBitmapField(
 
   if (ctx.hasThis) {
     // this.REG.MEMBER.field - 3 identifiers
-    if (!deps.currentScope) {
+    if (!CodeGenState.currentScope) {
       throw new Error("Error: 'this' can only be used inside a scope");
     }
-    scopeName = deps.currentScope;
+    scopeName = CodeGenState.currentScope;
     regName = ctx.identifiers[0];
     memberName = ctx.identifiers[1];
     fieldName = ctx.identifiers[2];
@@ -213,17 +208,19 @@ function handleScopedRegisterMemberBitmapField(
     fieldName = ctx.identifiers[3];
 
     // Validate cross-scope access
-    deps.validateCrossScopeVisibility(scopeName, regName);
+    gen().validateCrossScopeVisibility(scopeName, regName);
   }
 
   const fullRegName = `${scopeName}_${regName}`;
   const fullRegMember = `${fullRegName}_${memberName}`;
-  const bitmapType = deps.symbols.registerMemberTypes.get(fullRegMember)!;
+  const bitmapType =
+    CodeGenState.symbols!.registerMemberTypes.get(fullRegMember)!;
 
-  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx, deps);
+  const fieldInfo = getBitmapFieldInfo(bitmapType, fieldName, ctx);
 
   // Check for write-only register (includes w1s, w1c)
-  const accessMod = deps.symbols.registerMemberAccess.get(fullRegMember);
+  const accessMod =
+    CodeGenState.symbols!.registerMemberAccess.get(fullRegMember);
   const isWriteOnly =
     accessMod === "wo" || accessMod === "w1s" || accessMod === "w1c";