c-next 0.1.61 → 0.1.63

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

@@ -158,6 +158,47 @@ function handleArrayElementBit(
   return `${arrayElement} = (${arrayElement} & ~(${one} << ${bitIndex})) | (${intValue} << ${bitIndex});`;
 }
 
+/**
+ * Handle bit range through struct chain: devices[0].control[0, 4] <- 15
+ *
+ * The target is a chain like array[idx].member or struct.field with a
+ * bit range subscript [start, width] at the end.
+ */
+function handleStructChainBitRange(
+  ctx: IAssignmentContext,
+  deps: IHandlerDeps,
+): string {
+  validateNotCompound(ctx);
+
+  // Build the base target from postfixOps, excluding the last one (the bit range)
+  const baseId = ctx.identifiers[0];
+  const opsBeforeLast = ctx.postfixOps.slice(0, -1);
+
+  let baseTarget = baseId;
+  for (const op of opsBeforeLast) {
+    const memberId = op.IDENTIFIER();
+    if (memberId) {
+      baseTarget += "." + memberId.getText();
+    } else {
+      const exprs = op.expression();
+      if (exprs.length > 0) {
+        baseTarget += "[" + deps.generateExpression(exprs[0]) + "]";
+      }
+    }
+  }
+
+  // Get start and width from the last postfixOp (the bit range)
+  const lastOp = ctx.postfixOps.at(-1)!;
+  const bitRangeExprs = lastOp.expression();
+  const start = deps.generateExpression(bitRangeExprs[0]);
+  const width = deps.generateExpression(bitRangeExprs[1]);
+
+  // Generate bit range write
+  // Limitation: assumes 32-bit types. For 64-bit struct members,
+  // would need to track member type through chain.
+  return BitUtils.multiBitWrite(baseTarget, start, width, ctx.generatedValue);
+}
+
 /**
  * All bit access handlers for registration.
  */
@@ -166,6 +207,7 @@ const bitAccessHandlers: ReadonlyArray<[AssignmentKind, TAssignmentHandler]> = [
   [AssignmentKind.INTEGER_BIT_RANGE, handleIntegerBitRange],
   [AssignmentKind.STRUCT_MEMBER_BIT, handleStructMemberBit],
   [AssignmentKind.ARRAY_ELEMENT_BIT, handleArrayElementBit],
+  [AssignmentKind.STRUCT_CHAIN_BIT_RANGE, handleStructChainBitRange],
 ];
 
 export default bitAccessHandlers;

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

@@ -88,10 +88,11 @@ describe("BitAccessHandlers", () => {
       expect(kinds).toContain(AssignmentKind.INTEGER_BIT_RANGE);
       expect(kinds).toContain(AssignmentKind.STRUCT_MEMBER_BIT);
       expect(kinds).toContain(AssignmentKind.ARRAY_ELEMENT_BIT);
+      expect(kinds).toContain(AssignmentKind.STRUCT_CHAIN_BIT_RANGE);
     });
 
-    it("exports exactly 4 handlers", () => {
-      expect(bitAccessHandlers.length).toBe(4);
+    it("exports exactly 5 handlers", () => {
+      expect(bitAccessHandlers.length).toBe(5);
     });
   });
 
@@ -470,4 +471,77 @@ describe("BitAccessHandlers", () => {
       );
     });
   });
