@nudojs/cli 0.1.0 → 0.2.0

package/src/__tests__/evaluator-loops.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
+import { evaluateProgram, setSampleCount } from "../evaluator.ts";
+import { parse } from "@nudojs/parser";
+import type { TypeValue } from "@nudojs/core";
+
+function evalCode(code: string): TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  return evaluateProgram(ast, env);
+}
+
+function evalWith(code: string, bindings: Record<string, TypeValue>): TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  for (const [k, v] of Object.entries(bindings)) env.bind(k, v);
+  return evaluateProgram(ast, env);
+}
+
+describe("ForStatement", () => {
+  beforeEach(() => setSampleCount(3));
+
+  it("evaluates simple for loop with literal bounds", () => {
+    const result = evalCode(`
+      let sum = 0;
+      for (let i = 0; i < 3; i++) {
+        sum = sum + i;
+      }
+      sum
+    `);
+    expect(typeValueEquals(result, T.literal(3))).toBe(true);
+  });
+
+  it("evaluates for loop that returns early", () => {
+    const result = evalCode(`
+      function f() {
+        for (let i = 0; i < 10; i++) {
+          if (i === 2) return i;
+        }
+        return -1;
+      }
+    `);
+    // f is a function; we just check it's defined
+    expect(result).toBeDefined();
+  });
+
+  it("for loop with abstract bounds widens variables", () => {
+    const result = evalWith(`
+      let sum = 0;
+      for (let i = 0; i < n; i++) {
+        sum = sum + i;
+      }
+      sum
+    `, { n: T.number });
+    // After widening, sum should be T.number
+    expect(typeValueEquals(result, T.number)).toBe(true);
+  });
+
+  it("for loop variable accessible after loop", () => {
+    const result = evalCode(`
+      let x = 0;
+      for (let i = 0; i < 2; i++) {
+        x = x + 1;
+      }
+      x
+    `);
+    expect(typeValueEquals(result, T.literal(2))).toBe(true);
+  });
+});
+
+describe("WhileStatement", () => {
+  beforeEach(() => setSampleCount(3));
+
+  it("evaluates while loop with literal false condition", () => {
+    const result = evalCode(`
+      let x = 0;
+      while (false) {
+        x = 1;
+      }
+      x
+    `);
+    expect(typeValueEquals(result, T.literal(0))).toBe(true);
+  });
+
+  it("evaluates while loop with concrete iterations", () => {
+    const result = evalCode(`
+      let x = 0;
+      let i = 0;
+      while (i < 3) {
+        x = x + 1;
+        i = i + 1;
+      }
+      x
+    `);
+    expect(typeValueEquals(result, T.literal(3))).toBe(true);
+  });
+
+  it("while loop with abstract condition", () => {
+    const result = evalWith(`
+      let count = 0;
+      while (cond) {
+        count = count + 1;
+      }
+      count
+    `, { cond: T.boolean });
+    // After sample iterations, count should be widened to number
+    expect(typeValueEquals(result, T.number) || result.kind === "literal").toBe(true);
+  });
+});
+
+describe("DoWhileStatement", () => {
+  beforeEach(() => setSampleCount(3));
+
+  it("executes body at least once", () => {
+    const result = evalCode(`
+      let x = 0;
+      do {
+        x = x + 1;
+      } while (false);
+      x
+    `);
+    expect(typeValueEquals(result, T.literal(1))).toBe(true);
+  });
+
+  it("evaluates do-while with multiple iterations", () => {
+    const result = evalCode(`
+      let x = 0;
+      let i = 0;
+      do {
+        x = x + 1;
+        i = i + 1;
+      } while (i < 3);
+      x
+    `);
+    expect(typeValueEquals(result, T.literal(3))).toBe(true);
+  });
+});
+
+describe("@nudo:sample integration", () => {
+  it("respects custom sample count", () => {
+    setSampleCount(5);
+    const result = evalCode(`
+      let sum = 0;
+      for (let i = 0; i < 5; i++) {
+        sum = sum + i;
+      }
+      sum
+    `);
+    expect(typeValueEquals(result, T.literal(10))).toBe(true);
+  });
+
+  it("default sample count is 3", () => {
+    setSampleCount(3);
+    const result = evalCode(`
+      let sum = 0;
+      for (let i = 0; i < 3; i++) {
+        sum = sum + i;
+      }
+      sum
+    `);
+    expect(typeValueEquals(result, T.literal(3))).toBe(true);
+  });
+});

