c-next 0.1.61 → 0.1.63

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

@@ -13,6 +13,7 @@ import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IGeneratorOutput from "../IGeneratorOutput";
 import IOrchestrator from "../IOrchestrator";
+import generateRegisterMacros from "./RegisterMacroGenerator";
 
 /**
  * Generate register macros with scope prefix.
@@ -28,35 +29,25 @@ const generateScopedRegister = (
   const fullName = `${scopeName}_${name}`; // Teensy4_GPIO7
   const baseAddress = orchestrator.generateExpression(node.expression());
 
-  const lines: string[] = [];
-  lines.push(`/* Register: ${fullName} @ ${baseAddress} */`);
-
-  // Generate individual #define for each register member with its offset
-  for (const member of node.registerMember()) {
-    const regName = member.IDENTIFIER().getText();
-    let regType = orchestrator.generateType(member.type());
-    const access = member.accessModifier().getText();
-    const offset = orchestrator.generateExpression(member.expression());
-
-    // Check if the type is a scoped bitmap (e.g., GPIO7Pins -> Teensy4_GPIO7Pins)
+  // Type resolver for scoped bitmaps (e.g., GPIO7Pins -> Teensy4_GPIO7Pins)
+  const resolveType = (regType: string): string | undefined => {
     const scopedTypeName = `${scopeName}_${regType}`;
-    if (input.symbols?.knownBitmaps.has(scopedTypeName)) {
-      regType = scopedTypeName;
-    }
-
-    // Determine qualifiers based on access mode
-    let cast = `volatile ${regType}*`;
-    if (access === "ro") {
-      cast = `volatile ${regType} const *`;
-    }
-
-    // Generate: #define Teensy4_GPIO7_DR (*(volatile uint32_t*)(0x42004000 + 0x00))
-    lines.push(
-      `#define ${fullName}_${regName} (*(${cast})(${baseAddress} + ${offset}))`,
-    );
-  }
+    return input.symbols?.knownBitmaps.has(scopedTypeName)
+      ? scopedTypeName
+      : undefined;
+  };
 
