c-next 0.1.68 → 0.1.70

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

@@ -120,20 +120,16 @@ import CodegenParserUtils from "./utils/CodegenParserUtils";
 import IMemberSeparatorDeps from "./types/IMemberSeparatorDeps";
 import IParameterDereferenceDeps from "./types/IParameterDereferenceDeps";
 import ISeparatorContext from "./types/ISeparatorContext";
-// Issue #566: Statement expression collection for const inference
-import StatementExpressionCollector from "./helpers/StatementExpressionCollector";
-// Issue #269: Transitive modification propagation for const inference
-import TransitiveModificationPropagator from "./helpers/TransitiveModificationPropagator";
-// Issue #566: Child statement/block collection for const inference
-import ChildStatementCollector from "./helpers/ChildStatementCollector";
-// SonarCloud S3776: Assignment target extraction for walkStatementForModifications
-import AssignmentTargetExtractor from "./helpers/AssignmentTargetExtractor";
+// Issue #269: Transitive modification propagation for const inference (used by analyzeModificationsOnly)
+import TransitiveModificationPropagator from "../../logic/analysis/helpers/TransitiveModificationPropagator";
 // Phase 3: Type generation helper for improved testability
 import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 // Phase 5: Cast validation helper for improved testability
 import CastValidator from "./helpers/CastValidator";
 // Global state for code generation (simplifies debugging, eliminates DI complexity)
 import CodeGenState from "../../state/CodeGenState";
+// Issue #269: Pass-by-value analysis extracted from CodeGenerator
+import PassByValueAnalyzer from "../../logic/analysis/PassByValueAnalyzer";
 // Unified parameter generation (Phase 1)
 import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
 import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
@@ -220,41 +216,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 +230,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;
 