package/src/__tests__/evaluator-refined.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals, typeValueToString, isSubtypeOf } from "@nudojs/core";
+import { isTemplate, getTemplateParts, isRange, getRangeMeta } from "@nudojs/core";
+import { evaluate, evaluateProgram } from "../evaluator.ts";
+import { createEnvironment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+
+function evalExpr(code: string): import("@nudojs/core").TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  return evaluateProgram(ast, env);
+}
+
+function evalWithBindings(code: string, bindings: Record<string, import("@nudojs/core").TypeValue>): import("@nudojs/core").TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  for (const [k, v] of Object.entries(bindings)) {
+    env.bind(k, v);
+  }
+  return evaluateProgram(ast, env);
+}
+
+describe("Template Literal Evaluation", () => {
+  it("all-literal template produces literal", () => {
+    const result = evalExpr("`hello world`");
+    expect(typeValueEquals(result, T.literal("hello world"))).toBe(true);
+  });
+
+  it("template with abstract expression produces template type", () => {
+    const result = evalWithBindings("`xy${x}`", { x: T.string });
+    expect(isTemplate(result)).toBe(true);
+    expect(typeValueToString(result)).toBe("`xy${string}`");
+  });
+
+  it("template with multiple parts", () => {
+    const result = evalWithBindings("`${x}!`", { x: T.string });
+    expect(isTemplate(result)).toBe(true);
+    expect(typeValueToString(result)).toBe("`${string}!`");
+  });
+
+  it("string concatenation with + produces template", () => {
+    const result = evalWithBindings('"xy" + x', { x: T.string });
+    expect(isTemplate(result)).toBe(true);
+    expect(typeValueToString(result)).toBe("`xy${string}`");
+  });
+
+  it("chained concatenation produces template", () => {
+    const result = evalWithBindings('"x" + x + "!"', { x: T.string });
+    expect(isTemplate(result)).toBe(true);
+    expect(typeValueToString(result)).toBe("`x${string}!`");
+  });
+});
+
+describe("Template Method Dispatch", () => {
+  it("startsWith on template with known prefix returns true", () => {
+    const result = evalWithBindings(
+      'const s = "xy" + x; s.startsWith("x")',
+      { x: T.string },
+    );
+    // The evaluateMethodCall should dispatch to template's startsWith
+    // and return T.literal(true)
+    // Note: this requires string method support in evaluateMethodCall
+    // which we add in 6.1. For now, refined dispatch handles it.
+    if (result.kind === "literal") {
+      expect(result.value).toBe(true);
+    }
+  });
+});
+
+describe("Range Narrowing", () => {
+  it("x >= 0 narrows to range in true branch", () => {
+    const code = `
+      function f(x) {
+        if (x >= 0) {
+          return x;
+        }
+        return x;
+      }
+    `;
+    const ast = parse(code);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+    const fn = env.lookup("f");
+    expect(fn.kind).toBe("function");
+  });
+
+  it("range comparison produces correct results", () => {
+    const result = evalWithBindings(
+      'const r = x >= 0 ? x : 0; r',
+      { x: T.number },
+    );
+    // In the true branch, x is narrowed to range(min:0)
+    // In the false branch, result is T.literal(0)
+    // Union of both
+    expect(result).toBeDefined();
+  });
+});
+
+describe("User-defined Refined Types", () => {
+  it("refined type with custom ops", () => {
+    const odd = T.refine(T.number, {
+      name: "odd",
+      meta: {},
+      ops: {
+        "%"(self, other) {
+          if (other.kind === "literal" && other.value === 2) return T.literal(1);
+          return undefined;
+        },
+      },
+    });
+
+    const result = evalWithBindings("x % 2", { x: odd });
+    expect(typeValueEquals(result, T.literal(1))).toBe(true);
+  });
+
+  it("refined type falls back to base for undefined ops", () => {
+    const odd = T.refine(T.number, { name: "odd", meta: {} });
+    const result = evalWithBindings("x + 1", { x: odd });
+    expect(typeValueEquals(result, T.number)).toBe(true);
+  });
+});