-  lines.push("");
+  const lines: string[] = [
+    `/* Register: ${fullName} @ ${baseAddress} */`,
+    ...generateRegisterMacros(
+      node.registerMember(),
+      fullName,
+      baseAddress,
+      orchestrator,
+      resolveType,
+    ),
+    "",
+  ];
 
   return {
     code: lines.join("\n"),

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

@@ -21,6 +21,86 @@ import IGeneratorOutput from "../IGeneratorOutput";
 import IOrchestrator from "../IOrchestrator";
 import TGeneratorFn from "../TGeneratorFn";
 import TGeneratorEffect from "../TGeneratorEffect";
+import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
+import ArrayDimensionUtils from "./ArrayDimensionUtils";
+
+/**
+ * Generate a callback field declaration for a struct.
+ */
+function generateCallbackField(
+  fieldName: string,
+  callbackInfo: { typedefName: string },
+  isArray: boolean,
+  arrayDims: Parser.ArrayDimensionContext[],
+  orchestrator: IOrchestrator,
+): string {
+  if (isArray) {
+    const dims = orchestrator.generateArrayDimensions(arrayDims);
+    return `    ${callbackInfo.typedefName} ${fieldName}${dims};`;
+  }
+  return `    ${callbackInfo.typedefName} ${fieldName};`;
+}
+
+/**
+ * Generate a regular (non-callback) field declaration for a struct.
+ */
+function generateRegularField(
+  fieldName: string,
+  structName: string,
+  member: Parser.StructMemberContext,
+  isArray: boolean,
+  arrayDims: Parser.ArrayDimensionContext[],
+  input: IGeneratorInput,
+  orchestrator: IOrchestrator,
+): string {
+  const type = orchestrator.generateType(member.type());
+
+  // Check for arrayType syntax: u8[16] data -> member.type().arrayType()
+  // Use optional chaining for mock compatibility in tests
+  const arrayTypeCtx = member.type().arrayType?.() ?? null;
+  const arrayTypeDimStr = ArrayDimensionUtils.generateArrayTypeDimension(
+    arrayTypeCtx,
+    orchestrator,
+  );
+  const hasArrayTypeSyntax = arrayTypeCtx !== null;
+
+  // Check if we have tracked dimensions for this field (includes string capacity for string arrays)
+  const fieldDims = getTrackedFieldDimensions(
+    input.symbols,
+    structName,
+    fieldName,
+  );
+
+  if (fieldDims !== undefined) {
+    // Use tracked dimensions (includes string capacity for string arrays)
+    const dimsStr = fieldDims.map((d) => `[${d}]`).join("");
+    return `    ${type} ${fieldName}${dimsStr};`;
+  }
+
+  if (hasArrayTypeSyntax || isArray) {
+    // Combine arrayType dimension (if any) with arrayDimension dimensions
+    const dims = orchestrator.generateArrayDimensions(arrayDims);
+    return `    ${type} ${fieldName}${arrayTypeDimStr}${dims};`;
+  }
+
+  return `    ${type} ${fieldName};`;
+}
+
+/**
+ * Get tracked field dimensions from symbols if available.
+ */
+function getTrackedFieldDimensions(
+  symbols: ICodeGenSymbols | null,
+  structName: string,
+  fieldName: string,
+): readonly number[] | undefined {
+  if (!symbols) {
+    return undefined;
+  }
+  const trackedDimensions = symbols.structFieldDimensions.get(structName);
+  const fieldDims = trackedDimensions?.get(fieldName);
+  return fieldDims && fieldDims.length > 0 ? fieldDims : undefined;
+}
 
 /**
  * Generate a C typedef struct from a C-Next struct declaration.
@@ -64,31 +144,28 @@ const generateStruct: TGeneratorFn<Parser.StructDeclarationContext> = (
         typeName,
       });
 
-      if (isArray) {
-        const dims = orchestrator.generateArrayDimensions(arrayDims);
-        lines.push(`    ${callbackInfo.typedefName} ${fieldName}${dims};`);
-      } else {
-        lines.push(`    ${callbackInfo.typedefName} ${fieldName};`);
-      }
+      lines.push(
+        generateCallbackField(
+          fieldName,
+          callbackInfo,
+          isArray,
+          arrayDims,
+          orchestrator,
+        ),
+      );
     } else {
       // Regular field handling
-      const type = orchestrator.generateType(member.type());
-
-      // Check if we have tracked dimensions for this field (includes string capacity for string arrays)
-      const trackedDimensions = input.symbols?.structFieldDimensions.get(name);
-      const fieldDims = trackedDimensions?.get(fieldName);
-
-      if (fieldDims && fieldDims.length > 0) {
-        // Use tracked dimensions (includes string capacity for string arrays)
-        const dimsStr = fieldDims.map((d) => `[${d}]`).join("");
-        lines.push(`    ${type} ${fieldName}${dimsStr};`);
-      } else if (isArray) {
-        // Fall back to AST dimensions for non-string arrays
-        const dims = orchestrator.generateArrayDimensions(arrayDims);
-        lines.push(`    ${type} ${fieldName}${dims};`);
-      } else {
-        lines.push(`    ${type} ${fieldName};`);
-      }
+      lines.push(
+        generateRegularField(
+          fieldName,
+          name,
+          member,
+          isArray,
+          arrayDims,
+          input,
+          orchestrator,
+        ),
+      );
     }
   }
 

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import ArrayDimensionUtils from "../ArrayDimensionUtils";
+import IOrchestrator from "../../IOrchestrator";
+
+describe("ArrayDimensionUtils", () => {
+  const createMockOrchestrator = (
+    constValue?: number,
+    exprText = "EXPR",
+  ): IOrchestrator => {
+    return {
+      tryEvaluateConstant: vi.fn().mockReturnValue(constValue),
+      generateExpression: vi.fn().mockReturnValue(exprText),
+    } as unknown as IOrchestrator;
+  };
+
+  describe("generateArrayTypeDimension", () => {
+    it("returns empty string for null context", () => {
+      const orchestrator = createMockOrchestrator();
+      const result = ArrayDimensionUtils.generateArrayTypeDimension(
+        null,
+        orchestrator,
+      );
+      expect(result).toBe("");
+    });
+
+    it("returns [] for context with no expression", () => {
+      const orchestrator = createMockOrchestrator();
+      const ctx = {
+        expression: () => null,
+      };
+      const result = ArrayDimensionUtils.generateArrayTypeDimension(
+        ctx as never,
+        orchestrator,
+      );
+      expect(result).toBe("[]");
+    });
+
+    it("returns constant dimension when evaluable", () => {
+      const orchestrator = createMockOrchestrator(16);
+      const ctx = {
+        expression: () => ({ getText: () => "16" }),
+      };
+      const result = ArrayDimensionUtils.generateArrayTypeDimension(
+        ctx as never,
+        orchestrator,
+      );
+      expect(result).toBe("[16]");
+      expect(orchestrator.tryEvaluateConstant).toHaveBeenCalled();
+    });
+
+    it("falls back to expression generation for non-constant", () => {
+      const orchestrator = createMockOrchestrator(undefined, "BUFFER_SIZE");
+      const mockExpr = { getText: () => "BUFFER_SIZE" };
+      const ctx = {
+        expression: () => mockExpr,
+      };
+      const result = ArrayDimensionUtils.generateArrayTypeDimension(
+        ctx as never,
+        orchestrator,
+      );
+      expect(result).toBe("[BUFFER_SIZE]");
+      expect(orchestrator.generateExpression).toHaveBeenCalledWith(mockExpr);
+    });
+  });
+
+  describe("generateStringCapacityDim", () => {
+    it("returns empty string for non-string type", () => {
+      const ctx = {
+        stringType: () => null,
+      };
+      const result = ArrayDimensionUtils.generateStringCapacityDim(
+        ctx as never,
+      );
+      expect(result).toBe("");
+    });
+
+    it("returns empty string for string without capacity", () => {
+      const ctx = {
+        stringType: () => ({
+          INTEGER_LITERAL: () => null,
+        }),
+      };
+      const result = ArrayDimensionUtils.generateStringCapacityDim(
+        ctx as never,
+      );
+      expect(result).toBe("");
+    });
+
+    it("returns capacity + 1 for string with capacity", () => {
+      const ctx = {
+        stringType: () => ({
+          INTEGER_LITERAL: () => ({
+            getText: () => "32",
+          }),
+        }),
+      };
+      const result = ArrayDimensionUtils.generateStringCapacityDim(
+        ctx as never,
+      );
+      expect(result).toBe("[33]");
+    });
+
+    it("handles various capacity values", () => {
+      const testCases = [
+        { input: "8", expected: "[9]" },
+        { input: "64", expected: "[65]" },
+        { input: "255", expected: "[256]" },
+      ];
+
+      for (const { input, expected } of testCases) {
+        const ctx = {
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({
+              getText: () => input,
+            }),
+          }),
+        };
+        const result = ArrayDimensionUtils.generateStringCapacityDim(
+          ctx as never,
+        );
+        expect(result).toBe(expected);
+      }
+    });
+  });
+});

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

@@ -42,10 +42,35 @@ function createMockConstModifier(
   return isConst ? ({} as Parser.ConstModifierContext) : null;
 }
 
+/**
+ * Create a mock array type context.
+ */
+function createMockArrayType(sizeExpr?: string | null) {
+  if (sizeExpr === null) {
+    // Empty brackets - no expression
+    return {
+      expression: () => null,
+    };
+  }
+  return {
+    expression: () =>
+      sizeExpr
+        ? {
+            getText: () => sizeExpr,
+            __mockValue: sizeExpr,
+          }
+        : null,
+  };
+}
+
 /**
  * Create a mock type context.
  */
-function createMockType(typeName: string, hasStringType = false) {
+function createMockType(
+  typeName: string,
+  hasStringType = false,
+  arrayTypeSize?: string | null,
+) {
   return {
     getText: () => typeName,
     stringType: () =>
@@ -54,6 +79,8 @@ function createMockType(typeName: string, hasStringType = false) {
             INTEGER_LITERAL: () => ({ getText: () => "32" }),
           }
         : null,
+    arrayType: () =>
+      arrayTypeSize !== undefined ? createMockArrayType(arrayTypeSize) : null,
   };
 }
 
@@ -99,10 +126,16 @@ function createMockVariableDecl(options: {
   hasStringType?: boolean;
   constructorArgs?: string[];
   startLine?: number;
+  arrayTypeSize?: string | null; // C-Next style: u16[8] name
 }) {
   return {
     IDENTIFIER: () => ({ getText: () => options.name }),
-    type: () => createMockType(options.type, options.hasStringType),
+    type: () =>
+      createMockType(
+        options.type,
+        options.hasStringType,
+        options.arrayTypeSize,
+      ),
     constModifier: () => createMockConstModifier(options.isConst ?? false),
     expression: () =>
       options.initialValue ? createMockExpression(options.initialValue) : null,
@@ -207,10 +240,11 @@ function createMockStructMember(
   type: string,
   arrayDims?: string[],
   hasStringType = false,
+  arrayTypeSize?: string | null,
 ) {
   return {
     IDENTIFIER: () => ({ getText: () => name }),
-    type: () => createMockType(type, hasStringType),
+    type: () => createMockType(type, hasStringType, arrayTypeSize),
     arrayDimension: () => (arrayDims ?? []).map(createMockArrayDimension),
   };
 }
@@ -225,13 +259,20 @@ function createMockStructDecl(
     type: string;
     arrayDims?: string[];
     hasStringType?: boolean;
+    arrayTypeSize?: string | null;
   }>,
 ) {
   return {
     IDENTIFIER: () => ({ getText: () => name }),
     structMember: () =>
       members.map((m) =>
-        createMockStructMember(m.name, m.type, m.arrayDims, m.hasStringType),
+        createMockStructMember(
+          m.name,
+          m.type,
+          m.arrayDims,
+          m.hasStringType,
+          m.arrayTypeSize,
+        ),
       ),
   };
 }
@@ -579,6 +620,66 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("static uint8_t Serial_buffer[256] = {0};");
     });
 
+    it("generates C-Next style array variable with constant size", () => {
+      const varDecl = createMockVariableDecl({
+        name: "data",
+        type: "u16[8]",
+        arrayTypeSize: "8",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Buffer", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => 8),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("static u16[8] Buffer_data[8] = {0};");
+    });
+
+    it("generates C-Next style array variable with non-constant expression (fallback)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "items",
+        type: "u16[BUFFER_SIZE]",
+        arrayTypeSize: "BUFFER_SIZE",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Storage", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => undefined), // Can't resolve macro
+        generateExpression: vi.fn(() => "BUFFER_SIZE"),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain(
+        "static u16[BUFFER_SIZE] Storage_items[BUFFER_SIZE] = {0};",
+      );
+    });
+
+    it("generates C-Next style array variable with no size (empty brackets)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "flexible",
+        type: "u8[]",
+        arrayTypeSize: null, // No size expression
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Dynamic", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("static u8[] Dynamic_flexible[] = {0};");
+    });
+
     it("generates string variable with capacity dimension (ADR-045)", () => {
       const varDecl = createMockVariableDecl({
         name: "message",
@@ -1036,6 +1137,58 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("uint8_t data[256];");
     });
 
+    it("generates struct field with C-Next array type constant size", () => {
+      const structDecl = createMockStructDecl("Container", [
+        { name: "items", type: "u16[4]", arrayTypeSize: "4" },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Data", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => 4),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u16[4] items[4];");
+    });
+
+    it("generates struct field with C-Next array type non-constant (fallback)", () => {
+      const structDecl = createMockStructDecl("FlexContainer", [
+        { name: "buffer", type: "u8[MAX_SIZE]", arrayTypeSize: "MAX_SIZE" },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Flex", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        tryEvaluateConstant: vi.fn(() => undefined), // Can't resolve macro
+        generateExpression: vi.fn(() => "MAX_SIZE"),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u8[MAX_SIZE] buffer[MAX_SIZE];");
+    });
+
+    it("generates struct field with C-Next array type no size (empty brackets)", () => {
+      const structDecl = createMockStructDecl("DynamicContainer", [
+        { name: "data", type: "u8[]", arrayTypeSize: null },
+      ]);
+      const member = createMockScopeMember({ structDecl: structDecl });
+      const ctx = createMockScopeContext("Dyn", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("u8[] data[];");
+    });
+
     it("generates struct field with string capacity", () => {
       const structDecl = createMockStructDecl("Message", [
         { name: "text", type: "string<64>", hasStringType: true },

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -931,7 +931,11 @@ const tryKnownScopeAccess = (
       state.currentScope,
     );
   }
-  orchestrator.validateCrossScopeVisibility(ctx.result, ctx.memberName);
+  orchestrator.validateCrossScopeVisibility(
+    ctx.result,
+    ctx.memberName,
+    ctx.isGlobalAccess,
+  );
 
   const output = initializeMemberOutput(ctx);
   output.result = `${ctx.result}${orchestrator.getScopeSeparator(ctx.isCppAccessChain)}${ctx.memberName}`;

package/src/transpiler/output/codegen/generators/statements/ControlFlowGenerator.ts

@@ -25,23 +25,7 @@ import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 import VariableModifierBuilder from "../../helpers/VariableModifierBuilder";
 import ExpressionUtils from "../../../../../utils/ExpressionUtils";
-
-/**
- * Maps C-Next assignment operators to C assignment operators
- */
-const ASSIGNMENT_OPERATOR_MAP: Record<string, string> = {
-  "<-": "=",
-  "+<-": "+=",
-  "-<-": "-=",
-  "*<-": "*=",
-  "/<-": "/=",
-  "%<-": "%=",
-  "&<-": "&=",
-  "|<-": "|=",
-  "^<-": "^=",
-  "<<<-": "<<=",
-  ">><-": ">>=",
-};
+import ASSIGNMENT_OPERATOR_MAP from "../../../../../utils/constants/OperatorMappings";
 
 /**
  * Issue #477: Check if a simple identifier is an unqualified enum member.

package/src/transpiler/output/codegen/generators/support/HelperGenerator.ts

@@ -11,6 +11,27 @@
 import TYPE_MAP from "../../types/TYPE_MAP";
 import OverflowHelperTemplates from "./OverflowHelperTemplates";
 
+/**
+ * Generate a safe arithmetic helper function (div or mod).
+ * Extracted to eliminate duplication between safe_div and safe_mod generation.
+ */
+const generateSafeArithmeticHelper = (
+  opName: string,
+  opSymbol: string,
+  cnxType: string,
+  cType: string,
+): string[] => [
+  `static inline bool cnx_safe_${opName}_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
+  `    if (divisor == 0) {`,
+  `        *output = defaultValue;`,
+  `        return true;  // Error occurred`,
+  `    }`,
+  `    *output = numerator ${opSymbol} divisor;`,
+  `    return false;  // Success`,
+  `}`,
+  "",
+];
+
 /**
  * Generate all needed overflow helper functions
  * ADR-044: Overflow helper functions with clamping or panic behavior
@@ -90,32 +111,12 @@ const generateSafeDivHelpers = (
 
     // Generate safe_div helper if needed
     if (needsDiv) {
-      lines.push(
-        `static inline bool cnx_safe_div_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
-        `    if (divisor == 0) {`,
-        `        *output = defaultValue;`,
-        `        return true;  // Error occurred`,
-        `    }`,
-        `    *output = numerator / divisor;`,
-        `    return false;  // Success`,
-        `}`,
-        "",
-      );
+      lines.push(...generateSafeArithmeticHelper("div", "/", cnxType, cType));
     }
 
     // Generate safe_mod helper if needed
     if (needsMod) {
-      lines.push(
-        `static inline bool cnx_safe_mod_${cnxType}(${cType}* output, ${cType} numerator, ${cType} divisor, ${cType} defaultValue) {`,
-        `    if (divisor == 0) {`,
-        `        *output = defaultValue;`,
-        `        return true;  // Error occurred`,
-        `    }`,
-        `    *output = numerator % divisor;`,
-        `    return false;  // Success`,
-        `}`,
-        "",
-      );
+      lines.push(...generateSafeArithmeticHelper("mod", "%", cnxType, cType));
     }
   }