@@ -458,7 +383,7 @@ export default class CodeGenerator implements IOrchestrator {
     return {
       symbolTable: CodeGenState.symbolTable,
       symbols: CodeGenState.symbols,
-      typeRegistry: CodeGenState.typeRegistry,
+      typeRegistry: CodeGenState.getTypeRegistryView(),
       functionSignatures: CodeGenState.functionSignatures,
       knownFunctions: CodeGenState.knownFunctions,
       knownStructs: CodeGenState.symbols?.knownStructs ?? new Set(),
@@ -485,7 +410,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,
@@ -522,7 +447,7 @@ export default class CodeGenerator implements IOrchestrator {
 
         // Type registration effects
         case "register-type":
-          CodeGenState.typeRegistry.set(effect.name, effect.info);
+          CodeGenState.setVariableTypeInfo(effect.name, effect.info);
           break;
         case "register-local":
           CodeGenState.localVariables.add(effect.name);
@@ -628,7 +553,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}`;
       }
@@ -798,7 +723,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Check if it's a simple variable of string type
     if (/^[a-zA-Z_]\w*$/.exec(text)) {
-      const typeInfo = CodeGenState.typeRegistry.get(text);
+      const typeInfo = CodeGenState.getVariableTypeInfo(text);
       if (typeInfo?.isString) {
         return true;
       }
@@ -830,7 +755,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     const arrayName = arrayAccessMatch[1];
-    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(arrayName);
     if (!typeInfo) {
       return false;
     }
@@ -1148,10 +1073,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,
@@ -1415,7 +1364,7 @@ export default class CodeGenerator implements IOrchestrator {
     // Variable - check type registry
     const identifierRegex = /^[a-zA-Z_]\w*$/;
     if (identifierRegex.test(exprCode)) {
-      const typeInfo = CodeGenState.typeRegistry.get(exprCode);
+      const typeInfo = CodeGenState.getVariableTypeInfo(exprCode);
       if (typeInfo?.isString && typeInfo.stringCapacity !== undefined) {
         return typeInfo.stringCapacity;
       }
@@ -1546,36 +1495,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().
   }
 
   /**
@@ -1663,7 +1600,7 @@ export default class CodeGenerator implements IOrchestrator {
     const injectedFuncs = new Set(crossFileModifications?.keys() ?? []);
 
     // Run modification analysis on the tree (adds to what was injected)
-    this.collectFunctionParametersAndModifications(tree);
+    PassByValueAnalyzer.collectFunctionParametersAndModifications(tree);
 
     // Issue #565: Run transitive propagation with full context
     TransitiveModificationPropagator.propagate(
@@ -1773,23 +1710,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);
   }
 
   /**
@@ -2017,7 +1947,7 @@ export default class CodeGenerator implements IOrchestrator {
       isKnownPrimitive: (typeName: string) => this._isKnownPrimitive(typeName),
       knownEnums: CodeGenState.symbols!.knownEnums,
       isParameterPassByValue: (funcName: string, paramName: string) =>
-        this._isParameterPassByValueByName(funcName, paramName),
+        PassByValueAnalyzer.isParameterPassByValueByName(funcName, paramName),
       currentFunctionName: CodeGenState.currentFunctionName,
       maybeDereference: (id: string) => CppModeHelper.maybeDereference(id),
     };
@@ -2047,7 +1977,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 +1993,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 +2148,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 +2163,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
@@ -2253,7 +2192,7 @@ export default class CodeGenerator implements IOrchestrator {
   private initializeHelperObjects(tree: Parser.ProgramContext): void {
     // Collect function/callback information
     this.collectFunctionsAndCallbacks(tree);
-    this.analyzePassByValue(tree);
+    PassByValueAnalyzer.analyze(tree);
   }
 
   /**
@@ -2412,13 +2351,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) {
@@ -2686,581 +2619,15 @@ export default class CodeGenerator implements IOrchestrator {
   // Issue #63: validateBitmapFieldLiteral moved to TypeValidator
   // Issue #60: evaluateConstantExpression method removed - now in SymbolCollector
 
-  // ========================================================================
-  // Issue #269: Pass-by-value analysis for small unmodified parameters
-  // ========================================================================
-
-  /**
-   * Analyze all functions to determine which parameters should pass by value.
-   * This runs before code generation and populates passByValueParams.
-   * SonarCloud S3776: Refactored to use helper methods.
-   */
-  private analyzePassByValue(tree: Parser.ProgramContext): void {
-    // Reset analysis state
-    CodeGenState.modifiedParameters.clear();
-    CodeGenState.passByValueParams.clear();
-    CodeGenState.functionCallGraph.clear();
-    CodeGenState.functionParamLists.clear();
-
-    // Phase 1: Collect function parameter lists and direct modifications
-    this.collectFunctionParametersAndModifications(tree);
-
-    // Issue #558: Inject cross-file data before transitive propagation
-    this.injectCrossFileModifications();
-    this.injectCrossFileParamLists();
-
-    // Phase 2: Fixed-point iteration for transitive modifications
-    TransitiveModificationPropagator.propagate(
-      CodeGenState.functionCallGraph,
-      CodeGenState.functionParamLists,
-      CodeGenState.modifiedParameters,
-    );
-
-    // Phase 3: Determine which parameters can pass by value
-    this.computePassByValueParams();
-  }
-
-  /**
-   * Inject cross-file modification data into modifiedParameters.
-   * SonarCloud S3776: Extracted from analyzePassByValue().
-   */
-  private injectCrossFileModifications(): void {
-    if (!CodeGenState.pendingCrossFileModifications) return;
-
-    for (const [
-      funcName,
-      params,
-    ] of CodeGenState.pendingCrossFileModifications) {
-      const existing = CodeGenState.modifiedParameters.get(funcName);
-      if (existing) {
-        for (const param of params) {
-          existing.add(param);
-        }
-      } else {
-        CodeGenState.modifiedParameters.set(funcName, new Set(params));
-      }
-    }
-    CodeGenState.pendingCrossFileModifications = null; // Clear after use
-  }
-
-  /**
-   * Inject cross-file parameter lists into functionParamLists.
-   * SonarCloud S3776: Extracted from analyzePassByValue().
-   */
-  private injectCrossFileParamLists(): void {
-    if (!CodeGenState.pendingCrossFileParamLists) return;
-
-    for (const [funcName, params] of CodeGenState.pendingCrossFileParamLists) {
-      if (!CodeGenState.functionParamLists.has(funcName)) {
-        CodeGenState.functionParamLists.set(funcName, [...params]);
-      }
-    }
-    CodeGenState.pendingCrossFileParamLists = null; // Clear after use
-  }
-
-  /**
-   * Phase 1: Walk all functions to collect:
-   * - Parameter lists (for call graph resolution)
-   * - Direct modifications (param <- value)
-   * - Function calls where params are passed as arguments
-   */
-  private collectFunctionParametersAndModifications(
-    tree: Parser.ProgramContext,
-  ): void {
-    for (const decl of tree.declaration()) {
-      // Handle scope-level functions
-      if (decl.scopeDeclaration()) {
-        const scopeDecl = decl.scopeDeclaration()!;
-        const scopeName = scopeDecl.IDENTIFIER().getText();
-
-        for (const member of scopeDecl.scopeMember()) {
-          if (member.functionDeclaration()) {
-            const funcDecl = member.functionDeclaration()!;
-            const funcName = funcDecl.IDENTIFIER().getText();
-            const fullName = `${scopeName}_${funcName}`;
-            this.analyzeFunctionForModifications(fullName, funcDecl);
-          }
-        }
-      }
-
-      // Handle top-level functions
-      if (decl.functionDeclaration()) {
-        const funcDecl = decl.functionDeclaration()!;
-        const name = funcDecl.IDENTIFIER().getText();
-        this.analyzeFunctionForModifications(name, funcDecl);
-      }
-    }
-  }
-
-  /**
-   * Analyze a single function for parameter modifications and call graph edges.
-   */
-  private analyzeFunctionForModifications(
-    funcName: string,
-    funcDecl: Parser.FunctionDeclarationContext,
-  ): void {
-    // Collect parameter names
-    const paramNames: string[] = [];
-    const paramList = funcDecl.parameterList();
-    if (paramList) {
-      for (const param of paramList.parameter()) {
-        paramNames.push(param.IDENTIFIER().getText());
-      }
-    }
-    CodeGenState.functionParamLists.set(funcName, paramNames);
-
-    // Initialize modified set
-    CodeGenState.modifiedParameters.set(funcName, new Set());
-    // Issue #579: Initialize subscript access tracking
-    CodeGenState.subscriptAccessedParameters.set(funcName, new Set());
-    CodeGenState.functionCallGraph.set(funcName, []);
-
-    // Walk the function body to find modifications and calls
-    const block = funcDecl.block();
-    if (block) {
-      this.walkBlockForModifications(funcName, paramNames, block);
-    }
-  }
-
-  /**
-   * Walk a block to find parameter modifications and function calls.
-   */
-  private walkBlockForModifications(
-    funcName: string,
-    paramNames: string[],
-    block: Parser.BlockContext,
-  ): void {
-    const paramSet = new Set(paramNames);
-
-    for (const stmt of block.statement()) {
-      this.walkStatementForModifications(funcName, paramSet, stmt);
-    }
-  }
-
-  /**
-   * Walk a statement recursively looking for modifications and calls.
-   * Issue #566: Refactored to use helper methods for expression and child collection.
-   */
-  private walkStatementForModifications(
-    funcName: string,
-    paramSet: Set<string>,
-    stmt: Parser.StatementContext,
-  ): void {
-    // 1. Check for parameter modifications via assignment targets
-    if (stmt.assignmentStatement()) {
-      this.trackAssignmentModifications(funcName, paramSet, stmt);
-    }
-
-    // 2. Walk all expressions in this statement for function calls and subscript access
-    for (const expr of StatementExpressionCollector.collectAll(stmt)) {
-      this.walkExpressionForCalls(funcName, paramSet, expr);
-      // Issue #579: Also track subscript read access on parameters
-      this.walkExpressionForSubscriptAccess(funcName, paramSet, expr);
-    }
-
-    // 3. Recurse into child statements and blocks
-    const { statements, blocks } = ChildStatementCollector.collectAll(stmt);
-    for (const childStmt of statements) {
-      this.walkStatementForModifications(funcName, paramSet, childStmt);
-    }
-    for (const block of blocks) {
-      this.walkBlockForModifications(funcName, [...paramSet], block);
-    }
-  }
-
-  /**
-   * Track assignment modifications for parameter const inference.
-   * SonarCloud S3776: Extracted from walkStatementForModifications().
-   */
-  private trackAssignmentModifications(
-    funcName: string,
-    paramSet: Set<string>,
-    stmt: Parser.StatementContext,
-  ): void {
-    const assign = stmt.assignmentStatement()!;
-    const target = assign.assignmentTarget();
-
-    const { baseIdentifier, hasSingleIndexSubscript } =
-      AssignmentTargetExtractor.extract(target);
-
-    // Issue #579: Track subscript access on parameters (for write path)
-    if (
-      hasSingleIndexSubscript &&
-      baseIdentifier &&
-      paramSet.has(baseIdentifier)
-    ) {
-      CodeGenState.subscriptAccessedParameters
-        .get(funcName)!
-        .add(baseIdentifier);
-    }
-
-    // Track as modified parameter
-    if (baseIdentifier && paramSet.has(baseIdentifier)) {
-      CodeGenState.modifiedParameters.get(funcName)!.add(baseIdentifier);
-    }
-  }
-
-  /**
-   * Walk an expression tree to find function calls where parameters are passed.
-   * Uses recursive descent through the expression hierarchy.
-   */
-  private walkExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    expr: Parser.ExpressionContext,
-  ): void {
-    // Expression -> TernaryExpression -> OrExpression -> ... -> PostfixExpression
-    const ternary = expr.ternaryExpression();
-    if (ternary) {
-      // Walk all orExpression children
-      for (const orExpr of ternary.orExpression()) {
-        this.walkOrExpressionForCalls(funcName, paramSet, orExpr);
-      }
-    }
-  }
-
-  /**
-   * Issue #579: Walk an expression tree to find subscript access on parameters.
-   * This tracks read access like `buf[i]` where buf is a parameter.
-   * Parameters with subscript access must become pointers.
-   */
-  private walkExpressionForSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    expr: Parser.ExpressionContext,
-  ): void {
-    const ternary = expr.ternaryExpression();
-    if (ternary) {
-      for (const orExpr of ternary.orExpression()) {
-        this.walkOrExpression(orExpr, (unaryExpr) => {
-          this.handleSubscriptAccess(funcName, paramSet, unaryExpr);
-        });
-      }
-    }
-  }
-
-  /**
-   * Issue #579: Handle subscript access on a unary expression.
-   * Only tracks single-index subscript access (which could be array access).
-   * Two-index subscript (e.g., value[start, width]) is always bit extraction,
-   * so it doesn't require the parameter to become a pointer.
-   */
-  private handleSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    unaryExpr: Parser.UnaryExpressionContext,
-  ): void {
-    const postfixExpr = unaryExpr.postfixExpression();
-    if (!postfixExpr) return;
-
-    const primary = postfixExpr.primaryExpression();
-    const ops = postfixExpr.postfixOp();
-
-    // Check if primary is a parameter and there's subscript access
-    const primaryId = primary.IDENTIFIER()?.getText();
-    if (!primaryId || !paramSet.has(primaryId)) {
-      return;
-    }
-
-    // Only track SINGLE-index subscript access (potential array access)
-    // Two-index subscript like value[0, 8] is bit extraction, not array access
-    const hasSingleIndexSubscript = ops.some(
-      (op) => op.expression().length === 1,
-    );
-    if (hasSingleIndexSubscript) {
-      CodeGenState.subscriptAccessedParameters.get(funcName)!.add(primaryId);
-    }
-  }
-
-  /**
-   * Generic walker for orExpression trees.
-   * Walks through the expression hierarchy and calls the handler for each unaryExpression.
-   * Used by both function call tracking and subscript access tracking.
-   */
-  private walkOrExpression(
-    orExpr: Parser.OrExpressionContext,
-    handler: (unaryExpr: Parser.UnaryExpressionContext) => void,
-  ): void {
-    orExpr
-      .andExpression()
-      .flatMap((and) => and.equalityExpression())
-      .flatMap((eq) => eq.relationalExpression())
-      .flatMap((rel) => rel.bitwiseOrExpression())
-      .flatMap((bor) => bor.bitwiseXorExpression())
-      .flatMap((bxor) => bxor.bitwiseAndExpression())
-      .flatMap((band) => band.shiftExpression())
-      .flatMap((shift) => shift.additiveExpression())
-      .flatMap((add) => add.multiplicativeExpression())
-      .flatMap((mul) => mul.unaryExpression())
-      .forEach(handler);
-  }
-
-  /**
-   * Walk an orExpression tree for function calls.
-   */
-  private walkOrExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    orExpr: Parser.OrExpressionContext,
-  ): void {
-    this.walkOrExpression(orExpr, (unaryExpr) => {
-      this.walkUnaryExpressionForCalls(funcName, paramSet, unaryExpr);
-    });
-  }
-
-  /**
-   * Walk a unaryExpression tree for function calls.
-   */
-  private walkUnaryExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    unaryExpr: Parser.UnaryExpressionContext,
-  ): void {
-    // Recurse into nested unary
-    if (unaryExpr.unaryExpression()) {
-      this.walkUnaryExpressionForCalls(
-        funcName,
-        paramSet,
-        unaryExpr.unaryExpression()!,
-      );
-      return;
-    }
-
-    // Check postfix expression
-    const postfix = unaryExpr.postfixExpression();
-    if (postfix) {
-      this.walkPostfixExpressionForCalls(funcName, paramSet, postfix);
-    }
-  }
-
-  /**
-   * Walk a postfixExpression for function calls.
-   * This is where function calls are found: primaryExpr followed by '(' args ')'
-   */
-  private walkPostfixExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    postfix: Parser.PostfixExpressionContext,
-  ): void {
-    const primary = postfix.primaryExpression();
-    const postfixOps = postfix.postfixOp();
-
-    // Handle simple function calls: IDENTIFIER followed by '(' ... ')'
-    this.handleSimpleFunctionCall(funcName, paramSet, primary, postfixOps);
-
-    // Issue #365: Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
-    this.handleScopeQualifiedCalls(funcName, paramSet, primary, postfixOps);
-
-    // Recurse into primary expression if it's a parenthesized expression
-    if (primary.expression()) {
-      this.walkExpressionForCalls(funcName, paramSet, primary.expression()!);
-    }
-
-    // Walk arguments in any postfix function call ops (for nested calls)
-    this.walkPostfixOpsRecursively(funcName, paramSet, postfixOps);
-  }
-
-  /**
-   * Handle simple function calls: IDENTIFIER followed by '(' ... ')'
-   */
-  private handleSimpleFunctionCall(
-    funcName: string,
-    paramSet: Set<string>,
-    primary: Parser.PrimaryExpressionContext,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    if (!primary.IDENTIFIER() || postfixOps.length === 0) return;
-
-    const firstOp = postfixOps[0];
-    if (!firstOp.LPAREN()) return;
-
-    const calleeName = primary.IDENTIFIER()!.getText();
-    this.recordCallsFromArgList(funcName, paramSet, calleeName, firstOp);
-  }
-
-  /**
-   * Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
-   * Track member accesses to build the mangled callee name (e.g., Storage_load)
-   */
-  private handleScopeQualifiedCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    primary: Parser.PrimaryExpressionContext,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    if (postfixOps.length === 0) return;
-
-    const memberNames = this.collectInitialMemberNames(funcName, primary);
-
-    for (const op of postfixOps) {
-      if (op.IDENTIFIER()) {
-        memberNames.push(op.IDENTIFIER()!.getText());
-      } else if (op.LPAREN() && memberNames.length >= 1) {
-        const calleeName = memberNames.join("_");
-        this.recordCallsFromArgList(funcName, paramSet, calleeName, op);
-        memberNames.length = 0; // Reset for potential chained calls
-      } else if (op.expression().length > 0) {
-        memberNames.length = 0; // Array subscript breaks scope chain
-      }
-    }
-  }
-
-  /**
-   * Collect initial member names from primary expression for scope resolution.
-   * Issue #561: When 'this' is used, resolve to the current scope name from funcName.
-   */
-  private collectInitialMemberNames(
-    funcName: string,
-    primary: Parser.PrimaryExpressionContext,
-  ): string[] {
-    const memberNames: string[] = [];
-    const primaryId = primary.IDENTIFIER()?.getText();
-
-    if (primaryId && primaryId !== "global") {
-      memberNames.push(primaryId);
-    } else if (primary.THIS()) {
-      const scopeName = funcName.split("_")[0];
-      if (scopeName && scopeName !== funcName) {
-        memberNames.push(scopeName);
-      }
-    }
-    return memberNames;
-  }
-
-  /**
-   * Record function calls to the call graph from an argument list.
-   * Also recurses into argument expressions.
-   */
-  private recordCallsFromArgList(
-    funcName: string,
-    paramSet: Set<string>,
-    calleeName: string,
-    op: Parser.PostfixOpContext,
-  ): void {
-    const argList = op.argumentList();
-    if (!argList) return;
-
-    const args = argList.expression();
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      const argName = ExpressionUtils.extractIdentifier(arg);
-      if (argName && paramSet.has(argName)) {
-        CodeGenState.functionCallGraph.get(funcName)!.push({
-          callee: calleeName,
-          paramIndex: i,
-          argParamName: argName,
-        });
-      }
-      this.walkExpressionForCalls(funcName, paramSet, arg);
-    }
-  }
-
-  /**
-   * Walk postfix ops recursively for nested calls and array subscripts.
-   */
-  private walkPostfixOpsRecursively(
-    funcName: string,
-    paramSet: Set<string>,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    for (const op of postfixOps) {
-      if (op.argumentList()) {
-        for (const argExpr of op.argumentList()!.expression()) {
-          this.walkExpressionForCalls(funcName, paramSet, argExpr);
-        }
-      }
-      for (const expr of op.expression()) {
-        this.walkExpressionForCalls(funcName, paramSet, expr);
-      }
-    }
-  }
-
-  /**
-   * Phase 3: Determine which parameters can pass by value.
-   * A parameter passes by value if:
-   * 1. It's a small primitive type (u8, i8, u16, i16, u32, i32, u64, i64, bool)
-   * 2. It's not modified (directly or transitively)
-   * 3. It's not an array, struct, string, or callback
-   */
-  private computePassByValueParams(): void {
-    const smallPrimitives = new Set([
-      "u8",
-      "i8",
-      "u16",
-      "i16",
-      "u32",
-      "i32",
-      "u64",
-      "i64",
-      "bool",
-    ]);
-
-    for (const [funcName, paramNames] of CodeGenState.functionParamLists) {
-      const passByValue = new Set<string>();
-      const modified =
-        CodeGenState.modifiedParameters.get(funcName) ?? new Set();
-
-      // Get function declaration to check parameter types
-      const funcSig = CodeGenState.functionSignatures.get(funcName);
-      if (funcSig) {
-        for (let i = 0; i < paramNames.length; i++) {
-          const paramName = paramNames[i];
-          const paramSig = funcSig.parameters[i];
-
-          if (!paramSig) continue;
-
-          // Check if eligible for pass-by-value:
-          // - Is a small primitive type
-          // - Not an array
-          // - Not modified
-          // - Not accessed via subscript (Issue #579)
-          const isSmallPrimitive = smallPrimitives.has(paramSig.baseType);
-          const isArray = paramSig.isArray ?? false;
-          const isModified = modified.has(paramName);
-          // Issue #579: Parameters with subscript access must become pointers
-          const hasSubscriptAccess =
-            CodeGenState.subscriptAccessedParameters
-              .get(funcName)
-              ?.has(paramName) ?? false;
-
-          if (
-            isSmallPrimitive &&
-            !isArray &&
-            !isModified &&
-            !hasSubscriptAccess
-          ) {
-            passByValue.add(paramName);
-          }
-        }
-      }
-
-      CodeGenState.passByValueParams.set(funcName, passByValue);
-    }
-  }
-
-  /**
-   * Check if a parameter should be passed by value (by name).
-   * Used internally during code generation.
-   */
-  private _isParameterPassByValueByName(
-    funcName: string,
-    paramName: string,
-  ): boolean {
-    const passByValue = CodeGenState.passByValueParams.get(funcName);
-    return passByValue?.has(paramName) ?? false;
-  }
+  // Issue #269: Pass-by-value analysis extracted to PassByValueAnalyzer
 
   /**
    * Issue #269: Check if a parameter should be passed by value (by index).
    * Part of IOrchestrator interface - used by CallExprGenerator.
+   * Delegates to PassByValueAnalyzer.
    */
   isParameterPassByValue(funcName: string, paramIndex: number): boolean {
-    const paramList = CodeGenState.functionParamLists.get(funcName);
-    if (!paramList || paramIndex < 0 || paramIndex >= paramList.length) {
-      return false;
-    }
-    const paramName = paramList[paramIndex];
-    return this._isParameterPassByValueByName(funcName, paramName);
+    return PassByValueAnalyzer.isParameterPassByValue(funcName, paramIndex);
   }
 
   /**
@@ -3319,7 +2686,6 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-017: Check if this is an enum type
     if (
       TypeRegistrationUtils.tryRegisterEnumType(
-        CodeGenState.typeRegistry,
         CodeGenState.symbols!,
         registrationOptions,
       )
@@ -3331,7 +2697,6 @@ export default class CodeGenerator implements IOrchestrator {
     const bitmapDimensions = this._evaluateArrayDimensions(arrayDim);
     if (
       TypeRegistrationUtils.tryRegisterBitmapType(
-        CodeGenState.typeRegistry,
         CodeGenState.symbols!,
         registrationOptions,
         bitmapDimensions,
@@ -3398,7 +2763,7 @@ export default class CodeGenerator implements IOrchestrator {
     const allDims =
       additionalDims.length > 0 ? [...additionalDims, stringDim] : [stringDim];
 
-    CodeGenState.typeRegistry.set(registryName, {
+    CodeGenState.setVariableTypeInfo(registryName, {
       baseType: "char",
       bitWidth: 8,
       isArray: true,
@@ -3564,14 +2929,14 @@ export default class CodeGenerator implements IOrchestrator {
         )
       ) {
         // Enum/bitmap was registered, but we need to update with arrayType dimension
-        const existingInfo = CodeGenState.typeRegistry.get(registryName);
+        const existingInfo = CodeGenState.getVariableTypeInfo(registryName);
         if (existingInfo) {
           const arrayTypeDim =
             this._parseArrayTypeDimensionFromCtx(arrayTypeCtx);
           const allDims = arrayTypeDim
             ? [arrayTypeDim, ...(existingInfo.arrayDimensions ?? [])]
             : existingInfo.arrayDimensions;
-          CodeGenState.typeRegistry.set(registryName, {
+          CodeGenState.setVariableTypeInfo(registryName, {
             ...existingInfo,
             isArray: true,
             arrayDimensions: allDims,
@@ -3593,7 +2958,7 @@ export default class CodeGenerator implements IOrchestrator {
       arrayDim,
     );
 
-    CodeGenState.typeRegistry.set(registryName, {
+    CodeGenState.setVariableTypeInfo(registryName, {
       baseType,
       bitWidth,
       isArray: true,
@@ -3672,7 +3037,7 @@ export default class CodeGenerator implements IOrchestrator {
       ? this._evaluateArrayDimensions(arrayDim)
       : undefined;
 
-    CodeGenState.typeRegistry.set(registryName, {
+    CodeGenState.setVariableTypeInfo(registryName, {
       baseType,
       bitWidth,
       isArray,
@@ -3925,7 +3290,7 @@ export default class CodeGenerator implements IOrchestrator {
       stringCapacity,
       isParameter: true,
     };
-    CodeGenState.typeRegistry.set(name, registeredType);
+    CodeGenState.setVariableTypeInfo(name, registeredType);
   }
 
   /**
@@ -3962,13 +3327,10 @@ export default class CodeGenerator implements IOrchestrator {
   private _clearParameters(): void {
     // ADR-025: Remove parameter types from typeRegistry
     for (const name of CodeGenState.currentParameters.keys()) {
-      CodeGenState.typeRegistry.delete(name);
-      CodeGenState.typeRegistry.delete(name);
+      CodeGenState.deleteVariableTypeInfo(name);
     }
     CodeGenState.currentParameters.clear();
     CodeGenState.localArrays.clear();
-    CodeGenState.currentParameters.clear();
-    CodeGenState.localArrays.clear();
   }
 
   /**
@@ -4183,7 +3545,7 @@ export default class CodeGenerator implements IOrchestrator {
     const sourceName = sourceId.getText();
 
     // Check if source is a string type
-    const typeInfo = CodeGenState.typeRegistry.get(sourceName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(sourceName);
     if (!typeInfo?.isString || typeInfo.stringCapacity === undefined) {
       return null;
     }
@@ -4370,7 +3732,7 @@ export default class CodeGenerator implements IOrchestrator {
     baseId: string,
     targetParamBaseType: string,
   ): boolean {
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
     return CppMemberHelper.needsComplexMemberConversion(
       this._toPostfixOps(ops),
       typeInfo,
@@ -4397,7 +3759,7 @@ export default class CodeGenerator implements IOrchestrator {
     const baseId = primary.IDENTIFIER()?.getText();
     if (!baseId) return false;
 
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
     const paramInfo = CodeGenState.currentParameters.get(baseId);
 
     return CppMemberHelper.isStringSubscriptPattern(
@@ -4451,7 +3813,7 @@ export default class CodeGenerator implements IOrchestrator {
     // 2. Parameter: currentParameters.get(baseId).baseType
     let structType: string | undefined;
 
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
     if (typeInfo) {
       structType = typeInfo.baseType;
     } else {
@@ -4518,14 +3880,14 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Global arrays also decay to pointers (check typeRegistry)
     // But NOT strings - strings need & (they're char arrays but passed by reference)
-    const typeInfo = CodeGenState.typeRegistry.get(id);
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
     if (typeInfo?.isArray && !typeInfo.isString) {
       return id;
     }
 
     // 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);
@@ -5388,7 +4750,10 @@ export default class CodeGenerator implements IOrchestrator {
     // Small unmodified primitives
     if (
       CodeGenState.currentFunctionName &&
-      this._isParameterPassByValueByName(CodeGenState.currentFunctionName, name)
+      PassByValueAnalyzer.isParameterPassByValueByName(
+        CodeGenState.currentFunctionName,
+        name,
+      )
     ) {
       return true;
     }
@@ -5847,14 +5212,14 @@ export default class CodeGenerator implements IOrchestrator {
       const argName = argNode.getText();
 
       // Check if it exists in type registry
-      const typeInfo = CodeGenState.typeRegistry.get(argName);
+      const typeInfo = CodeGenState.getVariableTypeInfo(argName);
 
       // Also check scoped variables if inside a scope
       let scopedArgName = argName;
       let scopedTypeInfo = typeInfo;
       if (!typeInfo && CodeGenState.currentScope) {
         scopedArgName = `${CodeGenState.currentScope}_${argName}`;
-        scopedTypeInfo = CodeGenState.typeRegistry.get(scopedArgName);
+        scopedTypeInfo = CodeGenState.getVariableTypeInfo(scopedArgName);
       }
 
       if (!typeInfo && !scopedTypeInfo) {
@@ -5878,7 +5243,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Track the variable in type registry (as an external C++ type)
-    CodeGenState.typeRegistry.set(name, {
+    CodeGenState.setVariableTypeInfo(name, {
       baseType: type,
       bitWidth: 0, // Unknown for C++ types
       isArray: false,
@@ -6118,8 +5483,12 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-109: Dispatch to assignment handlers
     // Build context, classify, and dispatch - all patterns handled by handlers
     const assignCtx = buildAssignmentContext(ctx, {
-      typeRegistry: CodeGenState.typeRegistry,
+      typeRegistry: CodeGenState.getTypeRegistryView(),
       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 +5977,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)
    */