package/src/__tests__/evaluator-string-methods.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals, createEnvironment } from "@nudojs/core";
+import { evaluateProgram } from "../evaluator.ts";
+import { parse } from "@nudojs/parser";
+import type { TypeValue } from "@nudojs/core";
+
+function evalExpr(code: string): TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  return evaluateProgram(ast, env);
+}
+
+function evalWith(code: string, bindings: Record<string, TypeValue>): TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  for (const [k, v] of Object.entries(bindings)) env.bind(k, v);
+  return evaluateProgram(ast, env);
+}
+
+describe("String methods - literal receiver", () => {
+  it("toUpperCase", () => {
+    expect(typeValueEquals(evalExpr('"hello".toUpperCase()'), T.literal("HELLO"))).toBe(true);
+  });
+
+  it("toLowerCase", () => {
+    expect(typeValueEquals(evalExpr('"HELLO".toLowerCase()'), T.literal("hello"))).toBe(true);
+  });
+
+  it("trim", () => {
+    expect(typeValueEquals(evalExpr('"  hi  ".trim()'), T.literal("hi"))).toBe(true);
+  });
+
+  it("trimStart", () => {
+    expect(typeValueEquals(evalExpr('"  hi".trimStart()'), T.literal("hi"))).toBe(true);
+  });
+
+  it("trimEnd", () => {
+    expect(typeValueEquals(evalExpr('"hi  ".trimEnd()'), T.literal("hi"))).toBe(true);
+  });
+
+  it("charAt", () => {
+    expect(typeValueEquals(evalExpr('"abc".charAt(1)'), T.literal("b"))).toBe(true);
+  });
+
+  it("charCodeAt", () => {
+    expect(typeValueEquals(evalExpr('"A".charCodeAt(0)'), T.literal(65))).toBe(true);
+  });
+
+  it("at", () => {
+    expect(typeValueEquals(evalExpr('"abc".at(-1)'), T.literal("c"))).toBe(true);
+  });
+
+  it("startsWith", () => {
+    expect(typeValueEquals(evalExpr('"hello".startsWith("he")'), T.literal(true))).toBe(true);
+    expect(typeValueEquals(evalExpr('"hello".startsWith("lo")'), T.literal(false))).toBe(true);
+  });
+
+  it("endsWith", () => {
+    expect(typeValueEquals(evalExpr('"hello".endsWith("lo")'), T.literal(true))).toBe(true);
+    expect(typeValueEquals(evalExpr('"hello".endsWith("he")'), T.literal(false))).toBe(true);
+  });
+
+  it("includes", () => {
+    expect(typeValueEquals(evalExpr('"hello".includes("ell")'), T.literal(true))).toBe(true);
+    expect(typeValueEquals(evalExpr('"hello".includes("xyz")'), T.literal(false))).toBe(true);
+  });
+
+  it("indexOf", () => {
+    expect(typeValueEquals(evalExpr('"hello".indexOf("l")'), T.literal(2))).toBe(true);
+    expect(typeValueEquals(evalExpr('"hello".indexOf("z")'), T.literal(-1))).toBe(true);
+  });
+
+  it("lastIndexOf", () => {
+    expect(typeValueEquals(evalExpr('"hello".lastIndexOf("l")'), T.literal(3))).toBe(true);
+  });
+
+  it("slice", () => {
+    expect(typeValueEquals(evalExpr('"hello".slice(1, 3)'), T.literal("el"))).toBe(true);
+    expect(typeValueEquals(evalExpr('"hello".slice(2)'), T.literal("llo"))).toBe(true);
+  });
+
+  it("substring", () => {
+    expect(typeValueEquals(evalExpr('"hello".substring(1, 4)'), T.literal("ell"))).toBe(true);
+  });
+
+  it("split", () => {
+    const result = evalExpr('"a,b,c".split(",")');
+    expect(result.kind).toBe("tuple");
+    if (result.kind === "tuple") {
+      expect(result.elements.length).toBe(3);
+      expect(typeValueEquals(result.elements[0], T.literal("a"))).toBe(true);
+      expect(typeValueEquals(result.elements[1], T.literal("b"))).toBe(true);
+      expect(typeValueEquals(result.elements[2], T.literal("c"))).toBe(true);
+    }
+  });
+
+  it("replace", () => {
+    expect(typeValueEquals(evalExpr('"hello".replace("l", "r")'), T.literal("herlo"))).toBe(true);
+  });
+
+  it("replaceAll", () => {
+    expect(typeValueEquals(evalExpr('"hello".replaceAll("l", "r")'), T.literal("herro"))).toBe(true);
+  });
+
+  it("repeat", () => {
+    expect(typeValueEquals(evalExpr('"ab".repeat(3)'), T.literal("ababab"))).toBe(true);
+  });
+
+  it("padStart", () => {
+    expect(typeValueEquals(evalExpr('"5".padStart(3, "0")'), T.literal("005"))).toBe(true);
+  });
+
+  it("padEnd", () => {
+    expect(typeValueEquals(evalExpr('"5".padEnd(3, "0")'), T.literal("500"))).toBe(true);
+  });
+});
+
+describe("String methods - abstract receiver", () => {
+  it("toUpperCase returns string", () => {
+    const result = evalWith("x.toUpperCase()", { x: T.string });
+    expect(typeValueEquals(result, T.string)).toBe(true);
+  });
+
+  it("startsWith returns boolean", () => {
+    const result = evalWith('x.startsWith("a")', { x: T.string });
+    expect(typeValueEquals(result, T.boolean)).toBe(true);
+  });
+
+  it("indexOf returns number", () => {
+    const result = evalWith('x.indexOf("a")', { x: T.string });
+    expect(typeValueEquals(result, T.number)).toBe(true);
+  });
+
+  it("split returns string[]", () => {
+    const result = evalWith('x.split(",")', { x: T.string });
+    expect(result.kind).toBe("array");
+    if (result.kind === "array") {
+      expect(typeValueEquals(result.element, T.string)).toBe(true);
+    }
+  });
+
+  it("charAt returns string", () => {
+    const result = evalWith("x.charAt(0)", { x: T.string });
+    expect(typeValueEquals(result, T.string)).toBe(true);
+  });
+
+  it("slice returns string", () => {
+    const result = evalWith("x.slice(1)", { x: T.string });
+    expect(typeValueEquals(result, T.string)).toBe(true);
+  });
+});

package/src/evaluator-api.ts

@@ -9,6 +9,8 @@ export {
   getUnreachableRanges,
   resetUnreachableRanges,
   setNodeTypeCollector,
+  setSampleCount,
+  setMaxConcreteIter,
 } from "./evaluator.ts";
 
 export { narrow } from "./narrowing.ts";