c-next 0.1.68 → 0.1.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.68",
+  "version": "0.1.69",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -220,41 +220,6 @@ const DEFAULT_TARGET: TargetCapabilities = {
   hasBasepri: false,
 };
 
-/**
- * ADR-044: Assignment context for overflow behavior tracking
- */
-interface AssignmentContext {
-  targetName: string | null;
-  targetType: string | null;
-  overflowBehavior: TOverflowBehavior;
-}
-
-/**
- * Context for tracking current scope during code generation
- */
-interface GeneratorContext {
-  currentScope: string | null; // ADR-016: renamed from currentNamespace
-  currentFunctionName: string | null; // Issue #269: track current function for pass-by-value lookup
-  currentFunctionReturnType: string | null; // Issue #477: track return type for enum inference
-  indentLevel: number;
-  scopeMembers: Map<string, Set<string>>; // scope -> member names (ADR-016)
-  currentParameters: Map<string, TParameterInfo>; // ADR-006: track params for pointer semantics
-  // Issue #558: modifiedParameters removed - now uses analysis-phase results from CodeGenState.modifiedParameters
-  localArrays: Set<string>; // ADR-006: track local array variables (no & needed)
-  localVariables: Set<string>; // ADR-016: track local variables (allowed as bare identifiers)
-  floatBitShadows: Set<string>; // Track declared shadow variables for float bit indexing
-  floatShadowCurrent: Set<string>; // Track which shadows have current value (skip redundant memcpy reads)
-  inFunctionBody: boolean; // ADR-016: track if we're inside a function body
-  typeRegistry: Map<string, TTypeInfo>; // Track variable types for bit access and .length
-  expectedType: string | null; // For inferred struct initializers
-  mainArgsName: string | null; // Track the args parameter name for main() translation
-  assignmentContext: AssignmentContext; // ADR-044: Track current assignment for overflow
-  lastArrayInitCount: number; // ADR-035: Track element count for size inference
-  lastArrayFillValue: string | undefined; // ADR-035: Track fill-all value
-  lengthCache: Map<string, string> | null; // Cache: variable name -> temp variable name for strlen optimization
-  targetCapabilities: TargetCapabilities; // ADR-049: Target platform for atomic code generation
-}
-
 /**
  * Code Generator - Transpiles C-Next to C
  *
@@ -269,42 +234,6 @@ export default class CodeGenerator implements IOrchestrator {
       ["f64", "0.0"],
     ]);
 
-  private context: GeneratorContext =
-    CodeGenerator.createDefaultContext(DEFAULT_TARGET);
-
-  /**
-   * Create a fresh GeneratorContext with default values.
-   */
-  private static createDefaultContext(
-    targetCapabilities: TargetCapabilities,
-  ): GeneratorContext {
-    return {
-      currentScope: null,
-      currentFunctionName: null,
-      currentFunctionReturnType: null,
-      indentLevel: 0,
-      scopeMembers: new Map(),
-      currentParameters: new Map(),
-      localArrays: new Set(),
-      localVariables: new Set(),
-      floatBitShadows: new Set(),
-      floatShadowCurrent: new Set(),
-      inFunctionBody: false,
-      typeRegistry: new Map(),
-      expectedType: null,
-      mainArgsName: null,
-      assignmentContext: {
-        targetName: null,
-        targetType: null,
-        overflowBehavior: "clamp",
-      },
-      lastArrayInitCount: 0,
-      lastArrayFillValue: undefined,
-      lengthCache: null,
-      targetCapabilities,
-    };
-  }
-
   /** Token stream for comment extraction (ADR-043) */
   private tokenStream: CommonTokenStream | null = null;
 
