c-next 0.1.69 → 0.1.71

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

@@ -246,7 +246,7 @@ describe("StringDeclHelper", () => {
       expect(result.handled).toBe(true);
       expect(result.code).toBe('const char greeting[6] = "Hello";');
       expect(requireStringInclude).toHaveBeenCalled();
-      expect(CodeGenState.typeRegistry.get("greeting")).toMatchObject({
+      expect(CodeGenState.getVariableTypeInfo("greeting")).toMatchObject({
         baseType: "char",
         isString: true,
         stringCapacity: 5,
@@ -821,9 +821,9 @@ describe("StringDeclHelper", () => {
       expect(result.handled).toBe(true);
       expect(result.code).toContain("[2]"); // Inferred size
       expect(result.code).toContain("[11]"); // capacity + 1
-      expect(CodeGenState.typeRegistry.get("labels")?.arrayDimensions).toEqual([
-        2, 11,
-      ]);
+      expect(
+        CodeGenState.getVariableTypeInfo("labels")?.arrayDimensions,
+      ).toEqual([2, 11]);
     });
 
     it("generates string array without initializer (zero-init)", () => {

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

@@ -0,0 +1,269 @@
+/**
+ * Unit tests for StringOperationsHelper
+ *
+ * Tests string operation detection and extraction.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import StringOperationsHelper from "../StringOperationsHelper.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 an expression from source code.
+ */
+function parseExpression(source: string): Parser.ExpressionContext {
+  // Wrap expression in a variable declaration to get valid syntax
+  const fullSource = `u8 x <- ${source};`;
+  const result = CNextSourceParser.parse(fullSource);
+  const decl = result.tree.declaration(0);
+  const varDecl = decl?.variableDeclaration();
+  const expr = varDecl?.expression();
+  if (!expr) {
+    throw new Error(`Failed to parse expression from: ${source}`);
+  }
+  return expr;
+}
+
+describe("StringOperationsHelper", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  // ========================================================================
+  // getStringExprCapacity
+  // ========================================================================
+
+  describe("getStringExprCapacity", () => {
+    it("returns literal length for string literal", () => {
+      const capacity = StringOperationsHelper.getStringExprCapacity('"hello"');
+      expect(capacity).toBe(5);
+    });
+
+    it("returns literal length for empty string", () => {
+      const capacity = StringOperationsHelper.getStringExprCapacity('""');
+      expect(capacity).toBe(0);
+    });
+
+    it("returns null for non-string expression", () => {
+      const capacity = StringOperationsHelper.getStringExprCapacity("123");
+      expect(capacity).toBeNull();
+    });
+
+    it("returns capacity from type registry for string variable", () => {
+      CodeGenState.setVariableTypeInfo("myStr", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: true,
+        arrayDimensions: [33],
+        isConst: false,
+        isString: true,
+        stringCapacity: 32,
+      });
+
+      const capacity = StringOperationsHelper.getStringExprCapacity("myStr");
+      expect(capacity).toBe(32);
+    });
+
+    it("returns null for non-string variable", () => {
+      CodeGenState.setVariableTypeInfo("myInt", {
+        baseType: "u32",
+        bitWidth: 32,
+        isArray: false,
+        arrayDimensions: [],
+        isConst: false,
+      });
+
+      const capacity = StringOperationsHelper.getStringExprCapacity("myInt");
+      expect(capacity).toBeNull();
+    });
+
+    it("returns null for unknown variable", () => {
+      const capacity =
+        StringOperationsHelper.getStringExprCapacity("unknownVar");
+      expect(capacity).toBeNull();
+    });
+
+    it("returns null for complex expression", () => {
+      const capacity = StringOperationsHelper.getStringExprCapacity("a + b");
+      expect(capacity).toBeNull();
+    });
+  });
+
+  // ========================================================================
+  // getStringConcatOperands
+  // ========================================================================
+
+  describe("getStringConcatOperands", () => {
+    beforeEach(() => {
+      // Set up string variables for concatenation tests
+      CodeGenState.setVariableTypeInfo("str1", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: true,
+        arrayDimensions: [33],
+        isConst: false,
+        isString: true,
+        stringCapacity: 32,
+      });
+      CodeGenState.setVariableTypeInfo("str2", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: true,
+        arrayDimensions: [17],
+        isConst: false,
+        isString: true,
+        stringCapacity: 16,
+      });
+    });
+
+    it("returns operands for string variable concatenation", () => {
+      const expr = parseExpression("str1 + str2");
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+
+      expect(result).not.toBeNull();
+      expect(result!.left).toBe("str1");
+      expect(result!.right).toBe("str2");
+      expect(result!.leftCapacity).toBe(32);
+      expect(result!.rightCapacity).toBe(16);
+    });
+
+    it("returns operands for string literal concatenation", () => {
+      const expr = parseExpression('"hello" + "world"');
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+
+      expect(result).not.toBeNull();
+      expect(result!.left).toBe('"hello"');
+      expect(result!.right).toBe('"world"');
+      expect(result!.leftCapacity).toBe(5);
+      expect(result!.rightCapacity).toBe(5);
+    });
+
+    it("returns null for integer addition", () => {
+      const expr = parseExpression("1 + 2");
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+      expect(result).toBeNull();
+    });
+
+    it("returns null for subtraction", () => {
+      const expr = parseExpression("str1 - str2");
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+      expect(result).toBeNull();
+    });
+
+    it("returns null for mixed string/non-string", () => {
+      const expr = parseExpression("str1 + 5");
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+      expect(result).toBeNull();
+    });
+
+    it("returns null for more than 2 operands", () => {
+      // This expression has 3 operands at the additive level
+      const expr = parseExpression("str1 + str2 + str1");
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+      // With 3 operands, it should return null (simple concat only)
+      expect(result).toBeNull();
+    });
+
+    it("handles string literal containing hyphen correctly", () => {
+      // Regression test: ensure hyphen in string literal doesn't
+      // falsely trigger subtraction detection
+      const expr = parseExpression('str1 + "hello-world"');
+      const result = StringOperationsHelper.getStringConcatOperands(expr);
+
+      expect(result).not.toBeNull();
+      expect(result!.left).toBe("str1");
+      expect(result!.right).toBe('"hello-world"');
+      expect(result!.leftCapacity).toBe(32);
+      expect(result!.rightCapacity).toBe(11); // "hello-world" is 11 chars
+    });
+  });
+
+  // ========================================================================
+  // getSubstringOperands
+  // ========================================================================
+
+  describe("getSubstringOperands", () => {
+    beforeEach(() => {
+      CodeGenState.setVariableTypeInfo("myStr", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: true,
+        arrayDimensions: [65],
+        isConst: false,
+        isString: true,
+        stringCapacity: 64,
+      });
+    });
+
+    it("returns operands for substring [start, length] pattern", () => {
+      const expr = parseExpression("myStr[0, 5]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => ctx.getText(),
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.source).toBe("myStr");
+      expect(result!.start).toBe("0");
+      expect(result!.length).toBe("5");
+      expect(result!.sourceCapacity).toBe(64);
+    });
+
+    it("returns operands for single-char access [index] pattern", () => {
+      const expr = parseExpression("myStr[3]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => ctx.getText(),
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.source).toBe("myStr");
+      expect(result!.start).toBe("3");
+      expect(result!.length).toBe("1");
+      expect(result!.sourceCapacity).toBe(64);
+    });
+
+    it("returns null for non-string variable", () => {
+      CodeGenState.setVariableTypeInfo("myArray", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: true,
+        arrayDimensions: [10],
+        isConst: false,
+      });
+
+      const expr = parseExpression("myArray[0, 5]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBeNull();
+    });
+
+    it("returns null for unknown variable", () => {
+      const expr = parseExpression("unknown[0, 5]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBeNull();
+    });
+
+    it("returns null for function call expression", () => {
+      const expr = parseExpression("getStr()[0, 5]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => ctx.getText(),
+      });
+      expect(result).toBeNull();
+    });
+
+    it("uses callback to generate expression code", () => {
+      const expr = parseExpression("myStr[idx, len]");
+      const result = StringOperationsHelper.getSubstringOperands(expr, {
+        generateExpression: (ctx) => `generated_${ctx.getText()}`,
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.start).toBe("generated_idx");
+      expect(result!.length).toBe("generated_len");
+    });
+  });
+});

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

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "vitest";
 import SymbolLookupHelper from "../SymbolLookupHelper.js";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind.js";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage.js";
 
 describe("SymbolLookupHelper", () => {
@@ -10,7 +9,7 @@ describe("SymbolLookupHelper", () => {
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           null,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(false);
@@ -21,7 +20,7 @@ describe("SymbolLookupHelper", () => {
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           undefined,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(false);
@@ -35,7 +34,7 @@ describe("SymbolLookupHelper", () => {
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           mockTable,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(false);
@@ -44,14 +43,14 @@ describe("SymbolLookupHelper", () => {
     it("returns false when kind doesn't match", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Variable, sourceLanguage: ESourceLanguage.C },
+          { kind: "variable" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           mockTable,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(false);
@@ -60,14 +59,14 @@ describe("SymbolLookupHelper", () => {
     it("returns false when language doesn't match", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           mockTable,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(false);
@@ -76,14 +75,14 @@ describe("SymbolLookupHelper", () => {
     it("returns true when matching symbol found", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.C },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           mockTable,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C],
         ),
       ).toBe(true);
@@ -92,14 +91,14 @@ describe("SymbolLookupHelper", () => {
     it("returns true when any language in list matches", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(
         SymbolLookupHelper.hasSymbolWithKindAndLanguage(
           mockTable,
           "test",
-          ESymbolKind.Function,
+          "function",
           [ESourceLanguage.C, ESourceLanguage.Cpp],
         ),
       ).toBe(true);
@@ -114,7 +113,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C++ enum", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Enum, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "enum" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppEnumClass(mockTable, "MyEnum")).toBe(true);
@@ -123,7 +122,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C enum", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Enum, sourceLanguage: ESourceLanguage.C },
+          { kind: "enum" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(SymbolLookupHelper.isCppEnumClass(mockTable, "MyEnum")).toBe(
@@ -142,7 +141,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.C },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(SymbolLookupHelper.isExternalCFunction(mockTable, "myFunc")).toBe(
@@ -153,7 +152,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C++ function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isExternalCFunction(mockTable, "myFunc")).toBe(
@@ -164,7 +163,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C-Next function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(SymbolLookupHelper.isExternalCFunction(mockTable, "myFunc")).toBe(
@@ -186,7 +185,7 @@ describe("SymbolLookupHelper", () => {
       const mockTable = {
         getOverloads: () => [
           {
-            kind: ESymbolKind.Namespace,
+            kind: "namespace" as const,
             sourceLanguage: ESourceLanguage.CNext,
           },
         ],
@@ -197,7 +196,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false when no namespace symbol", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(SymbolLookupHelper.isNamespace(mockTable, "MyNS")).toBe(false);
@@ -216,7 +215,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C++ struct", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Struct, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "struct" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "MyStruct")).toBe(true);
@@ -225,7 +224,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C++ class", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Class, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "class" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "MyClass")).toBe(true);
@@ -234,7 +233,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C++ type alias", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Type, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "type" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "MyType")).toBe(true);
@@ -243,7 +242,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C struct", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Struct, sourceLanguage: ESourceLanguage.C },
+          { kind: "struct" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "MyStruct")).toBe(false);
@@ -252,7 +251,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C++ function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "myFunc")).toBe(false);
@@ -261,7 +260,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C++ enum", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Enum, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "enum" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCppType(mockTable, "MyEnum")).toBe(false);
@@ -282,7 +281,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true for C-Next function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(SymbolLookupHelper.isCNextFunction(mockTable, "myFunc")).toBe(
@@ -293,7 +292,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.C },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(SymbolLookupHelper.isCNextFunction(mockTable, "myFunc")).toBe(
@@ -304,7 +303,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C++ function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.Cpp },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.Cpp },
         ],
       };
       expect(SymbolLookupHelper.isCNextFunction(mockTable, "myFunc")).toBe(
@@ -315,7 +314,7 @@ describe("SymbolLookupHelper", () => {
     it("returns false for C-Next struct", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Struct, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "struct" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(SymbolLookupHelper.isCNextFunction(mockTable, "MyStruct")).toBe(
@@ -339,7 +338,7 @@ describe("SymbolLookupHelper", () => {
     it("returns true when in symbol table as C-Next function", () => {
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.CNext },
         ],
       };
       expect(
@@ -374,7 +373,7 @@ describe("SymbolLookupHelper", () => {
       const knownFunctions = new Set(["myFunc"]);
       const mockTable = {
         getOverloads: () => [
-          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.C },
+          { kind: "function" as const, sourceLanguage: ESourceLanguage.C },
         ],
       };
       expect(
@@ -399,7 +398,7 @@ describe("SymbolLookupHelper", () => {
       const mockTable = {
         getOverloads: () => [
           {
-            kind: ESymbolKind.Namespace,
+            kind: "namespace" as const,
             sourceLanguage: ESourceLanguage.CNext,
           },
         ],