c-next 0.1.28 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "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,
@@ -6287,6 +6289,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 +6319,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++;
 
@@ -9320,6 +9329,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 +9369,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/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 };