@@ -485,7 +414,7 @@ export default class CodeGenerator implements IOrchestrator {
       expectedType: CodeGenState.expectedType,
       selfIncludeAdded: CodeGenState.selfIncludeAdded, // Issue #369
       // Issue #644: Postfix expression state
-      scopeMembers: CodeGenState.scopeMembers,
+      scopeMembers: CodeGenState.getAllScopeMembers(),
       mainArgsName: CodeGenState.mainArgsName,
       floatBitShadows: CodeGenState.floatBitShadows,
       floatShadowCurrent: CodeGenState.floatShadowCurrent,
@@ -628,7 +557,7 @@ export default class CodeGenerator implements IOrchestrator {
   resolveIdentifier(identifier: string): string {
     // Check current scope first (inner scope shadows outer)
     if (CodeGenState.currentScope) {
-      const members = CodeGenState.scopeMembers.get(CodeGenState.currentScope);
+      const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
       if (members?.has(identifier)) {
         return `${CodeGenState.currentScope}_${identifier}`;
       }
@@ -1148,10 +1077,34 @@ export default class CodeGenerator implements IOrchestrator {
       );
     }
 
+    // Issue #779: Resolve bare scope member identifiers before postfix chain processing
+    // This ensures scope members get their prefix even with array/member access.
+    // Skip parameters - they don't need scope resolution and shouldn't be dereferenced
+    // when used with array indexing (buf[idx] is valid C for pointer params).
+    // Also skip known registers - they should be handled by the postfix chain builder
+    // to enable proper register validation (requiring global. when shadowed).
+    let resolvedIdentifier = identifier ?? "";
+    if (!hasGlobal && !hasThis && identifier) {
+      const isParameter = CodeGenState.currentParameters.has(identifier);
+      const isLocalVariable = CodeGenState.localVariables.has(identifier);
+      const isKnownRegister =
+        CodeGenState.symbols?.knownRegisters.has(identifier);
+      if (!isParameter && !isLocalVariable && !isKnownRegister) {
+        const resolved = TypeValidator.resolveBareIdentifier(
+          identifier,
+          false, // not local
+          (name: string) => this.isKnownStruct(name),
+        );
+        if (resolved !== null) {
+          resolvedIdentifier = resolved;
+        }
+      }
+    }
+
     // SonarCloud S3776: Use BaseIdentifierBuilder for base identifier
     const safeIdentifier = identifier ?? "";
     const { result: baseResult, firstId } = BaseIdentifierBuilder.build(
-      safeIdentifier,
+      hasGlobal || hasThis ? safeIdentifier : resolvedIdentifier,
       hasGlobal,
       hasThis,
       CodeGenState.currentScope,
@@ -1546,36 +1499,24 @@ export default class CodeGenerator implements IOrchestrator {
     return `\ntypedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});\n`;
   }
 
-  /**
-   * Issue #268: Store unmodified parameters for a function.
-   * Maps function name -> Set of parameter names that were NOT modified.
-   * Used by Pipeline to update symbol info before header generation.
-   */
-  private readonly functionUnmodifiedParams: Map<string, Set<string>> =
-    new Map();
-
   /**
    * Issue #268: Get unmodified parameters info for all functions.
    * Returns map of function name -> Set of unmodified parameter names.
+   * Computed on-demand from functionSignatures and modifiedParameters.
    */
   getFunctionUnmodifiedParams(): ReadonlyMap<string, Set<string>> {
-    return this.functionUnmodifiedParams;
+    return CodeGenState.getUnmodifiedParameters();
   }
 
   /**
    * Issue #268: Update symbol parameters with auto-const info.
-   * Issue #558: Now uses analysis-phase results for modification tracking.
-   */
-  updateFunctionParamsAutoConst(functionName: string): void {
-    // Collect unmodified parameters for this function using analysis results
-    const unmodifiedParams = new Set<string>();
-    const modifiedSet = CodeGenState.modifiedParameters.get(functionName);
-    for (const [paramName] of CodeGenState.currentParameters) {
-      if (!modifiedSet?.has(paramName)) {
-        unmodifiedParams.add(paramName);
-      }
-    }
-    this.functionUnmodifiedParams.set(functionName, unmodifiedParams);
+   * Now a no-op - unmodified params are computed on-demand from CodeGenState.
+   * Kept for IOrchestrator interface compatibility.
+   */
+  updateFunctionParamsAutoConst(_functionName: string): void {
+    // No-op: Unmodified parameters are now computed on-demand from
+    // CodeGenState.functionSignatures and CodeGenState.modifiedParameters
+    // via CodeGenState.getUnmodifiedParameters().
   }
 
   /**
@@ -1773,23 +1714,16 @@ export default class CodeGenerator implements IOrchestrator {
    * Returns true if the callee modifies that parameter (should not have const).
    */
   isCalleeParameterModified(funcName: string, paramIndex: number): boolean {
-    const unmodifiedParams = this.functionUnmodifiedParams.get(funcName);
-    if (!unmodifiedParams) {
-      // Callee not yet processed - conservatively return false (assume unmodified)
-      // This means we won't mark our param as modified, which may cause a C compiler error
-      // if the callee actually modifies the param. The C compiler will catch this.
-      return false;
-    }
-
     // Get the parameter name at the given index from the function signature
     const sig = CodeGenState.functionSignatures.get(funcName);
     if (!sig || paramIndex >= sig.parameters.length) {
+      // Callee not yet processed - conservatively return false (assume unmodified)
       return false;
     }
 
     const paramName = sig.parameters[paramIndex].name;
-    // If the param is NOT in the unmodified set, it was modified
-    return !unmodifiedParams.has(paramName);
+    // Check directly if the parameter is in the modified set
+    return CodeGenState.isParameterModified(funcName, paramName);
   }
 
   /**
@@ -2047,7 +1981,14 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * Validate register access from inside a scope requires global. prefix
+   * Validate register access from inside a scope requires global. prefix.
+   *
+   * Issue #779: Use ambiguity-aware validation - only require global. when
+   * the register name is ACTUALLY shadowed by a local or scope member.
+   *
+   * Exceptions (no global. required):
+   * 1. Scoped registers defined within the current scope
+   * 2. Unambiguous access - no local/scope member with the same name
    */
   private _validateRegisterAccess(
     registerName: string,
@@ -2056,6 +1997,27 @@ export default class CodeGenerator implements IOrchestrator {
   ): void {
     // Only validate when inside a scope and accessing without global. prefix
     if (CodeGenState.currentScope && !hasGlobal) {
+      // Check if this is a scoped register (defined within the current scope)
+      // The registerName may already be the fully qualified name (e.g., "GPIO_PORTA")
+      // if accessed as PORTA from inside scope GPIO
+      const scopePrefix = `${CodeGenState.currentScope}_`;
+      if (registerName.startsWith(scopePrefix)) {
+        // This is a scoped register - allow bare access
+        return;
+      }
+
+      // Issue #779: Ambiguity-aware validation
+      // Only require global. if the register name is shadowed by:
+      // 1. A local variable in the current function
+      // 2. A member of the current scope
+      const isShadowedByLocal = CodeGenState.localVariables.has(registerName);
+      const isShadowedByScope = CodeGenState.isCurrentScopeMember(registerName);
+
+      if (!isShadowedByLocal && !isShadowedByScope) {
+        // Unambiguous - allow bare access
+        return;
+      }
+
       throw new Error(
         `Error: Use 'global.${registerName}.${memberName}' to access register '${registerName}' ` +
           `from inside scope '${CodeGenState.currentScope}'`,
@@ -2190,30 +2152,11 @@ export default class CodeGenerator implements IOrchestrator {
    * Reset all generator state for a fresh generation pass.
    */
   private resetGeneratorState(targetCapabilities: TargetCapabilities): void {
-    // Reset global state first
+    // Reset global state (CodeGenState.reset() handles all field initialization)
     CodeGenState.reset(targetCapabilities);
 
     // Set generator reference for handlers to use
     CodeGenState.generator = this;
-
-    // Reset local context (will gradually migrate to CodeGenState)
-    this.context = CodeGenerator.createDefaultContext(targetCapabilities);
-
-    CodeGenState.knownFunctions = new Set();
-    CodeGenState.functionSignatures = new Map();
-    CodeGenState.callbackTypes = new Map();
-    CodeGenState.callbackFieldTypes = new Map();
-    CodeGenState.usedClampOps = new Set();
-    CodeGenState.usedSafeDivOps = new Set();
-    CodeGenState.needsStdint = false;
-    CodeGenState.needsStdbool = false;
-    CodeGenState.needsString = false;
-    CodeGenState.needsFloatStaticAssert = false;
-    CodeGenState.needsISR = false;
-    CodeGenState.needsCMSIS = false;
-    CodeGenState.needsLimits = false;
-    CodeGenState.needsIrqWrappers = false;
-    CodeGenState.selfIncludeAdded = false;
   }
 
   /**
@@ -2224,7 +2167,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Copy symbol data to CodeGenState.scopeMembers
     for (const [scopeName, members] of symbols.scopeMembers) {
-      CodeGenState.scopeMembers.set(scopeName, new Set(members));
+      CodeGenState.setScopeMembers(scopeName, new Set(members));
     }
 
     // Issue #461: Initialize constValues from symbol table
@@ -2412,13 +2355,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     if (CodeGenState.needsIrqWrappers) {
-      output.push(
-        "// ADR-050: IRQ wrappers to avoid macro collisions with platform headers",
-        "static inline void __cnx_disable_irq(void) { __disable_irq(); }",
-        "static inline uint32_t __cnx_get_PRIMASK(void) { return __get_PRIMASK(); }",
-        "static inline void __cnx_set_PRIMASK(uint32_t mask) { __set_PRIMASK(mask); }",
-        "",
-      );
+      output.push(...this.generateIrqWrappers());
     }
 
     if (CodeGenState.needsISR) {
@@ -4525,7 +4462,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Scope member - may need prefixing
     if (CodeGenState.currentScope) {
-      const members = CodeGenState.scopeMembers.get(CodeGenState.currentScope);
+      const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
       if (members?.has(id)) {
         const scopedName = `${CodeGenState.currentScope}_${id}`;
         return CppModeHelper.maybeAddressOf(scopedName);
@@ -6120,6 +6057,10 @@ export default class CodeGenerator implements IOrchestrator {
     const assignCtx = buildAssignmentContext(ctx, {
       typeRegistry: CodeGenState.typeRegistry,
       generateExpression: () => value,
+      generateAssignmentTarget: (targetCtx) =>
+        this.generateAssignmentTarget(targetCtx),
+      isKnownRegister: (name) => CodeGenState.symbols!.knownRegisters.has(name),
+      currentScope: CodeGenState.currentScope,
     });
     // ADR-109: Handlers access CodeGenState directly, no deps needed
     const assignmentKind = AssignmentClassifier.classify(assignCtx);
@@ -6608,6 +6549,55 @@ export default class CodeGenerator implements IOrchestrator {
     );
   }
 
+  /**
+   * Generate platform-portable IRQ wrappers for critical sections (ADR-050, Issue #778)
+   *
+   * Generates code that works on:
+   * - ARM platforms (bare-metal or Arduino): Uses inline assembly for PRIMASK access
+   * - AVR Arduino: Uses SREG save/restore pattern
+   * - Other platforms: Falls back to CMSIS intrinsics
+   *
+   * This avoids dependencies on CMSIS headers which may not be available on all platforms
+   * (e.g., Teensy 4.x via Arduino.h doesn't expose __get_PRIMASK/__set_PRIMASK).
+   */
+  private generateIrqWrappers(): string[] {
+    return [
+      "// ADR-050: Platform-portable IRQ wrappers for critical sections",
+      "#if defined(__arm__) || defined(__ARM_ARCH)",
+      "// ARM platforms (including ARM Arduino like Teensy 4.x, Due, Zero)",
+      "// Provide inline assembly PRIMASK access to avoid CMSIS header dependencies",
+      "__attribute__((always_inline)) static inline uint32_t __cnx_get_PRIMASK(void) {",
+      "    uint32_t result;",
+      '    __asm volatile ("MRS %0, primask" : "=r" (result));',
+      "    return result;",
+      "}",
+      "__attribute__((always_inline)) static inline void __cnx_set_PRIMASK(uint32_t mask) {",
+      '    __asm volatile ("MSR primask, %0" :: "r" (mask) : "memory");',
+      "}",
+      "#if defined(ARDUINO)",
+      "static inline void __cnx_disable_irq(void) { noInterrupts(); }",
+      "#else",
+      "__attribute__((always_inline)) static inline void __cnx_disable_irq(void) {",
+      '    __asm volatile ("cpsid i" ::: "memory");',
+      "}",
+      "#endif",
+      "#elif defined(__AVR__)",
+      "// AVR Arduino: use SREG for interrupt state",
+      "// Note: Uses PRIMASK naming for API consistency across platforms (AVR has no PRIMASK)",
+      "// Returns uint8_t which is implicitly widened to uint32_t at call sites - this is intentional",
+      "static inline uint8_t __cnx_get_PRIMASK(void) { return SREG; }",
+      "static inline void __cnx_set_PRIMASK(uint8_t mask) { SREG = mask; }",
+      "static inline void __cnx_disable_irq(void) { cli(); }",
+      "#else",
+      "// Fallback: assume CMSIS is available",
+      "static inline void __cnx_disable_irq(void) { __disable_irq(); }",
+      "static inline uint32_t __cnx_get_PRIMASK(void) { return __get_PRIMASK(); }",
+      "static inline void __cnx_set_PRIMASK(uint32_t mask) { __set_PRIMASK(mask); }",
+      "#endif",
+      "",
+    ];
+  }
+
   /**
    * Mark a clamp operation as used (will trigger helper generation)
    */

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

@@ -332,7 +332,7 @@ class TypeValidator {
       return;
     }
 
-    const scopeMembers = CodeGenState.scopeMembers.get(currentScope);
+    const scopeMembers = CodeGenState.getScopeMembers(currentScope);
     if (scopeMembers?.has(identifier)) {
       throw new Error(
         `Error: Use 'this.${identifier}' to access scope member '${identifier}' inside scope '${currentScope}'`,
@@ -410,7 +410,7 @@ class TypeValidator {
     identifier: string,
     currentScope: string,
   ): string | null {
-    const scopeMembers = CodeGenState.scopeMembers.get(currentScope);
+    const scopeMembers = CodeGenState.getScopeMembers(currentScope);
     if (scopeMembers?.has(identifier)) {
       return `${currentScope}_${identifier}`;
     }

package/src/transpiler/output/codegen/__tests__/CodeGenerator.coverage.test.ts

@@ -242,7 +242,7 @@ describe("CodeGenerator Coverage Tests", () => {
 
       // Manually set up scope context to test the resolution path
       CodeGenState.currentScope = "Motor";
-      CodeGenState.scopeMembers.set("Motor", new Set(["speed", "setSpeed"]));
+      CodeGenState.setScopeMembers("Motor", new Set(["speed", "setSpeed"]));
 
       // Now resolve should return prefixed name (line 633)
       const resolved = generator.resolveIdentifier("speed");
@@ -253,7 +253,7 @@ describe("CodeGenerator Coverage Tests", () => {
       const { generator } = setupGenerator("u32 globalVar; void main() {}");
 
       CodeGenState.currentScope = "Motor";
-      CodeGenState.scopeMembers.set("Motor", new Set(["speed"]));
+      CodeGenState.setScopeMembers("Motor", new Set(["speed"]));
 
       // globalVar is not in Motor scope members
       const resolved = generator.resolveIdentifier("globalVar");

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

@@ -7318,12 +7318,15 @@ describe("CodeGenerator", () => {
         expect(code).toContain("cfg.enabled = true");
       });
 
-      it("should throw when writing register from inside scope without global prefix", () => {
+      it("should throw when writing register from inside scope when SHADOWED without global prefix", () => {
+        // Issue #779: Ambiguity-aware validation - only require global. when shadowed
         const source = `
           register GPIO @ 0x40000000 {
               DR: u32 rw @ 0x00,
           }
           scope Motor {
+              // Shadow the register name with a scope member
+              u32 GPIO <- 0;
               public void init() {
                   GPIO.DR <- 0xFF;
               }
@@ -7342,6 +7345,31 @@ describe("CodeGenerator", () => {
         ).toThrow("Use 'global.GPIO.DR' to access register");
       });
 
+      it("should allow bare register access from inside scope when NOT shadowed", () => {
+        // Issue #779: Ambiguity-aware validation - allow unambiguous access
+        const source = `
+          register GPIO @ 0x40000000 {
+              DR: u32 rw @ 0x00,
+          }
+          scope Motor {
+              public void init() {
+                  GPIO.DR <- 0xFF;
+              }
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+        const code = generator.generate(tree, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        // Should generate GPIO_DR without error since GPIO is unambiguous
+        expect(code).toContain("GPIO_DR = 0xFF");
+      });
+
       it("should generate scope member write from outside any scope", () => {
         const source = `
           scope Timer {

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

@@ -38,9 +38,7 @@ describe("TypeValidator.resolveBareIdentifier", () => {
 
   beforeEach(() => {
     CodeGenState.reset();
-    CodeGenState.scopeMembers = new Map([
-      ["Motor", new Set(["speed", "maxSpeed"])],
-    ]);
+    CodeGenState.setScopeMembers("Motor", new Set(["speed", "maxSpeed"]));
     CodeGenState.typeRegistry.set("globalCounter", {
       baseType: "u32",
       bitWidth: 32,

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

@@ -89,7 +89,9 @@ function setupState(options: SetupStateOptions = {}): void {
     CodeGenState.currentScope = options.currentScope;
   }
   if (options.scopeMembers) {
-    CodeGenState.scopeMembers = options.scopeMembers;
+    for (const [scope, members] of options.scopeMembers) {
+      CodeGenState.setScopeMembers(scope, members);
+    }
   }
   if (options.currentParameters) {
     CodeGenState.currentParameters = options.currentParameters;

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,

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.typeRegistry.get(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,7 +69,8 @@ function handleArraySlice(ctx: IAssignmentContext): string {
     );
   }
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup (includes scope prefix)
+  const name = ctx.resolvedBaseIdentifier;
   const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // Get line number for error messages
@@ -77,10 +78,12 @@ function handleArraySlice(ctx: IAssignmentContext): string {
 
   // 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}'.`,
     );
   }
 

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

@@ -33,11 +33,14 @@ function validateNotCompound(ctx: IAssignmentContext): void {
 /**
  * Handle single bit on integer variable: flags[3] <- true
  * Also handles float bit indexing: f32Var[3] <- true
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleIntegerBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  // e.g., "ArrayBug_flags" instead of "flags"
+  const name = ctx.resolvedBaseIdentifier;
   const bitIndex = gen().generateExpression(ctx.subscripts[0]);
   const typeInfo = CodeGenState.typeRegistry.get(name);
 
@@ -67,11 +70,13 @@ function handleIntegerBit(ctx: IAssignmentContext): string {
 /**
  * Handle bit range on integer variable: flags[0, 3] <- 5
  * Also handles float bit range: f32Var[0, 8] <- 0xFF
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleIntegerBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  const name = ctx.resolvedBaseIdentifier;
   const start = gen().generateExpression(ctx.subscripts[0]);
   const width = gen().generateExpression(ctx.subscripts[1]);
   const typeInfo = CodeGenState.typeRegistry.get(name);
@@ -126,15 +131,19 @@ function handleStructMemberBit(ctx: IAssignmentContext): string {
 
 /**
  * Handle bit on multi-dimensional array element: matrix[i][j][FIELD_BIT] <- false
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleArrayElementBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const arrayName = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  const arrayName = ctx.resolvedBaseIdentifier;
   const typeInfo = CodeGenState.typeRegistry.get(arrayName);
 
   if (!typeInfo?.arrayDimensions) {
-    throw new Error(`Error: ${arrayName} is not an array`);
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
+    throw new Error(`Error: ${rawName} is not an array`);
   }
 
   const numDims = typeInfo.arrayDimensions.length;
@@ -160,12 +169,14 @@ function handleArrayElementBit(ctx: IAssignmentContext): string {
  *
  * The target is a chain like array[idx].member or struct.field with a
  * bit range subscript [start, width] at the end.
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleStructChainBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   // Build the base target from postfixOps, excluding the last one (the bit range)
-  const baseId = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for the base to include scope prefix
+  const baseId = ctx.resolvedBaseIdentifier;
   const opsBeforeLast = ctx.postfixOps.slice(0, -1);
 
   let baseTarget = baseId;

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

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["Counter", "value"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers.join("_")}`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["Counter", "value"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

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

@@ -28,8 +28,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["arr"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers[0]}[i]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["arr"],
+    identifiers,
     subscripts: [{ mockValue: "i", start: { line: 1 } } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -46,6 +52,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }
@@ -96,6 +104,7 @@ describe("ArrayHandlers", () => {
         isCompound: true,
         cnextOp: "+<-",
         cOp: "+=",
+        resolvedTarget: "arr[0]",
       });
 
       const result = getHandler()!(ctx);
@@ -109,6 +118,8 @@ describe("ArrayHandlers", () => {
       });
       const ctx = createMockContext({
         identifiers: ["buffer"],
+        resolvedTarget: "buffer[idx]",
+        resolvedBaseIdentifier: "buffer",
       });
 
       const result = getHandler()!(ctx);
@@ -137,6 +148,8 @@ describe("ArrayHandlers", () => {
           { mockValue: "j", start: { line: 1 } } as never,
         ],
         subscriptDepth: 2,
+        resolvedTarget: "matrix[i][j]",
+        resolvedBaseIdentifier: "matrix",
       });
 
       const result = getHandler()!(ctx);
@@ -160,6 +173,8 @@ describe("ArrayHandlers", () => {
           { mockValue: "z", start: { line: 1 } } as never,
         ],
         subscriptDepth: 3,
+        resolvedTarget: "cube[x][y][z]",
+        resolvedBaseIdentifier: "cube",
       });
 
       const result = getHandler()!(ctx);
@@ -212,6 +227,8 @@ describe("ArrayHandlers", () => {
         ],
         isCompound: true,
         cOp: "-=",
+        resolvedTarget: "grid[0][1]",
+        resolvedBaseIdentifier: "grid",
       });
 
       const result = getHandler()!(ctx);

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

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["flags"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers[0]}[3]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["flags"],
+    identifiers,
     subscripts: [{ mockValue: "3" } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

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

@@ -25,8 +25,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["flags", "Running"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["flags", "Running"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
@@ -44,6 +50,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

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

@@ -16,8 +16,15 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["GPIO7", "DR_SET"];
+  const resolvedTarget =
+    overrides.resolvedTarget ?? `${identifiers.join("_")}[LED_BIT]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["GPIO7", "DR_SET"],
+    identifiers,
     subscripts: [{ mockValue: "LED_BIT" } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +41,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

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

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["counter"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["counter"],
+    identifiers,
     subscripts: [],
     isCompound: true,
     cnextOp: "+<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: true,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

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

@@ -16,14 +16,22 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["testVar"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["testVar"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
     cOp: "=",
     generatedValue: '"hello"',
     targetCtx: {} as never,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/helpers/MemberSeparatorResolver.ts

@@ -89,7 +89,12 @@ class MemberSeparatorResolver {
     // Scope member access: Sensor.buffer -> Sensor_buffer
     // Works with or without global. prefix (both are valid syntax)
     if (deps.isKnownScope(identifierChain[0])) {
-      deps.validateCrossScopeVisibility(identifierChain[0], memberName);
+      // Issue #779: Skip cross-scope validation for scoped register access
+      // Board.GPIO where Board_GPIO is a known register is valid
+      const scopedRegisterName = `${identifierChain[0]}_${memberName}`;
+      if (!deps.isKnownRegister(scopedRegisterName)) {
+        deps.validateCrossScopeVisibility(identifierChain[0], memberName);
+      }
       return "_";
     }
 

package/src/transpiler/state/CodeGenState.ts

@@ -187,7 +187,7 @@ export default class CodeGenState {
   static localArrays: Set<string> = new Set();
 
   /** Scope member names: scope -> Set of member names */
-  static scopeMembers: Map<string, Set<string>> = new Map();
+  private static scopeMembers: Map<string, Set<string>> = new Map();
 
   /** Float bit indexing: declared shadow variables */
   static floatBitShadows: Set<string> = new Set();
@@ -463,6 +463,26 @@ export default class CodeGenState {
     return this.modifiedParameters.get(funcName)?.has(paramName) ?? false;
   }
 
+  /**
+   * Compute unmodified parameters for all functions on-demand.
+   * Returns a map of function name -> Set of parameter names NOT modified.
+   * Computed from functionSignatures and modifiedParameters (no cached state).
+   */
+  static getUnmodifiedParameters(): Map<string, Set<string>> {
+    const result = new Map<string, Set<string>>();
+    for (const [funcName, signature] of this.functionSignatures) {
+      const modifiedSet = this.modifiedParameters.get(funcName);
+      const unmodified = new Set<string>();
+      for (const param of signature.parameters) {
+        if (!modifiedSet?.has(param.name)) {
+          unmodified.add(param.name);
+        }
+      }
+      result.set(funcName, unmodified);
+    }
+    return result;
+  }
+
   /**
    * Check if a parameter should pass by value.
    */
@@ -542,6 +562,20 @@ export default class CodeGenState {
     return this.scopeMembers.get(scopeName);
   }
 
+  /**
+   * Set members of a scope.
+   */
+  static setScopeMembers(scopeName: string, members: Set<string>): void {
+    this.scopeMembers.set(scopeName, members);
+  }
+
+  /**
+   * Get all scope members (for IGeneratorState).
+   */
+  static getAllScopeMembers(): ReadonlyMap<string, ReadonlySet<string>> {
+    return this.scopeMembers;
+  }
+
   /**
    * Check if an identifier is a member of the current scope.
    */

package/src/transpiler/state/__tests__/CodeGenState.test.ts

@@ -110,7 +110,7 @@ describe("CodeGenState", () => {
 
     it("getScopeMembers returns members for known scope", () => {
       const members = new Set(["member1", "member2"]);
-      CodeGenState.scopeMembers.set("TestScope", members);
+      CodeGenState.setScopeMembers("TestScope", members);
 
       expect(CodeGenState.getScopeMembers("TestScope")).toBe(members);
     });
@@ -122,14 +122,14 @@ describe("CodeGenState", () => {
 
     it("isCurrentScopeMember returns false for non-member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.isCurrentScopeMember("nonMember")).toBe(false);
     });
 
     it("isCurrentScopeMember returns true for member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.isCurrentScopeMember("member1")).toBe(true);
     });
@@ -143,14 +143,14 @@ describe("CodeGenState", () => {
 
     it("returns identifier unchanged when not a scope member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.resolveIdentifier("varName")).toBe("varName");
     });
 
     it("returns scoped name for scope member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.resolveIdentifier("member1")).toBe(
         "TestScope_member1",