c-next 0.1.69 → 0.1.71

package/src/transpiler/output/codegen/helpers/__tests__/TypeRegistrationEngine.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Unit tests for TypeRegistrationEngine
+ * Issue #791: Tests for extracted type registration logic
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import TypeRegistrationEngine from "../TypeRegistrationEngine";
+import CNextSourceParser from "../../../../logic/parser/CNextSourceParser";
+import CodeGenState from "../../../../state/CodeGenState";
+import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
+import * as Parser from "../../../../logic/parser/grammar/CNextParser";
+
+/**
+ * Create a minimal mock ICodeGenSymbols with default empty collections.
+ */
+function createMockSymbols(): ICodeGenSymbols {
+  return {
+    knownScopes: new Set(),
+    knownEnums: new Set(),
+    knownBitmaps: new Set(),
+    knownStructs: new Set(),
+    knownRegisters: new Set(),
+    scopeMembers: new Map(),
+    scopeMemberVisibility: new Map(),
+    structFields: new Map(),
+    structFieldArrays: new Map(),
+    structFieldDimensions: new Map(),
+    enumMembers: new Map(),
+    bitmapFields: new Map(),
+    bitmapBackingType: new Map(),
+    bitmapBitWidth: new Map(),
+    scopedRegisters: new Map(),
+    registerMemberAccess: new Map(),
+    registerMemberTypes: new Map(),
+    registerBaseAddresses: new Map(),
+    registerMemberOffsets: new Map(),
+    registerMemberCTypes: new Map(),
+    scopeVariableUsage: new Map(),
+    scopePrivateConstValues: new Map(),
+    functionReturnTypes: new Map(),
+    getSingleFunctionForVariable: () => null,
+    hasPublicSymbols: () => false,
+  };
+}
+
+/**
+ * Helper to parse a variable declaration and get its arrayType context
+ */
+function parseArrayType(source: string): Parser.ArrayTypeContext | null {
+  const tree = CNextSourceParser.parse(source).tree;
+  const decl = tree.declaration(0)?.variableDeclaration();
+  return decl?.type()?.arrayType() ?? null;
+}
+
+/**
+ * Helper to parse a variable declaration and get its type context
+ */
+function parseTypeContext(source: string): Parser.TypeContext | null {
+  const tree = CNextSourceParser.parse(source).tree;
+  const decl = tree.declaration(0)?.variableDeclaration();
+  return decl?.type() ?? null;
+}
+
+describe("TypeRegistrationEngine", () => {
+  describe("parseArrayTypeDimension", () => {
+    it("returns number for integer literal dimension", () => {
+      const ctx = parseArrayType("u8[10] buffer;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.parseArrayTypeDimension(ctx!);
+      expect(result).toBe(10);
+    });
+
+    it("returns undefined for empty dimension", () => {
+      const ctx = parseArrayType("u8[] buffer;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.parseArrayTypeDimension(ctx!);
+      expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for non-numeric dimension", () => {
+      const ctx = parseArrayType("u8[SIZE] buffer;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.parseArrayTypeDimension(ctx!);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("resolveBaseType", () => {
+    it("resolves primitive types", () => {
+      const ctx = parseTypeContext("u32 counter;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, null);
+      expect(result).toBe("u32");
+    });
+
+    it("resolves scoped types with currentScope", () => {
+      const ctx = parseTypeContext("this.State value;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, "Motor");
+      expect(result).toBe("Motor_State");
+    });
+
+    it("resolves scoped types without currentScope", () => {
+      const ctx = parseTypeContext("this.State value;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, null);
+      expect(result).toBe("State");
+    });
+
+    it("resolves user types", () => {
+      const ctx = parseTypeContext("Point origin;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, null);
+      expect(result).toBe("Point");
+    });
+
+    it("resolves global types", () => {
+      const ctx = parseTypeContext("global.Config cfg;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, "Motor");
+      expect(result).toBe("Config");
+    });
+
+    it("resolves qualified types", () => {
+      const ctx = parseTypeContext("Motor.State state;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, null);
+      expect(result).toBe("Motor_State");
+    });
+
+    it("returns null for string types", () => {
+      const ctx = parseTypeContext("string<64> buffer;");
+      expect(ctx).not.toBeNull();
+      const result = TypeRegistrationEngine.resolveBaseType(ctx!, null);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("register orchestration", () => {
+    const mockCallbacks = {
+      tryEvaluateConstant: vi.fn(),
+      requireInclude: vi.fn(),
+    };
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      CodeGenState.reset();
+      CodeGenState.symbols = createMockSymbols();
+    });
+
+    afterEach(() => {
+      CodeGenState.reset();
+    });
+
+    it("registers global variable types", () => {
+      const source = `u32 counter;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("counter");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("u32");
+      expect(info?.bitWidth).toBe(32);
+    });
+
+    it("tracks const values", () => {
+      mockCallbacks.tryEvaluateConstant.mockReturnValue(10);
+      const source = `const u32 SIZE <- 10;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      expect(CodeGenState.constValues.get("SIZE")).toBe(10);
+    });
+
+    it("requires string include for string types", () => {
+      const source = `string<64> message;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      expect(mockCallbacks.requireInclude).toHaveBeenCalledWith("string");
+    });
+  });
+});

package/src/transpiler/output/codegen/helpers/__tests__/VariableDeclHelper.test.ts

@@ -0,0 +1,460 @@
+/**
+ * Unit tests for VariableDeclHelper
+ *
+ * Issue #792: Tests for extracted variable declaration logic
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import VariableDeclHelper from "../VariableDeclHelper.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
+import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
+import * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
+
+/**
+ * Helper to parse a variable declaration from source code.
+ */
+function parseVarDecl(source: string): Parser.VariableDeclarationContext {
+  const result = CNextSourceParser.parse(source);
+  const decl = result.tree.declaration(0);
+  const varDecl = decl?.variableDeclaration();
+  if (!varDecl) {
+    throw new Error(`Failed to parse variable declaration from: ${source}`);
+  }
+  return varDecl;
+}
+
+/**
+ * Helper to parse a type context from source code.
+ */
+function parseType(source: string): Parser.TypeContext {
+  const varDecl = parseVarDecl(source);
+  return varDecl.type();
+}
+
+describe("VariableDeclHelper", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  // ========================================================================
+  // Tier 1: Pure Utilities
+  // ========================================================================
+
+  describe("parseArrayTypeDimension", () => {
+    it("returns null for non-array types", () => {
+      const typeCtx = parseType("u8 x;");
+      expect(VariableDeclHelper.parseArrayTypeDimension(typeCtx)).toBeNull();
+    });
+
+    it("returns numeric dimension for literal array type", () => {
+      const typeCtx = parseType("u8[10] x;");
+      expect(VariableDeclHelper.parseArrayTypeDimension(typeCtx)).toBe(10);
+    });
+
+    it("returns null for empty array dimension", () => {
+      const typeCtx = parseType("u8[] x;");
+      expect(VariableDeclHelper.parseArrayTypeDimension(typeCtx)).toBeNull();
+    });
+
+    it("returns null for expression dimension", () => {
+      const typeCtx = parseType("u8[SIZE] x;");
+      expect(VariableDeclHelper.parseArrayTypeDimension(typeCtx)).toBeNull();
+    });
+  });
+
+  describe("parseFirstArrayDimension", () => {
+    it("returns null for empty array", () => {
+      expect(VariableDeclHelper.parseFirstArrayDimension([])).toBeNull();
+    });
+
+    it("returns null for empty dimension expression", () => {
+      const varDecl = parseVarDecl("u8 x[];");
+      const dims = varDecl.arrayDimension();
+      expect(VariableDeclHelper.parseFirstArrayDimension(dims)).toBeNull();
+    });
+
+    it("returns numeric value for literal dimension", () => {
+      // Note: arrayTypeDimension != arrayDimension, so we test with arrayDimension
+      const varDecl = parseVarDecl("u8 x[5];");
+      const arrayDims = varDecl.arrayDimension();
+      expect(VariableDeclHelper.parseFirstArrayDimension(arrayDims)).toBe(5);
+    });
+
+    it("returns null for expression dimension", () => {
+      const varDecl = parseVarDecl("u8 x[SIZE];");
+      const dims = varDecl.arrayDimension();
+      expect(VariableDeclHelper.parseFirstArrayDimension(dims)).toBeNull();
+    });
+  });
+
+  describe("extractBaseTypeName", () => {
+    it("extracts primitive type name", () => {
+      const typeCtx = parseType("u8 x;");
+      expect(VariableDeclHelper.extractBaseTypeName(typeCtx)).toBe("u8");
+    });
+
+    it("extracts user type name", () => {
+      const typeCtx = parseType("MyStruct x;");
+      expect(VariableDeclHelper.extractBaseTypeName(typeCtx)).toBe("MyStruct");
+    });
+
+    it("extracts primitive from array type", () => {
+      const typeCtx = parseType("u16[8] x;");
+      expect(VariableDeclHelper.extractBaseTypeName(typeCtx)).toBe("u16");
+    });
+
+    it("extracts user type from array type", () => {
+      const typeCtx = parseType("Point[4] x;");
+      expect(VariableDeclHelper.extractBaseTypeName(typeCtx)).toBe("Point");
+    });
+  });
+
+  // ========================================================================
+  // Tier 2: Simple Operations
+  // ========================================================================
+
+  describe("validateArrayDeclarationSyntax", () => {
+    it("allows C-Next style array syntax", () => {
+      const varDecl = parseVarDecl("u8[10] arr;");
+      const typeCtx = varDecl.type();
+      // Should not throw
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "arr",
+        );
+      }).not.toThrow();
+    });
+
+    it("allows empty dimension for size inference", () => {
+      const varDecl = parseVarDecl("u8 arr[] <- [1, 2, 3];");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "arr",
+        );
+      }).not.toThrow();
+    });
+
+    it("allows multi-dimensional C-style", () => {
+      const varDecl = parseVarDecl("u8 matrix[4][4];");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "matrix",
+        );
+      }).not.toThrow();
+    });
+
+    it("allows string type with C-style", () => {
+      const varDecl = parseVarDecl("string<32> names[4];");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "names",
+        );
+      }).not.toThrow();
+    });
+
+    it("rejects C-style single dimension for primitives", () => {
+      const varDecl = parseVarDecl("u8 arr[10];");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "arr",
+        );
+      }).toThrow(/C-style array declaration is not allowed/);
+    });
+  });
+
+  describe("validateIntegerInitializer", () => {
+    it("does nothing for non-integer types", () => {
+      const varDecl = parseVarDecl("f32 x <- 1.5;");
+      // Should not throw
+      expect(() => {
+        VariableDeclHelper.validateIntegerInitializer(varDecl, "f32", {
+          getExpressionType: () => "f32",
+        });
+      }).not.toThrow();
+    });
+
+    it("accepts valid integer literal", () => {
+      const varDecl = parseVarDecl("u8 x <- 255;");
+      expect(() => {
+        VariableDeclHelper.validateIntegerInitializer(varDecl, "u8", {
+          getExpressionType: () => "u8",
+        });
+      }).not.toThrow();
+    });
+
+    it("throws for overflow in literal", () => {
+      const varDecl = parseVarDecl("u8 x <- 256;");
+      expect(() => {
+        VariableDeclHelper.validateIntegerInitializer(varDecl, "u8", {
+          getExpressionType: () => "u8",
+        });
+      }).toThrow();
+    });
+  });
+
+  describe("finalizeCppClassAssignments", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+    });
+
+    it("returns simple declaration with semicolon when no pending assignments", () => {
+      const typeCtx = parseType("MyClass x;");
+      const result = VariableDeclHelper.finalizeCppClassAssignments(
+        typeCtx,
+        "x",
+        "MyClass x",
+        { getTypeName: () => "MyClass" },
+      );
+      expect(result).toBe("MyClass x;");
+    });
+
+    it("appends assignments in function body", () => {
+      CodeGenState.inFunctionBody = true;
+      CodeGenState.pendingCppClassAssignments = ["field1 = value1"];
+
+      const typeCtx = parseType("MyClass x;");
+      const result = VariableDeclHelper.finalizeCppClassAssignments(
+        typeCtx,
+        "x",
+        "MyClass x",
+        { getTypeName: () => "MyClass" },
+      );
+
+      expect(result).toBe("MyClass x;\nx.field1 = value1");
+      expect(CodeGenState.pendingCppClassAssignments).toHaveLength(0);
+    });
+
+    it("throws error at global scope with pending assignments", () => {
+      CodeGenState.inFunctionBody = false;
+      CodeGenState.pendingCppClassAssignments = ["field1 = value1"];
+
+      const typeCtx = parseType("MyClass x;");
+      expect(() => {
+        VariableDeclHelper.finalizeCppClassAssignments(
+          typeCtx,
+          "x",
+          "MyClass x",
+          { getTypeName: () => "MyClass" },
+        );
+      }).toThrow(/global scope/);
+    });
+  });
+
+  // ========================================================================
+  // Tier 3: Complex Operations
+  // ========================================================================
+
+  describe("getArrayTypeDimension", () => {
+    it("returns empty string for non-array type", () => {
+      const typeCtx = parseType("u8 x;");
+      const result = VariableDeclHelper.getArrayTypeDimension(typeCtx, {
+        tryEvaluateConstant: () => undefined,
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBe("");
+    });
+
+    it("returns dimension string for literal", () => {
+      const typeCtx = parseType("u8[10] x;");
+      const result = VariableDeclHelper.getArrayTypeDimension(typeCtx, {
+        tryEvaluateConstant: () => 10,
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBe("[10]");
+    });
+
+    it("returns empty bracket for unsized dimension", () => {
+      const typeCtx = parseType("u8[] x;");
+      const result = VariableDeclHelper.getArrayTypeDimension(typeCtx, {
+        tryEvaluateConstant: () => undefined,
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBe("[]");
+    });
+
+    it("falls back to expression for non-const", () => {
+      const typeCtx = parseType("u8[SIZE] x;");
+      const result = VariableDeclHelper.getArrayTypeDimension(typeCtx, {
+        tryEvaluateConstant: () => undefined,
+        generateExpression: () => "SIZE",
+      });
+      expect(result).toBe("[SIZE]");
+    });
+  });
+
+  describe("handleArrayDeclaration", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+    });
+
+    it("returns not handled for non-array", () => {
+      const varDecl = parseVarDecl("u8 x;");
+      const typeCtx = varDecl.type();
+      const result = VariableDeclHelper.handleArrayDeclaration(
+        varDecl,
+        typeCtx,
+        "x",
+        "uint8_t x",
+        {
+          generateExpression: (ctx) => ctx.getText(),
+          getTypeName: () => "u8",
+          generateArrayDimensions: () => "",
+          tryEvaluateConstant: () => undefined,
+        },
+      );
+      expect(result.handled).toBe(false);
+      expect(result.isArray).toBe(false);
+    });
+
+    it("returns array with dimension for C-Next style", () => {
+      const varDecl = parseVarDecl("u8[10] arr;");
+      const typeCtx = varDecl.type();
+      const result = VariableDeclHelper.handleArrayDeclaration(
+        varDecl,
+        typeCtx,
+        "arr",
+        "uint8_t arr",
+        {
+          generateExpression: (ctx) => ctx.getText(),
+          getTypeName: () => "u8",
+          generateArrayDimensions: () => "",
+          tryEvaluateConstant: () => 10,
+        },
+      );
+      expect(result.handled).toBe(false);
+      expect(result.isArray).toBe(true);
+      expect(result.decl).toBe("uint8_t arr[10]");
+    });
+  });
+
+  describe("generateVariableInitializer", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+    });
+
+    it("returns zero initializer for uninitialized variable", () => {
+      const varDecl = parseVarDecl("u8 x;");
+      const typeCtx = varDecl.type();
+      const result = VariableDeclHelper.generateVariableInitializer(
+        varDecl,
+        typeCtx,
+        "uint8_t x",
+        false,
+        {
+          generateExpression: (ctx) => ctx.getText(),
+          getTypeName: () => "u8",
+          getZeroInitializer: () => "0",
+          getExpressionType: () => "u8",
+        },
+      );
+      expect(result).toBe("uint8_t x = 0");
+    });
+
+    it("generates expression for initialized variable", () => {
+      const varDecl = parseVarDecl("u8 x <- 42;");
+      const typeCtx = varDecl.type();
+      const result = VariableDeclHelper.generateVariableInitializer(
+        varDecl,
+        typeCtx,
+        "uint8_t x",
+        false,
+        {
+          generateExpression: () => "42",
+          getTypeName: () => "u8",
+          getZeroInitializer: () => "0",
+          getExpressionType: () => "u8",
+        },
+      );
+      expect(result).toBe("uint8_t x = 42");
+    });
+  });
+
+  // ========================================================================
+  // Tier 4: Orchestrators
+  // ========================================================================
+
+  describe("generateConstructorDecl", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+      // Set up a const variable in the type registry for constructor argument
+      CodeGenState.setVariableTypeInfo("pinConst", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: false,
+        arrayDimensions: [],
+        isConst: true,
+      });
+    });
+
+    it("generates constructor declaration with const args", () => {
+      const varDecl = parseVarDecl("MAX31856 thermo(pinConst);");
+      const argListCtx = varDecl.constructorArgumentList()!;
+
+      const result = VariableDeclHelper.generateConstructorDecl(
+        varDecl,
+        argListCtx,
+        { generateType: () => "MAX31856" },
+      );
+
+      expect(result).toBe("MAX31856 thermo(pinConst);");
+    });
+
+    it("throws for undeclared constructor argument", () => {
+      const varDecl = parseVarDecl("MAX31856 thermo(unknownVar);");
+      const argListCtx = varDecl.constructorArgumentList()!;
+
+      expect(() => {
+        VariableDeclHelper.generateConstructorDecl(varDecl, argListCtx, {
+          generateType: () => "MAX31856",
+        });
+      }).toThrow(/not declared/);
+    });
+
+    it("throws for non-const constructor argument", () => {
+      CodeGenState.setVariableTypeInfo("nonConstVar", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: false,
+        arrayDimensions: [],
+        isConst: false,
+      });
+
+      const varDecl = parseVarDecl("MAX31856 thermo(nonConstVar);");
+      const argListCtx = varDecl.constructorArgumentList()!;
+
+      expect(() => {
+        VariableDeclHelper.generateConstructorDecl(varDecl, argListCtx, {
+          generateType: () => "MAX31856",
+        });
+      }).toThrow(/must be const/);
+    });
+
+    it("tracks the variable in type registry", () => {
+      const varDecl = parseVarDecl("MAX31856 thermo(pinConst);");
+      const argListCtx = varDecl.constructorArgumentList()!;
+
+      VariableDeclHelper.generateConstructorDecl(varDecl, argListCtx, {
+        generateType: () => "MAX31856",
+      });
+
+      const typeInfo = CodeGenState.getVariableTypeInfo("thermo");
+      expect(typeInfo).toBeDefined();
+      expect(typeInfo!.baseType).toBe("MAX31856");
+      expect(typeInfo!.isExternalCppType).toBe(true);
+    });
+  });
+});

package/src/transpiler/output/codegen/helpers/types/IArgumentGeneratorCallbacks.ts

@@ -0,0 +1,32 @@
+/**
+ * Callbacks required for argument generation.
+ * These need CodeGenerator context and cannot be replaced with static state.
+ *
+ * Issue #794: Extracted from CodeGenerator to reduce file size.
+ */
+
+import * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
+
+interface IArgumentGeneratorCallbacks {
+  /** Determine if expression is an lvalue (member access or array access) */
+  getLvalueType: (ctx: Parser.ExpressionContext) => "member" | "array" | null;
+
+  /** Check if member access is to an array field */
+  getMemberAccessArrayStatus: (
+    ctx: Parser.ExpressionContext,
+  ) => "array" | "not-array" | "unknown";
+
+  /** Check if C++ mode needs temp variable for type conversion */
+  needsCppMemberConversion: (
+    ctx: Parser.ExpressionContext,
+    targetType?: string,
+  ) => boolean;
+
+  /** Check if expression is subscript access on a string variable */
+  isStringSubscriptAccess: (ctx: Parser.ExpressionContext) => boolean;
+
+  /** Generate expression code */
+  generateExpression: (ctx: Parser.ExpressionContext) => string;
+}
+
+export default IArgumentGeneratorCallbacks;