+
+  describe("handleStructChainBitRange (STRUCT_CHAIN_BIT_RANGE)", () => {
+    const getHandler = () =>
+      bitAccessHandlers.find(
+        ([kind]) => kind === AssignmentKind.STRUCT_CHAIN_BIT_RANGE,
+      )?.[1];
+
+    it("generates bit range write through struct chain", () => {
+      const deps = createMockDeps({
+        generateExpression: vi
+          .fn()
+          .mockReturnValueOnce("0") // array index
+          .mockReturnValueOnce("0") // bit range start
+          .mockReturnValueOnce("4"), // bit range width
+      });
+
+      // Create mock postfixOps for devices[0].control[0, 4]
+      const mockPostfixOps = [
+        {
+          IDENTIFIER: () => null,
+          expression: () => [{ mockValue: "0" }],
+        },
+        {
+          IDENTIFIER: () => ({ getText: () => "control" }),
+          expression: () => [],
+        },
+        {
+          IDENTIFIER: () => null,
+          expression: () => [{ mockValue: "0" }, { mockValue: "4" }],
+        },
+      ];
+
+      const ctx = createMockContext({
+        identifiers: ["devices", "control"],
+        subscripts: [
+          { mockValue: "0" } as never,
+          { mockValue: "0" } as never,
+          { mockValue: "4" } as never,
+        ],
+        postfixOps: mockPostfixOps as never,
+        generatedValue: "15",
+        hasMemberAccess: true,
+        hasArrayAccess: true,
+        lastSubscriptExprCount: 2,
+      });
+
+      const result = getHandler()!(ctx, deps);
+
+      expect(result).toContain("devices[0].control =");
+      expect(result).toContain("& ~(");
+      expect(result).toContain("<< 0");
+      expect(result).toContain("15");
+    });
+
+    it("throws on compound assignment", () => {
+      const deps = createMockDeps();
+      const mockPostfixOps = [
+        {
+          IDENTIFIER: () => null,
+          expression: () => [{ mockValue: "0" }, { mockValue: "4" }],
+        },
+      ];
+      const ctx = createMockContext({
+        isCompound: true,
+        cnextOp: "+<-",
+        postfixOps: mockPostfixOps as never,
+      });
+
+      expect(() => getHandler()!(ctx, deps)).toThrow(
+        "Compound assignment operators not supported for bit field access",
+      );
+    });
+  });
 });

package/src/transpiler/output/codegen/generators/GeneratorRegistry.ts

@@ -102,6 +102,18 @@ export default class GeneratorRegistry {
     this.expressions.set(kind, fn as TGeneratorFn<ParserRuleContext>);
   }
 
+  // =========================================================================
+  // Deregistration Methods (for testing error paths)
+  // =========================================================================
+
+  /**
+   * Unregister a declaration generator.
+   * Primarily used for testing error paths when generators are missing.
+   */
+  unregisterDeclaration(kind: string): void {
+    this.declarations.delete(kind);
+  }
+
   // =========================================================================
   // Query Methods
   // =========================================================================

package/src/transpiler/output/codegen/generators/IOrchestrator.ts

