c-next 0.1.68 → 0.1.70

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

@@ -139,7 +139,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns isBitAccess false when last op is member access", () => {
       // point.flags (no subscript at end)
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -159,7 +159,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns isBitAccess false when last subscript has 2 expressions (bit range)", () => {
       // flags[0, 8] - bit range, not single bit access
-      CodeGenState.typeRegistry.set("flags", {
+      CodeGenState.setVariableTypeInfo("flags", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -180,7 +180,7 @@ describe("MemberChainAnalyzer", () => {
       pointFields.set("flags", "u8");
       setupStructFields("Point", pointFields);
 
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -209,7 +209,7 @@ describe("MemberChainAnalyzer", () => {
       gridFields.set("items", "u8");
       setupStructFields("Grid", gridFields, new Set(["items"]));
 
-      CodeGenState.typeRegistry.set("grid", {
+      CodeGenState.setVariableTypeInfo("grid", {
         baseType: "Grid",
         bitWidth: 0,
         isArray: false,
@@ -236,7 +236,7 @@ describe("MemberChainAnalyzer", () => {
       pointFields.set("name", "string");
       setupStructFields("Point", pointFields);
 
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -263,7 +263,7 @@ describe("MemberChainAnalyzer", () => {
       deviceFields.set("flags", "u8");
       setupStructFields("Device", deviceFields);
 
-      CodeGenState.typeRegistry.set("devices", {
+      CodeGenState.setVariableTypeInfo("devices", {
         baseType: "Device",
         bitWidth: 0,
         isArray: true,
@@ -290,7 +290,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns false for 2D array element: matrix[0][1]", () => {
       // matrix[0][1] is array access, not bit access
-      CodeGenState.typeRegistry.set("matrix", {
+      CodeGenState.setVariableTypeInfo("matrix", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -315,7 +315,7 @@ describe("MemberChainAnalyzer", () => {
     it("detects bit access on 2D array element: matrix[0][1][3]", () => {
       // matrix[0][1][3] where matrix is u8[4][4]
       // The third subscript [3] is bit access on the u8 element
-      CodeGenState.typeRegistry.set("matrix", {
+      CodeGenState.setVariableTypeInfo("matrix", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -357,7 +357,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns false for member access on non-struct", () => {
       // x.field[0] where x is a primitive
-      CodeGenState.typeRegistry.set("x", {
+      CodeGenState.setVariableTypeInfo("x", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,

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

@@ -38,7 +38,7 @@ describe("StringLengthCounter", () => {
 
   describe("countExpression", () => {
     it("counts single .length access on string variable", () => {
-      CodeGenState.typeRegistry.set("myStr", {
+      CodeGenState.setVariableTypeInfo("myStr", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -54,7 +54,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("counts multiple .length accesses on same variable", () => {
-      CodeGenState.typeRegistry.set("str", {
+      CodeGenState.setVariableTypeInfo("str", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -71,7 +71,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("counts .length accesses on different string variables", () => {
-      CodeGenState.typeRegistry.set("a", {
+      CodeGenState.setVariableTypeInfo("a", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -79,7 +79,7 @@ describe("StringLengthCounter", () => {
         isString: true,
         stringCapacity: 16,
       });
-      CodeGenState.typeRegistry.set("b", {
+      CodeGenState.setVariableTypeInfo("b", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -96,7 +96,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("ignores .length on non-string variables", () => {
-      CodeGenState.typeRegistry.set("arr", {
+      CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -111,7 +111,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("ignores other member accesses", () => {
-      CodeGenState.typeRegistry.set("obj", {
+      CodeGenState.setVariableTypeInfo("obj", {
         baseType: "MyStruct",
         bitWidth: 32,
         isArray: false,
@@ -135,7 +135,7 @@ describe("StringLengthCounter", () => {
 
   describe("countBlock", () => {
     it("counts .length accesses across multiple statements", () => {
-      CodeGenState.typeRegistry.set("msg", {
+      CodeGenState.setVariableTypeInfo("msg", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -154,7 +154,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("counts .length in assignment statements", () => {
-      CodeGenState.typeRegistry.set("text", {
+      CodeGenState.setVariableTypeInfo("text", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -175,7 +175,7 @@ describe("StringLengthCounter", () => {
 
   describe("countBlockInto", () => {
     it("adds counts to existing map", () => {
-      CodeGenState.typeRegistry.set("s1", {
+      CodeGenState.setVariableTypeInfo("s1", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -183,7 +183,7 @@ describe("StringLengthCounter", () => {
         isString: true,
         stringCapacity: 32,
       });
-      CodeGenState.typeRegistry.set("s2", {
+      CodeGenState.setVariableTypeInfo("s2", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -209,7 +209,7 @@ describe("StringLengthCounter", () => {
 
   describe("nested expressions", () => {
     it("counts .length in ternary expressions", () => {
-      CodeGenState.typeRegistry.set("str", {
+      CodeGenState.setVariableTypeInfo("str", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,
@@ -225,7 +225,7 @@ describe("StringLengthCounter", () => {
     });
 
     it("counts .length in comparison expressions", () => {
-      CodeGenState.typeRegistry.set("name", {
+      CodeGenState.setVariableTypeInfo("name", {
         baseType: "char",
         bitWidth: 8,
         isArray: false,

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

@@ -144,7 +144,7 @@ class AssignmentClassifier {
     varName: string,
     fieldName: string,
   ): AssignmentKind | null {
-    const typeInfo = CodeGenState.typeRegistry.get(varName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
     if (!typeInfo?.isBitmap || !typeInfo.bitmapTypeName) {
       return null;
     }
@@ -189,7 +189,7 @@ class AssignmentClassifier {
     }
 
     // Check if struct member bitmap field: struct.bitmapMember.field
-    const structTypeInfo = CodeGenState.typeRegistry.get(firstName);
+    const structTypeInfo = CodeGenState.getVariableTypeInfo(firstName);
     if (
       !structTypeInfo ||
       !CodeGenState.isKnownStruct(structTypeInfo.baseType)
@@ -270,7 +270,7 @@ class AssignmentClassifier {
 
     const ids = ctx.identifiers;
     const firstId = ids[0];
-    const typeInfo = CodeGenState.typeRegistry.get(firstId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(firstId);
 
     // Check for bit range through struct chain: devices[0].control[0, 4]
     // Detected by last subscript having 2 expressions (start, width)
@@ -494,7 +494,7 @@ class AssignmentClassifier {
     }
 
     const name = ctx.identifiers[0];
-    const typeInfo = CodeGenState.typeRegistry.get(name) ?? null;
+    const typeInfo = CodeGenState.getVariableTypeInfo(name) ?? null;
 
     // Use shared classifier for array vs bit access decision
     // Use lastSubscriptExprCount to distinguish [0][0] (two ops, each 1 expr)
@@ -558,16 +558,16 @@ class AssignmentClassifier {
     let typeInfo;
     if (ctx.isSimpleIdentifier) {
       const id = ctx.identifiers[0];
-      typeInfo = CodeGenState.typeRegistry.get(id);
+      typeInfo = CodeGenState.getVariableTypeInfo(id);
     } else if (ctx.isSimpleThisAccess && CodeGenState.currentScope) {
       // this.member pattern: lookup using scoped name
       const memberName = ctx.identifiers[0];
       const scopedName = `${CodeGenState.currentScope}_${memberName}`;
-      typeInfo = CodeGenState.typeRegistry.get(scopedName);
+      typeInfo = CodeGenState.getVariableTypeInfo(scopedName);
     } else if (ctx.isSimpleGlobalAccess) {
       // global.member pattern: lookup using direct name
       const memberName = ctx.identifiers[0];
-      typeInfo = CodeGenState.typeRegistry.get(memberName);
+      typeInfo = CodeGenState.getVariableTypeInfo(memberName);
     } else {
       return null;
     }
@@ -604,7 +604,7 @@ class AssignmentClassifier {
   ): AssignmentKind | null {
     if (!ctx.isSimpleIdentifier) return null;
     const id = ctx.identifiers[0];
-    const typeInfo = CodeGenState.typeRegistry.get(id);
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
     return AssignmentClassifier.isSimpleStringType(typeInfo)
       ? AssignmentKind.STRING_SIMPLE
       : null;
@@ -619,7 +619,7 @@ class AssignmentClassifier {
     if (!ctx.isSimpleThisAccess || !CodeGenState.currentScope) return null;
     const memberName = ctx.identifiers[0];
     const scopedName = `${CodeGenState.currentScope}_${memberName}`;
-    const typeInfo = CodeGenState.typeRegistry.get(scopedName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(scopedName);
     return AssignmentClassifier.isSimpleStringType(typeInfo)
       ? AssignmentKind.STRING_THIS_MEMBER
       : null;
@@ -633,7 +633,7 @@ class AssignmentClassifier {
   ): AssignmentKind | null {
     if (!ctx.isSimpleGlobalAccess) return null;
     const id = ctx.identifiers[0];
-    const typeInfo = CodeGenState.typeRegistry.get(id);
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
     return AssignmentClassifier.isSimpleStringType(typeInfo)
       ? AssignmentKind.STRING_GLOBAL
       : null;
@@ -644,7 +644,7 @@ class AssignmentClassifier {
    * Returns the base struct type if valid, null if not a known struct.
    */
   private static _resolveStructType(structName: string): string | null {
-    const structTypeInfo = CodeGenState.typeRegistry.get(structName);
+    const structTypeInfo = CodeGenState.getVariableTypeInfo(structName);
     if (
       !structTypeInfo ||
       !CodeGenState.isKnownStruct(structTypeInfo.baseType)

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

@@ -18,6 +18,15 @@ interface IContextBuilderDeps {
 
   /** Generate C expression for a value */
   generateExpression(ctx: Parser.ExpressionContext): string;
+
+  /** Generate fully-resolved assignment target with scope prefixes */
+  generateAssignmentTarget(ctx: Parser.AssignmentTargetContext): string;
+
+  /** Check if an identifier is a known register (for skipping resolution) */
+  isKnownRegister(name: string): boolean;
+
+  /** Current scope name (for scoped register detection) */
+  currentScope: string | null;
 }
 
 /**
@@ -32,6 +41,37 @@ interface ITargetExtraction {
   lastSubscriptExprCount: number;
 }
 
+/**
+ * Extract the base identifier from a resolved target string.
+ * Removes subscripts ([...]) from the resolved target.
+ * Examples:
+ *   "ArrayBug_data[0]" -> "ArrayBug_data"
+ *   "matrix[i][j]" -> "matrix"
+ *   "item.field" -> "item"
+ *   "Motor_speed" -> "Motor_speed"
+ */
+function extractResolvedBaseIdentifier(resolvedTarget: string): string {
+  // Assumes resolvedTarget always starts with a valid identifier (not empty or starting with [ . ->)
+  // as generated by generateAssignmentTarget()
+  const bracketIndex = resolvedTarget.indexOf("[");
+  const dotIndex = resolvedTarget.indexOf(".");
+  const arrowIndex = resolvedTarget.indexOf("->");
+
+  // Find the earliest terminator
+  let endIndex = resolvedTarget.length;
+  if (bracketIndex !== -1 && bracketIndex < endIndex) {
+    endIndex = bracketIndex;
+  }
+  if (dotIndex !== -1 && dotIndex < endIndex) {
+    endIndex = dotIndex;
+  }
+  if (arrowIndex !== -1 && arrowIndex < endIndex) {
+    endIndex = arrowIndex;
+  }
+
+  return resolvedTarget.substring(0, endIndex);
+}
+
 /**
  * Extract base identifier from assignment target.
  * With unified grammar, all patterns use IDENTIFIER postfixTargetOp*.
@@ -100,6 +140,13 @@ function buildAssignmentContext(
   // Generate value expression
   const generatedValue = deps.generateExpression(valueCtx);
 
+  // Generate fully-resolved target (with scope prefixes)
+  const resolvedTarget = deps.generateAssignmentTarget(targetCtx);
+
+  // Extract resolved base identifier for type lookups
+  // Removes subscripts ([...]) and member access (. or ->) from the end
+  const resolvedBaseIdentifier = extractResolvedBaseIdentifier(resolvedTarget);
+
   // Extract target info
   const hasGlobal = targetCtx.GLOBAL() !== null;
   const hasThis = targetCtx.THIS() !== null;
@@ -152,6 +199,8 @@ function buildAssignmentContext(
     cOp,
     isCompound,
     generatedValue,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     firstIdTypeInfo,
     memberAccessDepth,
     subscriptDepth,

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

@@ -67,6 +67,21 @@ interface IAssignmentContext {
   /** Generated C expression for the value (right-hand side) */
   readonly generatedValue: string;
 
+  /**
+   * Fully-resolved assignment target with scope prefixes applied.
+   * Use this instead of raw identifiers to ensure proper scope resolution.
+   * Example: "data" inside scope ArrayBug -> "ArrayBug_data"
+   */
+  readonly resolvedTarget: string;
+
+  /**
+   * Resolved base identifier for type lookups.
+   * Extracted from resolvedTarget by removing subscripts and member access.
+   * Example: "ArrayBug_data[0]" -> "ArrayBug_data"
+   * Use this for CodeGenState.typeRegistry lookups instead of identifiers[0].
+   */
+  readonly resolvedBaseIdentifier: string;
+
   // === Type info (looked up from registry) ===
 
   /** First identifier's type info, if found */

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

@@ -15,6 +15,11 @@ import TTypeInfo from "../../types/TTypeInfo";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Compute resolvedBaseIdentifier from resolvedTarget if not explicitly provided
+  const resolvedTarget = overrides.resolvedTarget ?? "x";
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? resolvedTarget.split(/[[.]/)[0];
+
   return {
     statementCtx: {} as IAssignmentContext["statementCtx"],
     targetCtx: {} as IAssignmentContext["targetCtx"],
@@ -31,6 +36,8 @@ function createMockContext(
     cOp: "=",
     isCompound: false,
     generatedValue: "5",
+    resolvedTarget,
+    resolvedBaseIdentifier,
     firstIdTypeInfo: null,
     memberAccessDepth: 0,
     subscriptDepth: 0,
@@ -141,7 +148,7 @@ describe("AssignmentClassifier - Bitmap Fields", () => {
       ["StatusFlags", new Map([["Running", { offset: 0, width: 1 }]])],
     ]);
     setupSymbols({ bitmapFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "flags",
       createTypeInfo({ isBitmap: true, bitmapTypeName: "StatusFlags" }),
     );
@@ -162,7 +169,7 @@ describe("AssignmentClassifier - Bitmap Fields", () => {
       ["StatusFlags", new Map([["Mode", { offset: 4, width: 4 }]])],
     ]);
     setupSymbols({ bitmapFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "flags",
       createTypeInfo({ isBitmap: true, bitmapTypeName: "StatusFlags" }),
     );
@@ -206,7 +213,7 @@ describe("AssignmentClassifier - Bitmap Fields", () => {
       ["Device", new Map([["flags", "DeviceFlags"]])],
     ]);
     setupSymbols({ bitmapFields, knownStructs, structFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "device",
       createTypeInfo({ baseType: "Device" }),
     );
@@ -233,7 +240,10 @@ describe("AssignmentClassifier - Integer Bit Access", () => {
   });
 
   it("classifies single bit access on integer", () => {
-    CodeGenState.typeRegistry.set("flags", createTypeInfo({ baseType: "u8" }));
+    CodeGenState.setVariableTypeInfo(
+      "flags",
+      createTypeInfo({ baseType: "u8" }),
+    );
 
     const ctx = createMockContext({
       identifiers: ["flags"],
@@ -246,7 +256,10 @@ describe("AssignmentClassifier - Integer Bit Access", () => {
   });
 
   it("classifies bit range access on integer", () => {
-    CodeGenState.typeRegistry.set("flags", createTypeInfo({ baseType: "u32" }));
+    CodeGenState.setVariableTypeInfo(
+      "flags",
+      createTypeInfo({ baseType: "u32" }),
+    );
 
     const ctx = createMockContext({
       identifiers: ["flags"],
@@ -275,7 +288,7 @@ describe("AssignmentClassifier - Array Access", () => {
   });
 
   it("classifies simple array element", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "arr",
       createTypeInfo({
         isArray: true,
@@ -296,7 +309,7 @@ describe("AssignmentClassifier - Array Access", () => {
   });
 
   it("classifies array slice", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "buffer",
       createTypeInfo({
         isArray: true,
@@ -329,7 +342,7 @@ describe("AssignmentClassifier - String Assignments", () => {
   });
 
   it("classifies simple string variable", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "name",
       createTypeInfo({
         baseType: "string<32>",
@@ -341,7 +354,7 @@ describe("AssignmentClassifier - String Assignments", () => {
     const ctx = createMockContext({
       identifiers: ["name"],
       isSimpleIdentifier: true,
-      firstIdTypeInfo: CodeGenState.typeRegistry.get("name")!,
+      firstIdTypeInfo: CodeGenState.getVariableTypeInfo("name")!,
     });
 
     expect(AssignmentClassifier.classify(ctx)).toBe(
@@ -355,7 +368,7 @@ describe("AssignmentClassifier - String Assignments", () => {
       ["Person", new Map([["name", "string<64>"]])],
     ]);
     setupSymbols({ knownStructs, structFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "person",
       createTypeInfo({ baseType: "Person" }),
     );
@@ -382,7 +395,7 @@ describe("AssignmentClassifier - Special Compound", () => {
   });
 
   it("classifies atomic RMW", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "counter",
       createTypeInfo({
         baseType: "u32",
@@ -401,7 +414,7 @@ describe("AssignmentClassifier - Special Compound", () => {
   });
 
   it("classifies overflow clamp", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "saturated",
       createTypeInfo({
         baseType: "u8",
@@ -422,7 +435,7 @@ describe("AssignmentClassifier - Special Compound", () => {
   });
 
   it("does not classify float as overflow clamp", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "value",
       createTypeInfo({
         baseType: "f32",
@@ -641,7 +654,7 @@ describe("AssignmentClassifier - Bitmap Array Element Field", () => {
       ["StatusFlags", new Map([["Active", { offset: 0, width: 1 }]])],
     ]);
     setupSymbols({ bitmapFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "flagsArr",
       createTypeInfo({
         isBitmap: true,
@@ -675,7 +688,7 @@ describe("AssignmentClassifier - Multi-dim Array Bit Indexing", () => {
   });
 
   it("classifies matrix[i][j][bit] as ARRAY_ELEMENT_BIT", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "matrix",
       createTypeInfo({
         baseType: "u32",
@@ -702,7 +715,7 @@ describe("AssignmentClassifier - Multi-dim Array Bit Indexing", () => {
   });
 
   it("classifies matrix[i][j] as MULTI_DIM_ARRAY_ELEMENT", () => {
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "matrix",
       createTypeInfo({
         baseType: "u32",
@@ -868,7 +881,7 @@ describe("AssignmentClassifier - Member Chain", () => {
     const knownStructs = new Set(["Config"]);
     const structFields = new Map([["Config", new Map([["items", "Item"]])]]);
     setupSymbols({ knownStructs, structFields });
-    CodeGenState.typeRegistry.set(
+    CodeGenState.setVariableTypeInfo(
       "config",
       createTypeInfo({ baseType: "Config" }),
     );

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

@@ -20,26 +20,30 @@ function gen(): ICodeGenApi {
 
 /**
  * Handle simple array element: arr[i] <- value
+ *
+ * Uses resolvedTarget which includes scope prefix and subscript,
+ * e.g., "data[0]" inside scope ArrayBug -> "ArrayBug_data[0]"
  */
 function handleArrayElement(ctx: IAssignmentContext): string {
-  const name = ctx.identifiers[0];
-  const index = gen().generateExpression(ctx.subscripts[0]);
-
-  return `${name}[${index}] ${ctx.cOp} ${ctx.generatedValue};`;
+  return `${ctx.resolvedTarget} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
 /**
  * Handle multi-dimensional array element: matrix[i][j] <- value
+ *
+ * Uses resolvedTarget which includes scope prefix and all subscripts.
+ * Uses resolvedBaseIdentifier for type lookups to support scoped arrays.
  */
 function handleMultiDimArrayElement(ctx: IAssignmentContext): string {
-  const name = ctx.identifiers[0];
-  const typeInfo = CodeGenState.typeRegistry.get(name);
+  // Use resolvedBaseIdentifier for type lookup (includes scope prefix)
+  // e.g., "ArrayBug_data" instead of "data"
+  const typeInfo = CodeGenState.getVariableTypeInfo(ctx.resolvedBaseIdentifier);
 
   // ADR-036: Compile-time bounds checking for constant indices
   if (typeInfo?.arrayDimensions) {
     const line = ctx.subscripts[0]?.start?.line ?? 0;
     TypeValidator.checkArrayBounds(
-      name,
+      ctx.resolvedBaseIdentifier,
       [...typeInfo.arrayDimensions],
       [...ctx.subscripts],
       line,
@@ -47,11 +51,7 @@ function handleMultiDimArrayElement(ctx: IAssignmentContext): string {
     );
   }
 
-  const indices = ctx.subscripts
-    .map((e) => gen().generateExpression(e))
-    .join("][");
-
-  return `${name}[${indices}] ${ctx.cOp} ${ctx.generatedValue};`;
+  return `${ctx.resolvedTarget} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
 /**
@@ -69,18 +69,21 @@ function handleArraySlice(ctx: IAssignmentContext): string {
     );
   }
 
-  const name = ctx.identifiers[0];
-  const typeInfo = CodeGenState.typeRegistry.get(name);
+  // Use resolvedBaseIdentifier for type lookup (includes scope prefix)
+  const name = ctx.resolvedBaseIdentifier;
+  const typeInfo = CodeGenState.getVariableTypeInfo(name);
 
   // Get line number for error messages
   const line = ctx.subscripts[0].start?.line ?? 0;
 
   // Validate 1D array only
   if (typeInfo?.arrayDimensions && typeInfo.arrayDimensions.length > 1) {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
       `${line}:0 Error: Slice assignment is only valid on one-dimensional arrays. ` +
-        `'${name}' has ${typeInfo.arrayDimensions.length} dimensions. ` +
-        `Access the innermost dimension first (e.g., ${name}[index][offset, length]).`,
+        `'${rawName}' has ${typeInfo.arrayDimensions.length} dimensions. ` +
+        `Access the innermost dimension first (e.g., ${rawName}[index][offset, length]).`,
     );
   }
 
@@ -109,17 +112,21 @@ function handleArraySlice(ctx: IAssignmentContext): string {
   } else if (typeInfo?.arrayDimensions?.[0]) {
     capacity = typeInfo.arrayDimensions[0];
   } else {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
-      `${line}:0 Error: Cannot determine buffer size for '${name}' at compile time.`,
+      `${line}:0 Error: Cannot determine buffer size for '${rawName}' at compile time.`,
     );
   }
 
   // Bounds validation
   if (offsetValue + lengthValue > capacity) {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
       `${line}:0 Error: Slice assignment out of bounds: ` +
         `offset(${offsetValue}) + length(${lengthValue}) = ${offsetValue + lengthValue} ` +
-        `exceeds buffer capacity(${capacity}) for '${name}'.`,
+        `exceeds buffer capacity(${capacity}) for '${rawName}'.`,
     );
   }