c-next 0.1.62 → 0.1.63

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/__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/ScopeGenerator.ts

@@ -22,6 +22,22 @@ 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.
@@ -81,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
@@ -113,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}`;
@@ -120,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 + ";";
 }
 
@@ -458,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.
@@ -473,27 +563,7 @@ function generateScopedStructInline(
 
   // 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};`, "");

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);
+      }
+    });
+  });
+});