c-next 0.1.28 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -51,6 +51,8 @@ import includeGenerators from "./generators/support/IncludeGenerator";
 import commentUtils from "./generators/support/CommentUtils";
 // ADR-046: NullCheckAnalyzer for nullable C pointer type detection
 import NullCheckAnalyzer from "../analysis/NullCheckAnalyzer";
+// ADR-006: Helper for building member access chains with proper separators
+import memberAccessChain from "./memberAccessChain";
 
 const {
   generateOverflowHelpers: helperGenerateOverflowHelpers,
@@ -317,6 +319,13 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private functionParamLists: Map<string, string[]> = new Map();
 
+  /**
+   * Issue #369: Tracks whether self-include was added.
+   * When true, skip struct/enum/bitmap definitions in .c file because
+   * they'll be defined in the included header.
+   */
+  private selfIncludeAdded: boolean = false;
+
   /**
    * Initialize generator registry with extracted generators.
    * Called once before code generation begins.
@@ -378,6 +387,7 @@ export default class CodeGenerator implements IOrchestrator {
       localVariables: this.context.localVariables,
       localArrays: this.context.localArrays,
       expectedType: this.context.expectedType,
+      selfIncludeAdded: this.selfIncludeAdded, // Issue #369
     };
   }
 
@@ -1381,6 +1391,7 @@ export default class CodeGenerator implements IOrchestrator {
     this.needsString = false; // ADR-045: Reset string header tracking
     this.needsISR = false; // ADR-040: Reset ISR typedef tracking
     this.needsCMSIS = false; // ADR-049/050: Reset CMSIS include tracking
+    this.selfIncludeAdded = false; // Issue #369: Reset self-include tracking
 
     // First pass: collect namespace and class members
     // Issue #60: Create SymbolCollector (extracted from CodeGenerator)
@@ -1441,6 +1452,7 @@ export default class CodeGenerator implements IOrchestrator {
     // When file has public symbols and headers are being generated,
     // include own header to ensure proper C linkage
     // Issue #339: Use relative path from source root when available
+    // Issue #369: Track self-include to skip type definitions in .c file
     if (
       options?.generateHeaders &&
       this.symbols!.hasPublicSymbols() &&
@@ -1453,6 +1465,8 @@ export default class CodeGenerator implements IOrchestrator {
       const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
       output.push(`#include "${headerName}"`);
       output.push("");
+      // Issue #369: Mark that self-include was added - types will be in header
+      this.selfIncludeAdded = true;
     }
 
     // Pass through #include directives from source
@@ -2134,16 +2148,62 @@ export default class CodeGenerator implements IOrchestrator {
       }
     }
 
-    // Check for scope-qualified calls: Scope.func(...)
-    // primaryExpression could be 'global' or 'this' with member access
-    // For now, handle the simple case where we see IDENTIFIER.IDENTIFIER(...)
+    // Issue #365: Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
+    // Track member accesses to build the mangled callee name (e.g., Storage_load)
+    // Then when we find the function call, record it to the call graph
+    if (postfixOps.length > 0) {
+      const memberNames: string[] = [];
+
+      // Start with primary identifier if it's a scope name (not 'global' or 'this')
+      const primaryId = primary.IDENTIFIER()?.getText();
+      if (primaryId && primaryId !== "global" && primaryId !== "this") {
+        memberNames.push(primaryId);
+      }
+
+      // Collect member access names until we hit a function call
+      for (const op of postfixOps) {
+        if (op.IDENTIFIER()) {
+          // Member access: .IDENTIFIER
+          memberNames.push(op.IDENTIFIER()!.getText());
+        } else if (op.LPAREN()) {
+          // Function call found - record to call graph if we have a callee name
+          if (memberNames.length >= 1) {
+            // Build mangled name: e.g., ["Storage", "load"] -> "Storage_load"
+            // For scope methods, the last name is the method, everything before is scope
+            const calleeName = memberNames.join("_");
+            const argList = op.argumentList();
+
+            if (argList) {
+              const args = argList.expression();
+              for (let j = 0; j < args.length; j++) {
+                const arg = args[j];
+                const argName = this.getSimpleIdentifierFromExpr(arg);
+                if (argName && paramSet.has(argName)) {
+                  this.functionCallGraph.get(funcName)!.push({
+                    callee: calleeName,
+                    paramIndex: j,
+                    argParamName: argName,
+                  });
+                }
+              }
+            }
+          }
+          // Reset for potential chained calls like obj.foo().bar()
+          memberNames.length = 0;
+        } else if (op.expression().length > 0) {
+          // Array subscript - doesn't contribute to method name
+          // but reset member chain as array access breaks scope chain
+          memberNames.length = 0;
+        }
+      }
+    }
 
     // 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
+    // Walk arguments in any postfix function call ops (for nested calls)
     for (const op of postfixOps) {
       if (op.argumentList()) {
         for (const argExpr of op.argumentList()!.expression()) {
@@ -4370,15 +4430,26 @@ export default class CodeGenerator implements IOrchestrator {
     if (ctx.registerDeclaration()) {
       return this.generateRegister(ctx.registerDeclaration()!);
     }
+    // Issue #369: Skip struct/enum/bitmap definitions when self-include is added
+    // These types will be defined in the included header file
     if (ctx.structDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateStruct(ctx.structDeclaration()!);
     }
     // ADR-017: Handle enum declarations
     if (ctx.enumDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateEnum(ctx.enumDeclaration()!);
     }
     // ADR-034: Handle bitmap declarations
     if (ctx.bitmapDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateBitmap(ctx.bitmapDeclaration()!);
     }
     if (ctx.functionDeclaration()) {
@@ -6287,6 +6358,10 @@ export default class CodeGenerator implements IOrchestrator {
           // Check if first identifier is a scope for special handling
           const isCrossScope = this.isKnownScope(firstId);
 
+          // ADR-006: Check if first identifier is a struct parameter (needs -> access)
+          const paramInfo = this.context.currentParameters.get(firstId);
+          const isStructParam = paramInfo?.isStruct ?? false;
+
           // Bug #8: Track struct types to detect bit access through chains
           // e.g., items[0].byte[7] where byte is u8 - final [7] is bit access
           let currentStructType: string | undefined;
@@ -6313,8 +6388,11 @@ export default class CodeGenerator implements IOrchestrator {
                 idIndex < identifiers.length
               ) {
                 const memberName = identifiers[idIndex].getText();
-                // Use underscore for first join if cross-scope, dot otherwise
-                const separator = isCrossScope && idIndex === 1 ? "_" : ".";
+                // ADR-006: Use determineSeparator helper for -> (struct param) / _ (scope) / .
+                const separator = memberAccessChain.determineSeparator(
+                  { isStructParam, isCrossScope },
+                  idIndex,
+                );
                 result += `${separator}${memberName}`;
                 idIndex++;
 
@@ -6850,14 +6928,22 @@ export default class CodeGenerator implements IOrchestrator {
       const exprs = arrayAccessCtx.expression();
       const typeInfo = this.context.typeRegistry.get(name);
 
+      // Issue #368: Check if this is an array parameter (e.g., void foo(u8 data[]))
+      // Array parameters may not have arrayDimensions in typeRegistry (for unsized params),
+      // but they ARE arrays and should use array indexing, not bit manipulation.
+      const paramInfo = this.context.currentParameters.get(name);
+      const isArrayParameter = paramInfo?.isArray ?? false;
+
       // ADR-040: ISR arrays use normal array indexing, not bit manipulation
       // Also handle any array type that isn't an integer scalar
       // Issue #213: String parameters (isString=true) should also use memcpy for slice assignment
+      // Issue #368: Array parameters (even unsized like u8 data[]) should use array indexing
       const isActualArray =
         (typeInfo?.isArray &&
           typeInfo.arrayDimensions &&
           typeInfo.arrayDimensions.length > 0) ||
-        typeInfo?.isString;
+        typeInfo?.isString ||
+        isArrayParameter;
       const isISRType = typeInfo?.baseType === "ISR";
 
       if (isActualArray || isISRType) {
@@ -9320,6 +9406,10 @@ export default class CodeGenerator implements IOrchestrator {
           // Check if first identifier is a scope for special handling
           const isCrossScope = this.isKnownScope(firstPart);
 
+          // ADR-006: Check if first identifier is a struct parameter (needs -> access)
+          const paramInfo = this.context.currentParameters.get(firstPart);
+          const isStructParam = paramInfo?.isStruct ?? false;
+
           // ADR-016: Inside a scope, accessing another scope requires global. prefix
           if (isCrossScope && this.context.currentScope) {
             // Self-referential access should use 'this.'
@@ -9356,8 +9446,11 @@ export default class CodeGenerator implements IOrchestrator {
               i++;
               if (i < ctx.children.length && idIndex < parts.length) {
                 const memberName = parts[idIndex];
-                // Use underscore for first join if cross-scope, dot otherwise
-                const separator = isCrossScope && idIndex === 1 ? "_" : ".";
+                // ADR-006: Use determineSeparator helper for -> (struct param) / _ (scope) / .
+                const separator = memberAccessChain.determineSeparator(
+                  { isStructParam, isCrossScope },
+                  idIndex,
+                );
                 result += `${separator}${memberName}`;
                 idIndex++;
 

package/src/codegen/TypeValidator.ts

@@ -866,16 +866,8 @@ class TypeValidator {
                   for (const add of shift.additiveExpression()) {
                     for (const mult of add.multiplicativeExpression()) {
                       for (const unary of mult.unaryExpression()) {
-                        const postfix = unary.postfixExpression();
-                        if (postfix) {
-                          for (const op of postfix.postfixOp()) {
-                            if (
-                              op.argumentList() ||
-                              op.getText().startsWith("(")
-                            ) {
-                              return true;
-                            }
-                          }
+                        if (this.hasPostfixFunctionCallInUnary(unary)) {
+                          return true;
                         }
                       }
                     }
@@ -890,6 +882,32 @@ class TypeValidator {
     return false;
   }
 
+  /**
+   * Issue #366: Recursively check unaryExpression for function calls.
+   * Handles unary operators (!, -, ~, &) that wrap function calls,
+   * including arbitrary nesting like !!isReady() or -~getValue().
+   */
+  private hasPostfixFunctionCallInUnary(
+    unary: Parser.UnaryExpressionContext,
+  ): boolean {
+    // Recurse through nested unary operators (!, -, ~, &) until we reach postfixExpression
+    const nestedUnary = unary.unaryExpression();
+    if (nestedUnary) {
+      return this.hasPostfixFunctionCallInUnary(nestedUnary);
+    }
+
+    // Base case: check postfixExpression
+    const postfix = unary.postfixExpression();
+    if (postfix) {
+      for (const op of postfix.postfixOp()) {
+        if (op.argumentList() || op.getText().startsWith("(")) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   // ========================================================================
   // Shift Amount Validation (MISRA C:2012 Rule 12.2)
   // ========================================================================

package/src/codegen/generators/IGeneratorState.ts

@@ -26,6 +26,13 @@ interface IGeneratorState {
 
   /** Expected type for inferred struct initializers */
   readonly expectedType: string | null;
+
+  /**
+   * Issue #369: Whether self-include was added.
+   * When true, type definitions (struct/enum/bitmap) should not be emitted
+   * in the .c file as they'll come from the included header.
+   */
+  readonly selfIncludeAdded: boolean;
 }
 
 export default IGeneratorState;

package/src/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -142,14 +142,16 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
 
     // ADR-017: Handle enum declarations inside scopes
     // The enum generator will use state.currentScope which we've set via orchestrator
-    if (member.enumDeclaration()) {
+    // Issue #369: Skip enum definition if self-include was added (it will be in the header)
+    if (member.enumDeclaration() && !state.selfIncludeAdded) {
       const enumDecl = member.enumDeclaration()!;
       lines.push("");
       lines.push(generateScopedEnumInline(enumDecl, name, input, orchestrator));
     }
 
     // ADR-034: Handle bitmap declarations inside scopes
-    if (member.bitmapDeclaration()) {
+    // Issue #369: Skip bitmap definition if self-include was added (it will be in the header)
+    if (member.bitmapDeclaration() && !state.selfIncludeAdded) {
       const bitmapDecl = member.bitmapDeclaration()!;
       lines.push("");
       lines.push(generateScopedBitmapInline(bitmapDecl, name, input));

package/src/codegen/memberAccessChain.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Tests for memberAccessChain helper module.
+ *
+ * This module tests the shared logic for building member access chains
+ * with proper separators (-> for struct params, _ for cross-scope, . otherwise).
+ */
+
+import { vi } from "vitest";
+import { ParseTree } from "antlr4ng";
+import memberAccessChain from "./memberAccessChain";
+
+const { determineSeparator, buildMemberAccessChain } = memberAccessChain;
+
+// Local type definition for separator options (mirrors internal type)
+interface SeparatorOptions {
+  isStructParam: boolean;
+  isCrossScope: boolean;
+}
+
+describe("determineSeparator", () => {
+  describe("struct parameter access", () => {
+    it("should return -> for struct param at idIndex 1", () => {
+      const options: SeparatorOptions = {
+        isStructParam: true,
+        isCrossScope: false,
+      };
+      expect(determineSeparator(options, 1)).toBe("->");
+    });
+
+    it("should return . for struct param at idIndex > 1", () => {
+      const options: SeparatorOptions = {
+        isStructParam: true,
+        isCrossScope: false,
+      };
+      expect(determineSeparator(options, 2)).toBe(".");
+      expect(determineSeparator(options, 3)).toBe(".");
+    });
+  });
+
+  describe("cross-scope access", () => {
+    it("should return _ for cross-scope at idIndex 1", () => {
+      const options: SeparatorOptions = {
+        isStructParam: false,
+        isCrossScope: true,
+      };
+      expect(determineSeparator(options, 1)).toBe("_");
+    });
+
+    it("should return . for cross-scope at idIndex > 1", () => {
+      const options: SeparatorOptions = {
+        isStructParam: false,
+        isCrossScope: true,
+      };
+      expect(determineSeparator(options, 2)).toBe(".");
+      expect(determineSeparator(options, 3)).toBe(".");
+    });
+  });
+
+  describe("struct param takes precedence over cross-scope", () => {
+    it("should return -> when both struct param and cross-scope at idIndex 1", () => {
+      const options: SeparatorOptions = {
+        isStructParam: true,
+        isCrossScope: true,
+      };
+      expect(determineSeparator(options, 1)).toBe("->");
+    });
+  });
+
+  describe("regular access", () => {
+    it("should return . when neither struct param nor cross-scope", () => {
+      const options: SeparatorOptions = {
+        isStructParam: false,
+        isCrossScope: false,
+      };
+      expect(determineSeparator(options, 1)).toBe(".");
+      expect(determineSeparator(options, 2)).toBe(".");
+    });
+  });
+});
+
+// Mock ParseTree for testing - only getText() is used by buildMemberAccessChain
+function createMockChildren(tokens: string[]): ParseTree[] {
+  return tokens.map(
+    (text) => ({ getText: () => text }) as unknown as ParseTree,
+  );
+}
+
+describe("buildMemberAccessChain", () => {
+  // Simple expression generator that just returns the expression as-is
+  const simpleExprGen = (expr: string) => expr;
+
+  describe("simple member access (no subscripts)", () => {
+    it("should build chain with regular separator", () => {
+      // cfg.tempInputs.assignedSpn
+      const options = {
+        firstId: "cfg",
+        identifiers: ["cfg", "tempInputs", "assignedSpn"],
+        expressions: [],
+        children: createMockChildren([
+          "cfg",
+          ".",
+          "tempInputs",
+          ".",
+          "assignedSpn",
+        ]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("cfg.tempInputs.assignedSpn");
+      expect(result.identifiersConsumed).toBe(3);
+      expect(result.expressionsConsumed).toBe(0);
+    });
+
+    it("should build chain with -> for struct parameter", () => {
+      // conf->tempInputs.assignedSpn (conf is a struct param)
+      const options = {
+        firstId: "conf",
+        identifiers: ["conf", "tempInputs", "assignedSpn"],
+        expressions: [],
+        children: createMockChildren([
+          "conf",
+          ".",
+          "tempInputs",
+          ".",
+          "assignedSpn",
+        ]),
+        separatorOptions: { isStructParam: true, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("conf->tempInputs.assignedSpn");
+      expect(result.identifiersConsumed).toBe(3);
+    });
+
+    it("should build chain with _ for cross-scope", () => {
+      // Timing_tickCount (cross-scope access)
+      const options = {
+        firstId: "Timing",
+        identifiers: ["Timing", "tickCount"],
+        expressions: [],
+        children: createMockChildren(["Timing", ".", "tickCount"]),
+        separatorOptions: { isStructParam: false, isCrossScope: true },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("Timing_tickCount");
+      expect(result.identifiersConsumed).toBe(2);
+    });
+  });
+
+  describe("member access with subscripts", () => {
+    it("should build chain with subscript at end", () => {
+      // cfg.tempInputs[idx]
+      const options = {
+        firstId: "cfg",
+        identifiers: ["cfg", "tempInputs"],
+        expressions: ["idx"],
+        children: createMockChildren([
+          "cfg",
+          ".",
+          "tempInputs",
+          "[",
+          "idx",
+          "]",
+        ]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("cfg.tempInputs[idx]");
+      expect(result.identifiersConsumed).toBe(2);
+      expect(result.expressionsConsumed).toBe(1);
+    });
+
+    it("should build chain with subscript then member (the issue #69 pattern)", () => {
+      // conf->tempInputs[idx].assignedSpn (struct param with subscript then member)
+      const options = {
+        firstId: "conf",
+        identifiers: ["conf", "tempInputs", "assignedSpn"],
+        expressions: ["idx"],
+        children: createMockChildren([
+          "conf",
+          ".",
+          "tempInputs",
+          "[",
+          "idx",
+          "]",
+          ".",
+          "assignedSpn",
+        ]),
+        separatorOptions: { isStructParam: true, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("conf->tempInputs[idx].assignedSpn");
+      expect(result.identifiersConsumed).toBe(3);
+      expect(result.expressionsConsumed).toBe(1);
+    });
+
+    it("should handle multiple subscripts", () => {
+      // matrix[i][j]
+      const options = {
+        firstId: "matrix",
+        identifiers: ["matrix"],
+        expressions: ["i", "j"],
+        children: createMockChildren(["matrix", "[", "i", "]", "[", "j", "]"]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("matrix[i][j]");
+      expect(result.expressionsConsumed).toBe(2);
+    });
+
+    it("should handle mixed subscripts and members", () => {
+      // data->items[0].value[1].flag
+      const options = {
+        firstId: "data",
+        identifiers: ["data", "items", "value", "flag"],
+        expressions: ["0", "1"],
+        children: createMockChildren([
+          "data",
+          ".",
+          "items",
+          "[",
+          "0",
+          "]",
+          ".",
+          "value",
+          "[",
+          "1",
+          "]",
+          ".",
+          "flag",
+        ]),
+        separatorOptions: { isStructParam: true, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("data->items[0].value[1].flag");
+      expect(result.identifiersConsumed).toBe(4);
+      expect(result.expressionsConsumed).toBe(2);
+    });
+  });
+
+  describe("type tracking and bit access", () => {
+    it("should call onBitAccess when accessing primitive integer field with subscript", () => {
+      // items[0].byte[7] -> bit access on u8 field
+      const mockTypeTracking = {
+        getStructFields: vi.fn().mockReturnValue(new Map([["byte", "u8"]])),
+        getStructArrayFields: vi.fn().mockReturnValue(new Set()),
+        isKnownStruct: vi.fn().mockImplementation((type) => type === "Item"),
+      };
+
+      const onBitAccess = vi.fn().mockReturnValue("((items[0].byte >> 7) & 1)");
+
+      const options = {
+        firstId: "items",
+        identifiers: ["items", "byte"],
+        expressions: ["0", "7"],
+        children: createMockChildren([
+          "items",
+          "[",
+          "0",
+          "]",
+          ".",
+          "byte",
+          "[",
+          "7",
+          "]",
+        ]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+        initialTypeInfo: { isArray: true, baseType: "Item" },
+        typeTracking: mockTypeTracking,
+        onBitAccess,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(onBitAccess).toHaveBeenCalledWith("items[0].byte", "7", "u8");
+      expect(result.code).toBe("((items[0].byte >> 7) & 1)");
+    });
+
+    it("should not trigger bit access for array fields", () => {
+      // items[0].indices[12] -> normal array access, not bit access
+      const mockTypeTracking = {
+        getStructFields: vi.fn().mockReturnValue(new Map([["indices", "u8"]])),
+        getStructArrayFields: vi.fn().mockReturnValue(new Set(["indices"])), // indices IS an array
+        isKnownStruct: vi.fn().mockImplementation((type) => type === "Item"),
+      };
+
+      const onBitAccess = vi.fn();
+
+      const options = {
+        firstId: "items",
+        identifiers: ["items", "indices"],
+        expressions: ["0", "12"],
+        children: createMockChildren([
+          "items",
+          "[",
+          "0",
+          "]",
+          ".",
+          "indices",
+          "[",
+          "12",
+          "]",
+        ]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+        initialTypeInfo: { isArray: true, baseType: "Item" },
+        typeTracking: mockTypeTracking,
+        onBitAccess,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(onBitAccess).not.toHaveBeenCalled();
+      expect(result.code).toBe("items[0].indices[12]");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle single identifier with subscript", () => {
+      // arr[0]
+      const options = {
+        firstId: "arr",
+        identifiers: ["arr"],
+        expressions: ["0"],
+        children: createMockChildren(["arr", "[", "0", "]"]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: simpleExprGen,
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("arr[0]");
+    });
+
+    it("should handle complex expression in subscript", () => {
+      // cfg.items[i + 1]
+      const options = {
+        firstId: "cfg",
+        identifiers: ["cfg", "items"],
+        expressions: ["expr_placeholder"],
+        children: createMockChildren(["cfg", ".", "items", "[", "i + 1", "]"]),
+        separatorOptions: { isStructParam: false, isCrossScope: false },
+        generateExpression: () => "i + 1", // Mock that generates "i + 1"
+      };
+
+      const result = buildMemberAccessChain(options);
+      expect(result.code).toBe("cfg.items[i + 1]");
+    });
+  });
+});

package/src/codegen/memberAccessChain.ts

@@ -0,0 +1,280 @@
+/**
+ * Helper module for building member access chains with proper separators.
+ *
+ * This module extracts the shared logic for building member access chains
+ * like `conf->tempInputs[idx].assignedSpn` from both read and write contexts.
+ *
+ * ADR-006: Struct parameters need -> access (passed by pointer in C)
+ * ADR-016: Cross-scope access uses _ separator
+ */
+
+import { ParseTree } from "antlr4ng";
+
+/**
+ * Options for determining the separator between the first identifier and
+ * the first member in a member access chain.
+ */
+interface SeparatorOptions {
+  /** Whether the first identifier is a struct parameter (needs -> in C) */
+  isStructParam: boolean;
+  /** Whether the first identifier is a cross-scope access (needs _ in C) */
+  isCrossScope: boolean;
+}
+
+/**
+ * Determines the separator to use between the first identifier and the first member.
+ *
+ * @param options - The separator options
+ * @param idIndex - The current identifier index (1 = first member after base)
+ * @returns The separator string: "->" for struct params, "_" for cross-scope, "." otherwise
+ */
+function determineSeparator(
+  options: SeparatorOptions,
+  idIndex: number,
+): string {
+  // Only the first separator (idIndex === 1) can be special
+  if (idIndex !== 1) {
+    return ".";
+  }
+
+  // ADR-006: Struct parameters are passed as pointers, need -> access
+  if (options.isStructParam) {
+    return "->";
+  }
+
+  // ADR-016: Cross-scope access uses underscore (scope_member)
+  if (options.isCrossScope) {
+    return "_";
+  }
+
+  return ".";
+}
+
+/**
+ * Result of building a member access chain.
+ */
+interface MemberAccessChainResult {
+  /** The generated C code for the member access chain */
+  code: string;
+  /** Number of identifiers consumed */
+  identifiersConsumed: number;
+  /** Number of expressions (subscripts) consumed */
+  expressionsConsumed: number;
+}
+
+/**
+ * Callback type for generating expression code from subscript expressions.
+ */
+type ExpressionGenerator<TExpr> = (expr: TExpr) => string;
+
+/**
+ * Callback type for checking if a type is a known struct.
+ */
+type StructChecker = (typeName: string) => boolean;
+
+/**
+ * Type tracking state while walking a member access chain.
+ */
+interface TypeTrackingState {
+  /** Current struct type being accessed (undefined if not in a struct) */
+  currentStructType: string | undefined;
+  /** Type of the last accessed member */
+  lastMemberType: string | undefined;
+  /** Whether the last accessed member is an array field */
+  lastMemberIsArray: boolean;
+}
+
+/**
+ * Callbacks for type tracking while building the chain.
+ */
+interface TypeTrackingCallbacks {
+  /** Get the fields map for a struct type */
+  getStructFields: (structType: string) => Map<string, string> | undefined;
+  /** Get the array fields set for a struct type */
+  getStructArrayFields: (structType: string) => Set<string> | undefined;
+  /** Check if a type name is a known struct */
+  isKnownStruct: StructChecker;
+}
+
+/**
+ * Options for building a member access chain.
+ */
+interface BuildChainOptions<TExpr> {
+  /** The first identifier (base of the chain) */
+  firstId: string;
+  /** All identifier names in the chain */
+  identifiers: string[];
+  /** Subscript expressions */
+  expressions: TExpr[];
+  /** Parse tree children for walking */
+  children: ParseTree[];
+  /** Separator options (struct param, cross-scope) */
+  separatorOptions: SeparatorOptions;
+  /** Function to generate code from an expression */
+  generateExpression: ExpressionGenerator<TExpr>;
+  /** Optional: Initial type info for type tracking */
+  initialTypeInfo?: {
+    isArray: boolean;
+    baseType: string;
+  };
+  /** Optional: Type tracking callbacks for bit access detection */
+  typeTracking?: TypeTrackingCallbacks;
+  /** Optional: Callback when bit access is detected on last subscript */
+  onBitAccess?: (
+    result: string,
+    bitIndex: string,
+    memberType: string,
+  ) => string | null;
+}
+
+/**
+ * Builds a member access chain with proper separators and subscripts.
+ *
+ * This function walks through the parse tree children in order, building
+ * the C code string incrementally. It handles:
+ * - Struct parameter access (-> separator)
+ * - Cross-scope access (_ separator)
+ * - Array subscripts
+ * - Optional type tracking for bit access detection
+ *
+ * @param options - The build options
+ * @returns The result containing the generated code and consumption counts
+ */
+function buildMemberAccessChain<TExpr>(
+  options: BuildChainOptions<TExpr>,
+): MemberAccessChainResult {
+  const {
+    firstId,
+    identifiers,
+    expressions,
+    children,
+    separatorOptions,
+    generateExpression,
+    initialTypeInfo,
+    typeTracking,
+    onBitAccess,
+  } = options;
+
+  let result = firstId;
+  let idIndex = 1; // Start at 1 since we already have firstId
+  let exprIndex = 0;
+
+  // Initialize type tracking state
+  let typeState: TypeTrackingState | undefined;
+  if (typeTracking && initialTypeInfo) {
+    typeState = {
+      currentStructType: typeTracking.isKnownStruct(initialTypeInfo.baseType)
+        ? initialTypeInfo.baseType
+        : undefined,
+      lastMemberType: undefined,
+      lastMemberIsArray: false,
+    };
+  }
+
+  let i = 1;
+  while (i < children.length) {
+    const childText = children[i].getText();
+
+    if (childText === ".") {
+      // Dot found - consume it, then get the next identifier
+      i++;
+      if (i < children.length && idIndex < identifiers.length) {
+        const memberName = identifiers[idIndex];
+        const separator = determineSeparator(separatorOptions, idIndex);
+        result += `${separator}${memberName}`;
+        idIndex++;
+
+        // Update type tracking for the member we just accessed
+        if (typeState && typeTracking && typeState.currentStructType) {
+          const fields = typeTracking.getStructFields(
+            typeState.currentStructType,
+          );
+          typeState.lastMemberType = fields?.get(memberName);
+
+          const arrayFields = typeTracking.getStructArrayFields(
+            typeState.currentStructType,
+          );
+          typeState.lastMemberIsArray = arrayFields?.has(memberName) ?? false;
+
+          // Check if this member is itself a struct
+          if (
+            typeState.lastMemberType &&
+            typeTracking.isKnownStruct(typeState.lastMemberType)
+          ) {
+            typeState.currentStructType = typeState.lastMemberType;
+          } else {
+            typeState.currentStructType = undefined;
+          }
+        }
+      }
+    } else if (childText === "[") {
+      // Opening bracket - handle subscript
+
+      // Check for bit access on primitive integer (if type tracking enabled)
+      if (typeState && onBitAccess) {
+        const isPrimitiveInt =
+          typeState.lastMemberType &&
+          !typeState.lastMemberIsArray &&
+          ["u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64"].includes(
+            typeState.lastMemberType,
+          );
+        const isLastExpr = exprIndex === expressions.length - 1;
+
+        if (isPrimitiveInt && isLastExpr && exprIndex < expressions.length) {
+          const bitIndex = generateExpression(expressions[exprIndex]);
+          const bitResult = onBitAccess(
+            result,
+            bitIndex,
+            typeState.lastMemberType!,
+          );
+          if (bitResult !== null) {
+            return {
+              code: bitResult,
+              identifiersConsumed: idIndex,
+              expressionsConsumed: exprIndex + 1,
+            };
+          }
+        }
+      }
+
+      // Normal array subscript
+      if (exprIndex < expressions.length) {
+        const expr = generateExpression(expressions[exprIndex]);
+        result += `[${expr}]`;
+        exprIndex++;
+
+        // After subscripting an array, update type tracking
+        if (
+          typeState &&
+          typeTracking &&
+          initialTypeInfo?.isArray &&
+          exprIndex === 1
+        ) {
+          // First subscript on array - element type might be a struct
+          if (typeTracking.isKnownStruct(initialTypeInfo.baseType)) {
+            typeState.currentStructType = initialTypeInfo.baseType;
+          }
+        }
+      }
+
+      // Skip forward to find and pass the closing bracket
+      while (i < children.length && children[i].getText() !== "]") {
+        i++;
+      }
+
+      // Reset lastMemberType after subscript (no longer on a member)
+      if (typeState) {
+        typeState.lastMemberType = undefined;
+      }
+    }
+    i++;
+  }
+
+  return {
+    code: result,
+    identifiersConsumed: idIndex,
+    expressionsConsumed: exprIndex,
+  };
+}
+
+export default { determineSeparator, buildMemberAccessChain };