c-next 0.1.69 → 0.1.71

package/src/transpiler/output/codegen/helpers/VariableDeclarationFormatter.ts

@@ -75,7 +75,7 @@ class VariableDeclarationFormatter {
    * @param dimensions - Array of dimension strings (e.g., ['10', '20'])
    * @returns Formatted dimensions (e.g., '[10][20]')
    */
-  static buildArrayDimensions(dimensions?: string[]): string {
+  static buildArrayDimensions(dimensions?: readonly string[]): string {
     if (!dimensions || dimensions.length === 0) {
       return "";
     }

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

@@ -0,0 +1,521 @@
+/**
+ * Unit tests for ArgumentGenerator
+ * Issue #794: Extract Argument Generator from CodeGenerator
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import ArgumentGenerator from "../ArgumentGenerator";
+import CodeGenState from "../../../../state/CodeGenState";
+import IArgumentGeneratorCallbacks from "../types/IArgumentGeneratorCallbacks";
+
+describe("ArgumentGenerator", () => {
+  // Mock callbacks that return predictable values
+  const createMockCallbacks = (
+    overrides: Partial<IArgumentGeneratorCallbacks> = {},
+  ): IArgumentGeneratorCallbacks => ({
+    getLvalueType: () => null,
+    getMemberAccessArrayStatus: () => "not-array",
+    needsCppMemberConversion: () => false,
+    isStringSubscriptAccess: () => false,
+    generateExpression: (ctx) => ctx.getText(),
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("handleIdentifierArg", () => {
+    describe("parameters", () => {
+      it("returns parameter name unchanged (already pointers)", () => {
+        CodeGenState.currentParameters.set("cfg", {
+          name: "cfg",
+          baseType: "Config",
+          isArray: false,
+          isStruct: true,
+          isConst: false,
+          isCallback: false,
+          isString: false,
+        });
+
+        const result = ArgumentGenerator.handleIdentifierArg("cfg");
+        expect(result).toBe("cfg");
+      });
+    });
+
+    describe("local arrays", () => {
+      it("returns array name unchanged (decay to pointers)", () => {
+        CodeGenState.localArrays.add("buffer");
+
+        const result = ArgumentGenerator.handleIdentifierArg("buffer");
+        expect(result).toBe("buffer");
+      });
+    });
+
+    describe("global arrays", () => {
+      it("returns global array name unchanged", () => {
+        CodeGenState.setVariableTypeInfo("globalArr", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+        });
+
+        const result = ArgumentGenerator.handleIdentifierArg("globalArr");
+        expect(result).toBe("globalArr");
+      });
+
+      it("adds & for global strings (char arrays passed by reference)", () => {
+        CodeGenState.cppMode = false;
+        CodeGenState.setVariableTypeInfo("name", {
+          baseType: "char",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+          isString: true,
+        });
+
+        const result = ArgumentGenerator.handleIdentifierArg("name");
+        expect(result).toBe("&name");
+      });
+    });
+
+    describe("scope members", () => {
+      it("prefixes scope member and adds & in C mode", () => {
+        CodeGenState.cppMode = false;
+        CodeGenState.currentScope = "LED";
+        CodeGenState.setScopeMembers("LED", new Set(["brightness"]));
+
+        const result = ArgumentGenerator.handleIdentifierArg("brightness");
+        expect(result).toBe("&LED_brightness");
+      });
+
+      it("prefixes scope member without & in C++ mode", () => {
+        CodeGenState.cppMode = true;
+        CodeGenState.currentScope = "LED";
+        CodeGenState.setScopeMembers("LED", new Set(["brightness"]));
+
+        const result = ArgumentGenerator.handleIdentifierArg("brightness");
+        expect(result).toBe("LED_brightness");
+      });
+    });
+
+    describe("local variables", () => {
+      it("adds & for local variable in C mode", () => {
+        CodeGenState.cppMode = false;
+
+        const result = ArgumentGenerator.handleIdentifierArg("value");
+        expect(result).toBe("&value");
+      });
+
+      it("returns local variable unchanged in C++ mode", () => {
+        CodeGenState.cppMode = true;
+
+        const result = ArgumentGenerator.handleIdentifierArg("value");
+        expect(result).toBe("value");
+      });
+    });
+  });
+
+  describe("handleRvalueArg", () => {
+    it("returns expression unchanged when no target type", () => {
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "42",
+      });
+
+      const result = ArgumentGenerator.handleRvalueArg(
+        null as never, // ctx not used in this path
+        undefined,
+        callbacks,
+      );
+      expect(result).toBe("42");
+    });
+
+    it("returns expression unchanged for void target type", () => {
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "doSomething()",
+      });
+
+      const result = ArgumentGenerator.handleRvalueArg(
+        null as never,
+        "void",
+        callbacks,
+      );
+      expect(result).toBe("doSomething()");
+    });
+
+    it("returns expression unchanged in C++ mode (rvalues bind to const T&)", () => {
+      CodeGenState.cppMode = true;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "42",
+      });
+
+      const result = ArgumentGenerator.handleRvalueArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("42");
+    });
+
+    it("wraps in compound literal for C mode", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "42",
+      });
+
+      const result = ArgumentGenerator.handleRvalueArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&(uint8_t){42}");
+    });
+
+    it("uses correct C type for compound literal", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "1000",
+      });
+
+      const result = ArgumentGenerator.handleRvalueArg(
+        null as never,
+        "i32",
+        callbacks,
+      );
+      expect(result).toBe("&(int32_t){1000}");
+    });
+  });
+
+  describe("createCppMemberConversionTemp", () => {
+    it("creates temp variable with static_cast in C++ mode", () => {
+      CodeGenState.cppMode = true;
+      CodeGenState.tempVarCounter = 0;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "cfg.value",
+      });
+
+      const result = ArgumentGenerator.createCppMemberConversionTemp(
+        null as never,
+        "u8",
+        callbacks,
+      );
+
+      expect(result).toBe("_cnx_tmp_0");
+      expect(CodeGenState.pendingTempDeclarations).toContain(
+        "uint8_t _cnx_tmp_0 = static_cast<uint8_t>(cfg.value);",
+      );
+      expect(CodeGenState.tempVarCounter).toBe(1);
+    });
+
+    it("increments temp counter for multiple temps", () => {
+      CodeGenState.cppMode = true;
+      CodeGenState.tempVarCounter = 5;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "x",
+      });
+
+      const result = ArgumentGenerator.createCppMemberConversionTemp(
+        null as never,
+        "i16",
+        callbacks,
+      );
+
+      expect(result).toBe("_cnx_tmp_5");
+      expect(CodeGenState.tempVarCounter).toBe(6);
+    });
+  });
+
+  describe("maybeCastStringSubscript", () => {
+    it("returns expr unchanged when no target type", () => {
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&buf[0]",
+        undefined,
+        callbacks,
+      );
+      expect(result).toBe("&buf[0]");
+    });
+
+    it("returns expr unchanged when not string subscript", () => {
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => false,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&arr[0]",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&arr[0]");
+    });
+
+    it("casts string subscript to integer pointer type in C mode", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&buf[0]",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("(uint8_t*)&buf[0]");
+    });
+
+    it("casts string subscript with reinterpret_cast in C++ mode", () => {
+      CodeGenState.cppMode = true;
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&buf[0]",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("reinterpret_cast<uint8_t*>(&buf[0])");
+    });
+
+    it("does not cast for float types", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&buf[0]",
+        "f32",
+        callbacks,
+      );
+      expect(result).toBe("&buf[0]");
+    });
+
+    it("does not cast for bool type", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.maybeCastStringSubscript(
+        null as never,
+        "&buf[0]",
+        "bool",
+        callbacks,
+      );
+      expect(result).toBe("&buf[0]");
+    });
+  });
+
+  describe("handleMemberAccessArg", () => {
+    it("returns expression unchanged for array member (no & needed)", () => {
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "array",
+        generateExpression: () => "result.data",
+      });
+
+      const result = ArgumentGenerator.handleMemberAccessArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("result.data");
+    });
+
+    it("creates temp for C++ conversion when needed", () => {
+      CodeGenState.cppMode = true;
+      CodeGenState.tempVarCounter = 0;
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "not-array",
+        needsCppMemberConversion: () => true,
+        generateExpression: () => "cfg.enabled",
+      });
+
+      const result = ArgumentGenerator.handleMemberAccessArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+
+      expect(result).toBe("_cnx_tmp_0");
+      expect(CodeGenState.pendingTempDeclarations).toHaveLength(1);
+    });
+
+    it("returns null for default lvalue handling", () => {
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "not-array",
+        needsCppMemberConversion: () => false,
+      });
+
+      const result = ArgumentGenerator.handleMemberAccessArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+      expect(result).toBeNull();
+    });
+
+    it("returns null when array status is unknown", () => {
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "unknown",
+        needsCppMemberConversion: () => false,
+      });
+
+      const result = ArgumentGenerator.handleMemberAccessArg(
+        null as never,
+        "u8",
+        callbacks,
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("handleLvalueArg", () => {
+    it("delegates to handleMemberAccessArg for member access", () => {
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "array",
+        generateExpression: () => "result.buffer",
+      });
+
+      const result = ArgumentGenerator.handleLvalueArg(
+        null as never,
+        "member",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("result.buffer");
+    });
+
+    it("generates expression with & for member when not array", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        getMemberAccessArrayStatus: () => "not-array",
+        needsCppMemberConversion: () => false,
+        generateExpression: () => "obj.field",
+      });
+
+      const result = ArgumentGenerator.handleLvalueArg(
+        null as never,
+        "member",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&obj.field");
+    });
+
+    it("handles array access with & and string subscript cast", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "buf[0]",
+        isStringSubscriptAccess: () => true,
+      });
+
+      const result = ArgumentGenerator.handleLvalueArg(
+        null as never,
+        "array",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("(uint8_t*)&buf[0]");
+    });
+
+    it("returns expression with & for array without string cast", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        generateExpression: () => "arr[i]",
+        isStringSubscriptAccess: () => false,
+      });
+
+      const result = ArgumentGenerator.handleLvalueArg(
+        null as never,
+        "array",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&arr[i]");
+    });
+  });
+
+  describe("generateArg (main dispatcher)", () => {
+    it("handles simple identifier", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        getLvalueType: () => null,
+      });
+
+      const result = ArgumentGenerator.generateArg(
+        null as never,
+        "value",
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&value");
+    });
+
+    it("handles parameter identifier", () => {
+      CodeGenState.currentParameters.set("cfg", {
+        name: "cfg",
+        baseType: "Config",
+        isArray: false,
+        isStruct: true,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+      const callbacks = createMockCallbacks({
+        getLvalueType: () => null,
+      });
+
+      const result = ArgumentGenerator.generateArg(
+        null as never,
+        "cfg",
+        "Config",
+        callbacks,
+      );
+      expect(result).toBe("cfg");
+    });
+
+    it("handles lvalue expressions", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        getLvalueType: () => "member",
+        getMemberAccessArrayStatus: () => "not-array",
+        needsCppMemberConversion: () => false,
+        generateExpression: () => "obj.field",
+      });
+
+      const result = ArgumentGenerator.generateArg(
+        null as never,
+        null, // no simple identifier
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&obj.field");
+    });
+
+    it("handles rvalue expressions", () => {
+      CodeGenState.cppMode = false;
+      const callbacks = createMockCallbacks({
+        getLvalueType: () => null,
+        generateExpression: () => "42",
+      });
+
+      const result = ArgumentGenerator.generateArg(
+        null as never,
+        null, // no simple identifier
+        "u8",
+        callbacks,
+      );
+      expect(result).toBe("&(uint8_t){42}");
+    });
+  });
+});

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

@@ -56,7 +56,7 @@ describe("ArrayInitHelper", () => {
 
     it("handles size inference with array initializer", () => {
       // Add existing type to registry
-      CodeGenState.typeRegistry.set("arr", {
+      CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,

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

@@ -68,7 +68,7 @@ describe("AssignmentExpectedTypeResolver", () => {
   describe("resolve()", () => {
     describe("simple identifier", () => {
       it("should resolve expected type for known variable", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u32",
           bitWidth: 32,
           isArray: false,
@@ -87,7 +87,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should use specified overflow behavior", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u8",
           bitWidth: 8,
           isArray: false,
@@ -113,7 +113,7 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("member access", () => {
       it("should resolve expected type for struct field", () => {
-        CodeGenState.typeRegistry.set("config", {
+        CodeGenState.setVariableTypeInfo("config", {
           baseType: "Config",
           bitWidth: 0,
           isArray: false,
@@ -128,7 +128,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should walk nested struct chain", () => {
-        CodeGenState.typeRegistry.set("app", {
+        CodeGenState.setVariableTypeInfo("app", {
           baseType: "App",
           bitWidth: 0,
           isArray: false,
@@ -144,7 +144,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should return null for non-struct root", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u32",
           bitWidth: 32,
           isArray: false,
@@ -158,7 +158,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should return null for unknown field", () => {
-        CodeGenState.typeRegistry.set("config", {
+        CodeGenState.setVariableTypeInfo("config", {
           baseType: "Config",
           bitWidth: 0,
           isArray: false,
@@ -175,7 +175,7 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("array access", () => {
       it("should return null for array access target", () => {
-        CodeGenState.typeRegistry.set("arr", {
+        CodeGenState.setVariableTypeInfo("arr", {
           baseType: "u32",
           bitWidth: 32,
           isArray: true,

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

@@ -141,7 +141,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate enum assignment for enum-typed variable", () => {
-      CodeGenState.typeRegistry.set("status", {
+      CodeGenState.setVariableTypeInfo("status", {
         baseType: "Status",
         bitWidth: 8,
         isArray: false,
@@ -165,7 +165,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate integer assignment for integer-typed variable", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -190,7 +190,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should pass isCompound flag to integer validation", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -215,7 +215,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should rethrow validation error with line:column prefix", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,
@@ -240,7 +240,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should handle non-Error validation exceptions", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,
@@ -298,7 +298,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should check array bounds for array with dimensions", () => {
-      CodeGenState.typeRegistry.set("arr", {
+      CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isConst: false,
@@ -374,7 +374,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate callback assignment for callback field", () => {
-      CodeGenState.typeRegistry.set("handler", {
+      CodeGenState.setVariableTypeInfo("handler", {
         baseType: "Handler",
         bitWidth: 0,
         isArray: false,

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

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "vitest";
 import CppConstructorHelper from "../CppConstructorHelper.js";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind.js";
 
 describe("CppConstructorHelper", () => {
   describe("toQualifiedName", () => {
@@ -87,7 +86,7 @@ describe("CppConstructorHelper", () => {
 
     it("returns false when symbol is not a function", () => {
       const mockSymbolTable = {
-        getSymbol: () => ({ kind: ESymbolKind.Variable }),
+        getSymbol: () => ({ kind: "variable" as const }),
       };
       expect(
         CppConstructorHelper.hasConstructor("MyClass", mockSymbolTable),
@@ -98,7 +97,7 @@ describe("CppConstructorHelper", () => {
       const mockSymbolTable = {
         getSymbol: (name: string) => {
           if (name === "MyClass::MyClass") {
-            return { kind: ESymbolKind.Function };
+            return { kind: "function" as const };
           }
           return undefined;
         },
@@ -112,7 +111,7 @@ describe("CppConstructorHelper", () => {
       const mockSymbolTable = {
         getSymbol: (name: string) => {
           if (name === "TestNS::MyClass::MyClass") {
-            return { kind: ESymbolKind.Function };
+            return { kind: "function" as const };
           }
           return undefined;
         },
@@ -126,7 +125,7 @@ describe("CppConstructorHelper", () => {
       const mockSymbolTable = {
         getSymbol: (name: string) => {
           if (name === "TestNS::MyClass::MyClass") {
-            return { kind: ESymbolKind.Function };
+            return { kind: "function" as const };
           }
           return undefined;
         },