@@ -120,7 +120,11 @@ interface IOrchestrator {
   // === Validation ===
 
   /** Validate cross-scope member visibility (ADR-016) */
-  validateCrossScopeVisibility(scopeName: string, memberName: string): void;
+  validateCrossScopeVisibility(
+    scopeName: string,
+    memberName: string,
+    isGlobalAccess?: boolean,
+  ): void;
 
   /** Validate shift amount is within type bounds */
   validateShiftAmount(

package/src/transpiler/output/codegen/generators/__tests__/GeneratorRegistry.test.ts

@@ -9,7 +9,7 @@ const mockGenerator: TGeneratorFn<ParserRuleContext> = () => ({
   effects: [],
 });
 
-export default describe("GeneratorRegistry", () => {
+describe("GeneratorRegistry", () => {
   let registry: GeneratorRegistry;
 
   beforeEach(() => {
@@ -48,4 +48,31 @@ export default describe("GeneratorRegistry", () => {
       expect(registry.hasExpression("ternary")).toBe(true);
     });
   });
+
+  describe("unregisterDeclaration", () => {
+    it("removes a registered declaration", () => {
+      registry.registerDeclaration("struct", mockGenerator);
+      expect(registry.hasDeclaration("struct")).toBe(true);
+
+      registry.unregisterDeclaration("struct");
+      expect(registry.hasDeclaration("struct")).toBe(false);
+    });
+
+    it("is a no-op for non-existent kind", () => {
+      expect(registry.hasDeclaration("unknown")).toBe(false);
+      registry.unregisterDeclaration("unknown");
+      expect(registry.hasDeclaration("unknown")).toBe(false);
+    });
+  });
+
+  describe("getDeclaration", () => {
+    it("returns undefined for unregistered kind", () => {
+      expect(registry.getDeclaration("struct")).toBeUndefined();
+    });
+
+    it("returns generator for registered kind", () => {
+      registry.registerDeclaration("struct", mockGenerator);
+      expect(registry.getDeclaration("struct")).toBe(mockGenerator);
+    });
+  });
 });

package/src/transpiler/output/codegen/generators/declarationGenerators/ArrayDimensionUtils.ts

@@ -0,0 +1,67 @@
+/**
+ * ArrayDimensionUtils - Shared utilities for generating array dimension strings.
+ *
+ * Used by StructGenerator and ScopeGenerator for consistent array dimension handling.
+ */
+
+import * as Parser from "../../../../logic/parser/grammar/CNextParser";
+import IOrchestrator from "../IOrchestrator";
+
+/**
+ * Generate array type dimension string from arrayType syntax (e.g., u8[16]).
+ * Evaluates constants when possible, falls back to expression generation.
+ *
+ * @param arrayTypeCtx - The arrayType context, or null if not present
+ * @param orchestrator - The orchestrator for constant evaluation and expression generation
+ * @returns Dimension string like "[16]", "[]", or "" if no arrayType
+ */
+function generateArrayTypeDimension(
+  arrayTypeCtx: Parser.ArrayTypeContext | null,
+  orchestrator: IOrchestrator,
+): string {
+  if (arrayTypeCtx === null) {
+    return "";
+  }
+
+  const sizeExpr = arrayTypeCtx.expression();
+  if (!sizeExpr) {
+    return "[]";
+  }
+
+  const constValue = orchestrator.tryEvaluateConstant(sizeExpr);
+  if (constValue === undefined) {
+    // Fall back to expression generation for macros, enums, etc.
+    return `[${orchestrator.generateExpression(sizeExpr)}]`;
+  }
+
+  return `[${constValue}]`;
+}
+
+/**
+ * Generate string capacity dimension if applicable.
+ * Adds +1 for null terminator.
+ *
+ * @param typeCtx - The type context to check for string type
+ * @returns Dimension string like "[33]" for string<32>, or "" if not a string
+ */
+function generateStringCapacityDim(typeCtx: Parser.TypeContext): string {
+  const stringCtx = typeCtx.stringType();
+  if (!stringCtx) {
+    return "";
+  }
+
+  const intLiteral = stringCtx.INTEGER_LITERAL();
+  if (!intLiteral) {
+    return "";
+  }
+
+  const capacity = Number.parseInt(intLiteral.getText(), 10);
+  return `[${capacity + 1}]`;
+}
+
+class ArrayDimensionUtils {
+  static readonly generateArrayTypeDimension = generateArrayTypeDimension;
+  static readonly generateStringCapacityDim = generateStringCapacityDim;
+}
+
+export default ArrayDimensionUtils;

package/src/transpiler/output/codegen/generators/declarationGenerators/RegisterGenerator.ts

@@ -20,6 +20,7 @@ import IGeneratorState from "../IGeneratorState";
 import IGeneratorOutput from "../IGeneratorOutput";
 import IOrchestrator from "../IOrchestrator";
 import TGeneratorFn from "../TGeneratorFn";
+import generateRegisterMacros from "./RegisterMacroGenerator";
 
 /**
  * Generate C #define macros from a C-Next register declaration.
@@ -36,30 +37,16 @@ const generateRegister: TGeneratorFn<Parser.RegisterDeclarationContext> = (
   const name = node.IDENTIFIER().getText();
   const baseAddress = orchestrator.generateExpression(node.expression());
 
-  const lines: string[] = [];
-  lines.push(`/* Register: ${name} @ ${baseAddress} */`);
-
-  // Generate individual #define for each register member with its offset
-  // This handles non-contiguous register layouts correctly (like i.MX RT1062)
-  for (const member of node.registerMember()) {
-    const regName = member.IDENTIFIER().getText();
-    const regType = orchestrator.generateType(member.type());
-    const access = member.accessModifier().getText();
-    const offset = orchestrator.generateExpression(member.expression());
-
-    // Determine qualifiers based on access mode
-    let cast = `volatile ${regType}*`;
-    if (access === "ro") {
-      cast = `volatile ${regType} const *`;
-    }
-
-    // Generate: #define GPIO7_DR (*(volatile uint32_t*)(0x42004000 + 0x00))
-    lines.push(
-      `#define ${name}_${regName} (*(${cast})(${baseAddress} + ${offset}))`,
-    );
-  }
-
-  lines.push("");
+  const lines: string[] = [
+    `/* Register: ${name} @ ${baseAddress} */`,
+    ...generateRegisterMacros(
+      node.registerMember(),
+      name,
+      baseAddress,
+      orchestrator,
+    ),
+    "",
+  ];
 
   return {
     code: lines.join("\n"),

package/src/transpiler/output/codegen/generators/declarationGenerators/RegisterMacroGenerator.ts

@@ -0,0 +1,64 @@
+/**
+ * RegisterMacroGenerator - Shared logic for register #define macro generation
+ *
+ * Extracts common logic from RegisterGenerator and ScopedRegisterGenerator
+ * for generating C #define macros from C-Next register members.
+ */
+import * as Parser from "../../../../logic/parser/grammar/CNextParser";
+import IOrchestrator from "../IOrchestrator";
+
+/**
+ * Optional type resolver for scoped types.
+ * Returns resolved type name if found, undefined to use original type.
+ */
+type TTypeResolver = (originalType: string) => string | undefined;
+
+/**
+ * Generate #define macros for register members.
+ *
+ * @param members - Register member declarations from AST
+ * @param prefix - Prefix for macro names (e.g., "GPIO7" or "Teensy4_GPIO7")
+ * @param baseAddress - Base address expression string
+ * @param orchestrator - Code generation orchestrator
+ * @param typeResolver - Optional callback to resolve scoped types
+ * @returns Array of #define lines
+ */
+function generateRegisterMacros(
+  members: Parser.RegisterMemberContext[],
+  prefix: string,
+  baseAddress: string,
+  orchestrator: IOrchestrator,
+  typeResolver?: TTypeResolver,
+): string[] {
+  const lines: string[] = [];
+
+  for (const member of members) {
+    const regName = member.IDENTIFIER().getText();
+    let regType = orchestrator.generateType(member.type());
+    const access = member.accessModifier().getText();
+    const offset = orchestrator.generateExpression(member.expression());
+
+    // Apply optional type resolution (for scoped bitmaps)
+    if (typeResolver) {
+      const resolved = typeResolver(regType);
+      if (resolved) {
+        regType = resolved;
+      }
+    }
+
+    // Determine qualifiers based on access mode
+    let cast = `volatile ${regType}*`;
+    if (access === "ro") {
+      cast = `volatile ${regType} const *`;
+    }
+
+    // Generate: #define PREFIX_REGNAME (*(volatile type*)(base + offset))
+    lines.push(
+      `#define ${prefix}_${regName} (*(${cast})(${baseAddress} + ${offset}))`,
+    );
+  }
+
+  return lines;
+}
+
+export default generateRegisterMacros;

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

@@ -22,6 +22,34 @@ import IOrchestrator from "../IOrchestrator";
 import TGeneratorFn from "../TGeneratorFn";
 import generateScopedRegister from "./ScopedRegisterGenerator";
 import BitmapCommentUtils from "./BitmapCommentUtils";
+import ArrayDimensionUtils from "./ArrayDimensionUtils";
+
+/**
+ * Generate initializer expression for a variable declaration.
+ */
+function generateInitializer(
+  varDecl: Parser.VariableDeclarationContext,
+  isArray: boolean,
+  orchestrator: IOrchestrator,
+): string {
+  if (varDecl.expression()) {
+    return ` = ${orchestrator.generateExpression(varDecl.expression()!)}`;
+  }
+  // ADR-015: Zero initialization for uninitialized scope variables
+  return ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
+}
+
+/**
+ * Extract scoped name from a declaration node.
+ * Returns both the local name and the fully qualified scoped name.
+ */
+function getScopedName(
+  node: { IDENTIFIER(): { getText(): string } },
+  scopeName: string,
+): { name: string; fullName: string } {
+  const name = node.IDENTIFIER().getText();
+  return { name, fullName: `${scopeName}_${name}` };
+}
 
 /**
  * Validate and resolve constructor arguments, ensuring each is const.
@@ -69,30 +97,25 @@ function generateScopeVariable(
   // Issue #375: Check for constructor syntax
   const constructorArgList = varDecl.constructorArgumentList();
   if (constructorArgList) {
-    // ADR-016: All scope variables are emitted at file scope
-    const type = orchestrator.generateType(varDecl.type());
-    const fullName = `${scopeName}_${varName}`;
-    const prefix = isPrivate ? "static " : "";
-
-    // Validate and resolve constructor arguments
-    const argIdentifiers = constructorArgList.IDENTIFIER();
-    const line = varDecl.start?.line ?? 0;
-    const resolvedArgs = resolveConstructorArgs(
-      argIdentifiers,
+    return generateConstructorVariable(
+      varDecl,
+      varName,
       scopeName,
-      line,
+      isPrivate,
+      constructorArgList,
       orchestrator,
     );
-
-    return `${prefix}${type} ${fullName}(${resolvedArgs.join(", ")});`;
   }
 
   // Issue #282: Check if this is a const variable - const values should be inlined
   const isConst = varDecl.constModifier() !== null;
 
   // Issue #500: Check if array before skipping - arrays must be emitted
+  // Check both C-style arrayDimension and C-Next style arrayType
+  // Use optional chaining for mock compatibility in tests
   const arrayDims = varDecl.arrayDimension();
-  const isArray = arrayDims.length > 0;
+  const arrayTypeCtx = varDecl.type().arrayType?.() ?? null;
+  const isArray = arrayDims.length > 0 || arrayTypeCtx !== null;
 
   // Issue #282: Private const variables should be inlined, not emitted at file scope
   // Issue #500: EXCEPT arrays - arrays must be emitted as static const
@@ -101,6 +124,60 @@ function generateScopeVariable(
     return null;
   }
 
+  return generateRegularVariable(
+    varDecl,
+    varName,
+    scopeName,
+    isPrivate,
+    orchestrator,
+  );
+}
+
+/**
+ * Generate a constructor-style variable declaration.
+ */
+function generateConstructorVariable(
+  varDecl: Parser.VariableDeclarationContext,
+  varName: string,
+  scopeName: string,
+  isPrivate: boolean,
+  constructorArgList: Parser.ConstructorArgumentListContext,
+  orchestrator: IOrchestrator,
+): string {
+  // ADR-016: All scope variables are emitted at file scope
+  const type = orchestrator.generateType(varDecl.type());
+  const fullName = `${scopeName}_${varName}`;
+  const prefix = isPrivate ? "static " : "";
+
+  // Validate and resolve constructor arguments
+  const argIdentifiers = constructorArgList.IDENTIFIER();
+  const line = varDecl.start?.line ?? 0;
+  const resolvedArgs = resolveConstructorArgs(
+    argIdentifiers,
+    scopeName,
+    line,
+    orchestrator,
+  );
+
+  return `${prefix}${type} ${fullName}(${resolvedArgs.join(", ")});`;
+}
+
+/**
+ * Generate a regular (non-constructor) variable declaration.
+ */
+function generateRegularVariable(
+  varDecl: Parser.VariableDeclarationContext,
+  varName: string,
+  scopeName: string,
+  isPrivate: boolean,
+  orchestrator: IOrchestrator,
+): string {
+  // Derive array and const info from varDecl
+  const isConst = varDecl.constModifier() !== null;
+  const arrayDims = varDecl.arrayDimension();
+  const arrayTypeCtx = varDecl.type().arrayType?.() ?? null;
+  const isArray = arrayDims.length > 0 || arrayTypeCtx !== null;
+
   // ADR-016: All scope variables are emitted at file scope (static-like persistence)
   const type = orchestrator.generateType(varDecl.type());
   const fullName = `${scopeName}_${varName}`;
@@ -108,26 +185,22 @@ function generateScopeVariable(
   const constPrefix = isConst ? "const " : "";
   const prefix = isPrivate ? "static " : "";
 
-  // ADR-036: arrayDimension() now returns an array (arrayDims defined above)
+  // Build declaration with all dimensions
   let decl = `${prefix}${constPrefix}${type} ${fullName}`;
-  if (isArray) {
+  decl += ArrayDimensionUtils.generateArrayTypeDimension(
+    arrayTypeCtx,
+    orchestrator,
+  );
+
+  if (arrayDims.length > 0) {
+    // C-style or additional dimensions
     decl += orchestrator.generateArrayDimensions(arrayDims);
   }
+
   // ADR-045: Add string capacity dimension for string arrays
-  if (varDecl.type().stringType()) {
-    const stringCtx = varDecl.type().stringType()!;
-    const intLiteral = stringCtx.INTEGER_LITERAL();
-    if (intLiteral) {
-      const capacity = Number.parseInt(intLiteral.getText(), 10);
-      decl += `[${capacity + 1}]`;
-    }
-  }
-  if (varDecl.expression()) {
-    decl += ` = ${orchestrator.generateExpression(varDecl.expression()!)}`;
-  } else {
-    // ADR-015: Zero initialization for uninitialized scope variables
-    decl += ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
-  }
+  decl += ArrayDimensionUtils.generateStringCapacityDim(varDecl.type());
+  decl += generateInitializer(varDecl, isArray, orchestrator);
+
   return decl + ";";
 }
 
@@ -339,11 +412,8 @@ function generateScopedEnumInline(
   input: IGeneratorInput,
   orchestrator: IOrchestrator,
 ): string {
-  const name = node.IDENTIFIER().getText();
-  const fullName = `${scopeName}_${name}`;
-
-  const lines: string[] = [];
-  lines.push(`typedef enum {`);
+  const { fullName } = getScopedName(node, scopeName);
+  const lines: string[] = [`typedef enum {`];
 
   // Try to get members from symbol info first
   const symbolMembers = input.symbols?.enumMembers.get(fullName);
@@ -449,6 +519,35 @@ function generateScopedBitmapInline(
   return lines.join("\n");
 }
 
+/**
+ * Generate a single struct field declaration for scoped struct.
+ */
+function generateScopedStructField(
+  member: Parser.StructMemberContext,
+  orchestrator: IOrchestrator,
+): string {
+  const fieldName = member.IDENTIFIER().getText();
+  const fieldType = orchestrator.generateType(member.type());
+
+  // Handle C-Next style arrayType syntax (u16[8] arr)
+  const arrayTypeCtx = member.type().arrayType?.() ?? null;
+  let dimStr = ArrayDimensionUtils.generateArrayTypeDimension(
+    arrayTypeCtx,
+    orchestrator,
+  );
+
+  // Handle C-style array dimensions if present
+  const arrayDims = member.arrayDimension();
+  if (arrayDims.length > 0) {
+    dimStr += orchestrator.generateArrayDimensions(arrayDims);
+  }
+
+  // Handle string capacity for string fields
+  dimStr += ArrayDimensionUtils.generateStringCapacityDim(member.type());
+
+  return `    ${fieldType} ${fieldName}${dimStr};`;
+}
+
 /**
  * Generate struct inside a scope with proper prefixing.
  * Struct fields maintain their original types.
@@ -459,35 +558,12 @@ function generateScopedStructInline(
   _input: IGeneratorInput,
   orchestrator: IOrchestrator,
 ): string {
-  const name = node.IDENTIFIER().getText();
-  const fullName = `${scopeName}_${name}`;
-
-  const lines: string[] = [];
-  lines.push(`typedef struct ${fullName} {`);
+  const { fullName } = getScopedName(node, scopeName);
+  const lines: string[] = [`typedef struct ${fullName} {`];
 
   // Process struct members
   for (const member of node.structMember()) {
-    const fieldName = member.IDENTIFIER().getText();
-    const fieldType = orchestrator.generateType(member.type());
-
-    // Handle array dimensions if present
-    const arrayDims = member.arrayDimension();
-    let dimStr = "";
-    if (arrayDims.length > 0) {
-      dimStr = orchestrator.generateArrayDimensions(arrayDims);
-    }
-
-    // Handle string capacity for string fields
-    if (member.type().stringType()) {
-      const stringCtx = member.type().stringType()!;
-      const intLiteral = stringCtx.INTEGER_LITERAL();
-      if (intLiteral) {
-        const capacity = Number.parseInt(intLiteral.getText(), 10);
-        dimStr += `[${capacity + 1}]`;
-      }
-    }
-
-    lines.push(`    ${fieldType} ${fieldName}${dimStr};`);
+    lines.push(generateScopedStructField(member, orchestrator));
   }
 
   lines.push(`} ${fullName};`, "");