c-next 0.1.61 → 0.1.63

package/src/transpiler/output/codegen/analysis/__tests__/StringLengthCounter.test.ts

@@ -3,10 +3,10 @@
  * Issue #644: strlen caching optimization
  */
 
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import StringLengthCounter from "../StringLengthCounter";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser";
-import TTypeInfo from "../../types/TTypeInfo";
+import CodeGenState from "../../CodeGenState";
 
 /**
  * Parse a C-Next expression and return the expression context.
@@ -32,122 +32,102 @@ function parseBlock(statements: string) {
 }
 
 describe("StringLengthCounter", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("countExpression", () => {
     it("counts single .length access on string variable", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "myStr") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 64,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("myStr", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 64,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("myStr.length");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("myStr")).toBe(1);
     });
 
     it("counts multiple .length accesses on same variable", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "str") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 32,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("str", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 32,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       // Expression: str.length + str.length
       const expr = parseExpression("str.length + str.length");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("str")).toBe(2);
     });
 
     it("counts .length accesses on different string variables", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "a" || name === "b") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 16,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("a", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 16,
+      });
+      CodeGenState.typeRegistry.set("b", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 16,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("a.length + b.length");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("a")).toBe(1);
       expect(counts.get("b")).toBe(1);
     });
 
     it("ignores .length on non-string variables", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "arr") {
-          return {
-            baseType: "u8",
-            bitWidth: 8,
-            isArray: true,
-            isConst: false,
-            arrayDimensions: [10],
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("arr", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: true,
+        isConst: false,
+        arrayDimensions: [10],
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("arr.length");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("arr")).toBeUndefined();
     });
 
     it("ignores other member accesses", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "obj") {
-          return {
-            baseType: "MyStruct",
-            bitWidth: 32,
-            isArray: false,
-            isConst: false,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("obj", {
+        baseType: "MyStruct",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("obj.value");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.size).toBe(0);
     });
 
     it("handles unknown variables gracefully", () => {
-      const typeRegistry = vi.fn((): TTypeInfo | undefined => undefined);
-
-      const counter = new StringLengthCounter(typeRegistry);
+      // No type registered for "unknown"
       const expr = parseExpression("unknown.length");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.size).toBe(0);
     });
@@ -155,51 +135,39 @@ describe("StringLengthCounter", () => {
 
   describe("countBlock", () => {
     it("counts .length accesses across multiple statements", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "msg") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 128,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("msg", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 128,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const block = parseBlock(`
         u32 len <- msg.length;
         u32 doubled <- msg.length * 2;
       `);
-      const counts = counter.countBlock(block);
+      const counts = StringLengthCounter.countBlock(block);
 
       expect(counts.get("msg")).toBe(2);
     });
 
     it("counts .length in assignment statements", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "text") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 64,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("text", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 64,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const block = parseBlock(`
         u32 x;
         x <- text.length;
       `);
-      const counts = counter.countBlock(block);
+      const counts = StringLengthCounter.countBlock(block);
 
       expect(counts.get("text")).toBe(1);
     });
@@ -207,21 +175,22 @@ describe("StringLengthCounter", () => {
 
   describe("countBlockInto", () => {
     it("adds counts to existing map", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "s1" || name === "s2") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 32,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("s1", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 32,
+      });
+      CodeGenState.typeRegistry.set("s2", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 32,
       });
-
-      const counter = new StringLengthCounter(typeRegistry);
 
       // Pre-populate counts
       const counts = new Map<string, number>();
@@ -231,7 +200,7 @@ describe("StringLengthCounter", () => {
         u32 a <- s1.length;
         u32 b <- s2.length;
       `);
-      counter.countBlockInto(block, counts);
+      StringLengthCounter.countBlockInto(block, counts);
 
       expect(counts.get("s1")).toBe(2); // 1 existing + 1 new
       expect(counts.get("s2")).toBe(1);
@@ -240,45 +209,33 @@ describe("StringLengthCounter", () => {
 
   describe("nested expressions", () => {
     it("counts .length in ternary expressions", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "str") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 64,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("str", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 64,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("(str.length > 0) ? str.length : 0");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("str")).toBe(2);
     });
 
     it("counts .length in comparison expressions", () => {
-      const typeRegistry = vi.fn((name: string): TTypeInfo | undefined => {
-        if (name === "name") {
-          return {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-            stringCapacity: 50,
-          };
-        }
-        return undefined;
+      CodeGenState.typeRegistry.set("name", {
+        baseType: "char",
+        bitWidth: 8,
+        isArray: false,
+        isConst: false,
+        isString: true,
+        stringCapacity: 50,
       });
 
-      const counter = new StringLengthCounter(typeRegistry);
       const expr = parseExpression("name.length = 10");
-      const counts = counter.countExpression(expr);
+      const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("name")).toBe(1);
     });