@nudojs/cli 0.2.0 → 0.2.1

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

@@ -66,6 +66,126 @@ describe("ForStatement", () => {
     `);
     expect(typeValueEquals(result, T.literal(2))).toBe(true);
   });
+
+  it("let loop variable gets a fresh binding per iteration for closures", () => {
+    // Real JS semantics: let creates a per-iteration scope, so each closure
+    // captures the value at its own iteration.
+    const result = evalCode(`
+      const fns = [];
+      for (let i = 0; i < 3; i++) {
+        fns.push(() => i);
+      }
+      [fns[0](), fns[1](), fns[2]()]
+    `);
+    expect(typeValueToString(result)).toBe("[0, 1, 2]");
+  });
+
+  it("var loop variable shares one binding across iterations for closures", () => {
+    // var keeps a single shared cell: every closure observes the final value.
+    const result = evalCode(`
+      const fns = [];
+      for (var i = 0; i < 3; i++) {
+        fns.push(() => i);
+      }
+      [fns[0](), fns[1](), fns[2]()]
+    `);
+    expect(typeValueToString(result)).toBe("[3, 3, 3]");
+  });
+
+  it("let loop closure sees body-side increments; loop still progresses", () => {
+    // Real JS: an assignment in the body targets the per-iteration binding
+    // the closure captured (node: fns[0]() === 1), unlike the update clause
+    // which runs outside it. No update clause here — the copy-back from the
+    // per-iteration binding must still drive the loop condition.
+    const result = evalCode(`
+      const fns = [];
+      let total = 0;
+      for (let i = 0; i < 3;) {
+        fns.push(() => i);
+        total = total + i;
+        i = i + 1;
+      }
+      [fns[0](), total]
+    `);
+    expect(typeValueToString(result)).toBe("[1, 3]");
+  });
+
+  it("for-of over a union of tuples iterates every member", () => {
+    const result = evalWith(`
+      function pick(c) {
+        if (c) { return [9]; }
+        return [10, [11, 12]];
+      }
+      function f(a, t) {
+        const r = t || [];
+        for (const e of a) {
+          if (Array.isArray(e)) { f(e, r) } else { r.push(e) }
+        }
+        return r;
+      }
+      f(pick(c))
+    `, { c: T.boolean });
+    // Both union members' elements flow through the body (concatenated),
+    // including the recursive flattening of the nested [11, 12] member.
+    // (typeValueEquals has no tuple branch — compare rendered form.)
+    expect(typeValueToString(result)).toBe("[9, 10, 11, 12]");
+  });
+
+  it("for-of over a union with non-iterable members skips them", () => {
+    const result = evalWith(`
+      function pick(c) {
+        if (c) { return [1, 2]; }
+        if (c === 2) { return 42; }
+        return "str";
+      }
+      function f(a, t) {
+        const r = t || [];
+        for (const e of a) {
+          if (Array.isArray(e)) { f(e, r) } else { r.push(e) }
+        }
+        return r;
+      }
+      f(pick(c))
+    `, { c: T.boolean });
+    // number/string members of the union contribute nothing; the tuple
+    // member's pushes still land on the shared accumulator.
+    expect(typeValueToString(result)).toBe("[1, 2]");
+  });
+
+  it("break terminates loop iteration and skips the rest of the body", () => {
+    // Guard-style break (reach.js pattern): the member access after break
+    // must not execute on the falsy receiver. Before break was implemented
+    // the loop kept evaluating the body and dereferenced the undefined ref.
+    const result = evalWith(`
+      function step(ref, key) {
+        let out = null;
+        for (const k of [key]) {
+          if (!ref) {
+            out = 'default';
+            break;
+          }
+          out = ref[k];
+        }
+        return out;
+      }
+      step(ref, 'a')
+    `, { ref: T.undefined });
+    expect(typeValueToString(result)).toBe('"default"');
+  });
+
+  it("break stops the loop and continue skips to the update clause", () => {
+    const result = evalCode(`
+      const collected = [];
+      for (let i = 0; i < 5; i++) {
+        if (i === 1) { continue; }
+        if (i === 3) { break; }
+        collected.push(i);
+      }
+      collected
+    `);
+    // continue skips push(1); break stops before 3 and 4
+    expect(typeValueToString(result)).toBe("[0, 2]");
+  });
 });
 
 describe("WhileStatement", () => {

package/src/__tests__/evaluator-nullish-coalescing.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueToString, createEnvironment } from "@nudojs/core";
+import type { TypeValue } from "@nudojs/core";
+import { evaluateProgram, evaluateFunction } from "../evaluator.ts";
+import { parse } from "@nudojs/parser";
+
+function evalSource(source: string) {
+  const ast = parse(source);
+  const env = createEnvironment();
+  evaluateProgram(ast, env);
+  return env;
+}
+
+function evalFn(code: string, args: TypeValue[]): TypeValue {
+  const ast = parse(code);
+  const env = createEnvironment();
+  evaluateProgram(ast, env);
+  const fns = ast.type === "File" ? ast.program.body : [];
+  const fnNode = fns.find(
+    (n: any) => n.type === "FunctionDeclaration",
+  );
+  if (!fnNode) throw new Error("No function found");
+  return evaluateFunction(fnNode, args, env);
+}
+
+describe("nullish coalescing narrowing", () => {
+  it("narrows ?? to exclude null/undefined from left side", () => {
+    const env = evalSource(`
+      const x = "hello" ?? "default";
+    `);
+    expect(typeValueToString(env.lookup("x"))).toBe('"hello"');
+  });
+
+  it("returns right side when left is always null", () => {
+    const env = evalSource(`
+      const x = null;
+      const result = x ?? 42;
+    `);
+    expect(typeValueToString(env.lookup("result"))).toBe("42");
+  });
+
+  it("returns left side when left is never null", () => {
+    const env = evalSource(`
+      const x = "hello";
+      const result = x ?? "default";
+    `);
+    expect(typeValueToString(env.lookup("result"))).toBe('"hello"');
+  });
+
+  it("narrows union type by removing null from left side", () => {
+    const result = evalFn(
+      `function test(x) { return x ?? "default"; }`,
+      [T.union(T.string, T.null)],
+    );
+    // null is excluded from string | null, leaving string.
+    // "default" is a subtype of string, so result is string.
+    expect(typeValueToString(result)).toBe("string");
+  });
+
+  it("narrows union type by removing undefined from left side", () => {
+    const result = evalFn(
+      `function test(x) { return x ?? "fallback"; }`,
+      [T.union(T.string, T.undefined)],
+    );
+    // undefined is excluded from string | undefined, leaving string.
+    expect(typeValueToString(result)).toBe("string");
+  });
+
+  it("narrows union type by removing null and undefined from left side", () => {
+    const result = evalFn(
+      `function test(x) { return x ?? "fallback"; }`,
+      [T.union(T.string, T.null, T.undefined)],
+    );
+    // null and undefined are excluded, leaving string.
+    expect(typeValueToString(result)).toBe("string");
+  });
+
+  it("returns right side when left is always null/undefined union", () => {
+    const result = evalFn(
+      `function test(x) { return x ?? 42; }`,
+      [T.union(T.null, T.undefined)],
+    );
+    // All left members are null/undefined, so use right side.
+    expect(typeValueToString(result)).toBe("42");
+  });
+});

package/src/__tests__/evaluator-optional-chaining.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueToString, createEnvironment } from "@nudojs/core";
+import { evaluateProgram } from "../evaluator.ts";
+import { parse } from "@nudojs/parser";
+
+function evalSource(source: string) {
+  const ast = parse(source);
+  const env = createEnvironment();
+  evaluateProgram(ast, env);
+  return env;
+}
+
+describe("optional chaining", () => {
+  it("evaluates obj?.foo when obj is object", () => {
+    const env = evalSource(`
+      const obj = { foo: "hello" };
+      const result = obj?.foo;
+    `);
+    expect(typeValueToString(env.lookup("result"))).toBe('"hello"');
+  });
+
+  it("evaluates arr?.[0] for optional computed access", () => {
+    const env = evalSource(`
+      const arr = [1, 2, 3];
+      const result = arr?.[0];
+    `);
+    expect(typeValueToString(env.lookup("result"))).toBe("1");
+  });
+
+  it("evaluates fn?.() for optional call", () => {
+    const env = evalSource(`
+      const fn = () => 42;
+      const result = fn?.();
+    `);
+    expect(typeValueToString(env.lookup("result"))).toBe("42");
+  });
+});

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

@@ -8,7 +8,7 @@ import {
 } from "@nudojs/core";
 import type { TypeValue } from "@nudojs/core";
 import { parse } from "@nudojs/parser";
-import { evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, resetMemo, setModuleResolver, setCurrentFileDir } from "../evaluator.ts";
+import { evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, resetMemo, setModuleResolver, setCurrentFileDir, setUnknownCollector, setMockModules, resetMockModules, type UnknownRecord } from "../evaluator.ts";
 
 function evalCode(code: string): TypeValue {
   const ast = parse(code);
@@ -207,7 +207,15 @@ describe("instanceof", () => {
       const x = 42;
       x instanceof Error
     `);
-    expect(result).toBe(T.boolean);
+    // primitives can never be instanceof anything — decided statically
+    expect(typeValueEquals(result, T.literal(false))).toBe(true);
+    // unknown receivers keep the conservative boolean fallback
+    const fn = evaluateFunction(
+      parse("function f(x) { return x instanceof Error; }").program.body[0],
+      [T.unknown],
+      createEnvironment(),
+    );
+    expect(fn).toBe(T.boolean);
   });
 });
 
@@ -301,6 +309,51 @@ describe("recursion with memoization", () => {
     const result = env.lookup("result");
     expect(result.kind).toBe("unknown");
   });
+
+  it("budget-truncated recursion falls back to the function's observed results instead of unknown", () => {
+    // eq over chains deeper than MAX_CALL_DEPTH truncates mid-recursion.
+    // The first truncation has no observations and stays unknown; precise
+    // calls then accumulate true/false; a later truncation (fresh argument
+    // shapes, so no memo hit) degrades to the observed union.
+    const nest = (n: number, leaf: string): string => (n === 0 ? leaf : `{ x: ${nest(n - 1, leaf)} }`);
+    const ast = parse(`
+      function eq(a, b) {
+        if (a === b) return true;
+        if (typeof a !== "object") return false;
+        return eq(a.x, b.x);
+      }
+      const r1 = eq(${nest(70, "1")}, ${nest(70, "2")});
+      const t = eq(1, 1);
+      const f = eq(1, 2);
+      const r2 = eq(${nest(80, "3")}, ${nest(80, "4")});
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+    expect(env.lookup("r1").kind).toBe("unknown");
+    expect(typeValueToString(env.lookup("t"))).toBe("true");
+    expect(typeValueToString(env.lookup("f"))).toBe("false");
+    const r2 = env.lookup("r2");
+    expect(r2.kind).toBe("union");
+    if (r2.kind === "union") {
+      expect(r2.members).toHaveLength(2);
+      expect(typeValueToString(r2)).toBe("true | false");
+    }
+  });
+
+  it("budget-truncated recursion without observed results stays unknown", () => {
+    const nest = (n: number, leaf: string): string => (n === 0 ? leaf : `{ x: ${nest(n - 1, leaf)} }`);
+    const ast = parse(`
+      function eq(a, b) {
+        if (a === b) return true;
+        if (typeof a !== "object") return false;
+        return eq(a.x, b.x);
+      }
+      const r = eq(${nest(70, "5")}, ${nest(70, "6")});
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+    expect(env.lookup("r").kind).toBe("unknown");
+  });
 });
 
 describe("modules import/export", () => {
@@ -436,6 +489,304 @@ describe("modules import/export", () => {
 
     setModuleResolver(null);
   });
+
+  it("resolves require() of a CJS module exporting an object", () => {
+    setModuleResolver((source) => {
+      if (source === "./b") {
+        return {
+          ast: parse(`function triple(x) { return x * 3; }\nmodule.exports = { triple };\n`),
+          filePath: "/fake/b.js",
+        };
+      }
+      return null;
+    });
+    setCurrentFileDir("/fake");
+
+    const ast = parse(`
+      const b = require("./b");
+      const r = b.triple(4);
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+
+    const b = env.lookup("b");
+    expect(b.kind).toBe("object");
+    if (b.kind === "object") {
+      expect(b.properties.triple.kind).toBe("function");
+    }
+    expect(typeValueEquals(env.lookup("r"), T.literal(12))).toBe(true);
+
+    setModuleResolver(null);
+  });
+
+  it("require() picks up a chained module.exports = internals.x = function assignment", () => {
+    setModuleResolver((source) => {
+      if (source === "./clone") {
+        return {
+          ast: parse(`
+            const internals = {};
+            module.exports = internals.clone = function (obj, options = {}) {
+              if (options.shallow) {
+                return obj;
+              }
+              return obj;
+            };
+          `),
+          filePath: "/fake/clone.js",
+        };
+      }
+      return null;
+    });
+    setCurrentFileDir("/fake");
+
+    const ast = parse(`
+      const Clone = require("./clone");
+      const r = Clone(5);
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+
+    expect(env.lookup("Clone").kind).toBe("function");
+    expect(typeValueEquals(env.lookup("r"), T.literal(5))).toBe(true);
+
+    setModuleResolver(null);
+  });
+
+  it("supports exports.name assignments", () => {
+    setModuleResolver((source) => {
+      if (source === "./b") {
+        return {
+          ast: parse(`exports.triple = function (x) { return x * 3; };\n`),
+          filePath: "/fake/b.js",
+        };
+      }
+      return null;
+    });
+    setCurrentFileDir("/fake");
+
+    const ast = parse(`
+      const b = require("./b");
+      const r = b.triple(2);
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+
+    expect(typeValueEquals(env.lookup("r"), T.literal(6))).toBe(true);
+
+    setModuleResolver(null);
+  });
+
+  it("require() of an ES module returns its exports as properties", () => {
+    setModuleResolver((source) => {
+      if (source === "./esm") {
+        return {
+          ast: parse(`export const n = 1;\nexport function f(x) { return x + 1; }\n`),
+          filePath: "/fake/esm.js",
+        };
+      }
+      return null;
+    });
+    setCurrentFileDir("/fake");
+
+    const ast = parse(`
+      const b = require("./esm");
+      const r = b.f(b.n);
+    `);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+
+    expect(typeValueEquals(env.lookup("r"), T.literal(2))).toBe(true);
+
+    setModuleResolver(null);
+  });
+
+  it("require() with a bare specifier returns unknown and records a warning", () => {
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    try {
+      const ast = parse(`const u = require("@hapi/hoek");\n`);
+      evaluateProgram(ast, env);
+    } finally {
+      setUnknownCollector(null);
+      setCurrentFileDir("");
+    }
+
+    expect(env.lookup("u").kind).toBe("unknown");
+    expect(records.some((r) => r.kind === "global" && r.name === `require('@hapi/hoek')`)).toBe(true);
+  });
+
+  // --- 模块加载边界守卫（环 / 深度 / 缺失），来源：evaluator.ts loadModuleEnv 加固 ---
+
+  it("reports a circular import chain a -> b -> a and keeps partial-binding semantics", () => {
+    const aAst = parse(`import { bVal } from "./b.js";\nexport const aVal = 1;\nexport const mixed = bVal;\n`);
+    const bAst = parse(`import { aVal } from "./a.js";\nexport const bVal = aVal;\n`);
+    const files: Record<string, { ast: ReturnType<typeof parse>; filePath: string }> = {
+      "./a.js": { ast: aAst, filePath: "/fake/a.js" },
+      "./b.js": { ast: bAst, filePath: "/fake/b.js" },
+    };
+    setModuleResolver((source) => files[source] ?? null);
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { aVal, mixed } from "./a.js";\n`), env);
+
+    const cycle = records.find((r) => r.kind === "global" && r.name.startsWith("module-cycle:"));
+    expect(cycle).toBeDefined();
+    expect(cycle?.name).toBe("module-cycle:a.js");
+    expect(cycle?.reason).toBe("Circular module load: /fake/a.js -> /fake/b.js -> /fake/a.js (bindings inside the cycle resolve to their partially evaluated types)");
+    // 环内 aVal 在 b 求值时尚未执行 → unknown；环后补齐的导出照常可得
+    expect(typeValueEquals(env.lookup("aVal"), T.literal(1))).toBe(true);
+    expect(env.lookup("mixed").kind).toBe("unknown");
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+  });
+
+  it("reports a mock-module cycle when the mock file re-imports the mocked module", () => {
+    const mockAst = parse(`import { helper } from "calc";\nexport const value = helper;\nexport const own = 2;\n`);
+    setMockModules(new Map([["calc", { fromPath: "./mockCalc.js" }]]));
+    setModuleResolver((source) => {
+      if (source === "./mockCalc.js") return { ast: mockAst, filePath: "/fake/mockCalc.js" };
+      return null;
+    });
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { value, own } from "calc";\nconst sum = own + 40;\n`), env);
+
+    const cycle = records.find((r) => r.kind === "global" && r.name.startsWith("module-cycle:"));
+    expect(cycle).toBeDefined();
+    expect(cycle?.reason).toBe("Circular module load: /fake/mockCalc.js -> /fake/mockCalc.js (bindings inside the cycle resolve to their partially evaluated types)");
+    // 环截断后 mock 文件其余导出照常求值，分析不中断
+    expect(env.lookup("value").kind).toBe("unknown");
+    expect(typeValueEquals(env.lookup("sum"), T.literal(42))).toBe(true);
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+    resetMockModules();
+  });
+
+  it("truncates module chains deeper than the depth limit and reports the chain", () => {
+    // f1 -> f2 -> ... -> f20：第 17 层（f17）触发深度上限（MAX_MODULE_LOAD_DEPTH = 16）
+    const files: Record<string, { ast: ReturnType<typeof parse>; filePath: string }> = {};
+    for (let i = 1; i <= 20; i++) {
+      const body = i < 20
+        ? `import { value as inner } from "./f${i + 1}.js";\nexport const value = inner;\n`
+        : `export const value = 20;\n`;
+      files[`./f${i}.js`] = { ast: parse(body), filePath: `/fake/f${i}.js` };
+    }
+    setModuleResolver((source) => files[source] ?? null);
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { value } from "./f1.js";\n`), env);
+
+    const depth = records.find((r) => r.kind === "global" && r.name.startsWith("module-depth:"));
+    expect(depth).toBeDefined();
+    expect(depth?.name).toBe("module-depth:f17.js");
+    expect(depth?.reason).toContain("depth 17 > 16 max");
+    const expectedChain = Array.from({ length: 17 }, (_, k) => `/fake/f${k + 1}.js`).join(" -> ");
+    expect(depth?.reason).toContain(expectedChain);
+    // 截断为 unknown，而非栈溢出崩溃
+    expect(env.lookup("value").kind).toBe("unknown");
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+  });
+
+  it("reports a missing @nudo:mock-module target with its full path and falls back to the original", () => {
+    setMockModules(new Map([["b", { fromPath: "./nope.js" }]]));
+    setModuleResolver((source) => {
+      if (source === "b") return { ast: parse(`export const x = 41;\n`), filePath: "/fake/b.js" };
+      return null; // "./nope.js" 不存在
+    });
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { x } from "b";\nconst y = x + 1;\n`), env);
+
+    const missing = records.find((r) => r.kind === "global" && r.name.startsWith("module-missing:"));
+    expect(missing).toBeDefined();
+    expect(missing?.name).toBe("module-missing:nope.js");
+    expect(missing?.reason).toContain('@nudo:mock-module target for "b" not found');
+    expect(missing?.reason).toContain("/fake/nope.js");
+    // 回落到原模块，mock 缺失不中断分析
+    expect(typeValueEquals(env.lookup("y"), T.literal(42))).toBe(true);
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+    resetMockModules();
+  });
+
+  it("reports an unresolvable relative import with the attempted full path", () => {
+    setModuleResolver(() => null);
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { x } from "./gone.js";\nconst y = 1;\n`), env);
+
+    const missing = records.find((r) => r.kind === "global" && r.name.startsWith("module-missing:"));
+    expect(missing).toBeDefined();
+    expect(missing?.reason).toContain("Cannot resolve import './gone.js'");
+    expect(missing?.reason).toContain("/fake/gone.js");
+    expect(typeValueEquals(env.lookup("y"), T.literal(1))).toBe(true);
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+  });
+
+  it("loads nested mock-module dependencies without triggering guard diagnostics", () => {
+    const helperAst = parse(`export const h = 2;\n`);
+    const mockAst = parse(`import { h } from "./helper.js";\nexport const answer = h * 21;\n`);
+    const files: Record<string, { ast: ReturnType<typeof parse>; filePath: string }> = {
+      "./helper.js": { ast: helperAst, filePath: "/fake/helper.js" },
+      "./mockCalc.js": { ast: mockAst, filePath: "/fake/mockCalc.js" },
+    };
+    setMockModules(new Map([["calc", { fromPath: "./mockCalc.js" }]]));
+    setModuleResolver((source) => files[source] ?? null);
+    setCurrentFileDir("/fake");
+
+    const records: UnknownRecord[] = [];
+    setUnknownCollector((r) => records.push(r));
+    const env = createEnvironment();
+    evaluateProgram(parse(`import { answer } from "calc";\nconst life = answer;\n`), env);
+
+    // 正常嵌套 mock：不产生任何守卫诊断
+    expect(records.filter((r) => r.name.startsWith("module-"))).toHaveLength(0);
+    expect(typeValueEquals(env.lookup("life"), T.literal(42))).toBe(true);
+
+    setUnknownCollector(null);
+    setModuleResolver(null);
+    setCurrentFileDir("");
+    resetMockModules();
+  });
+
+  it("pre-binds __dirname and __filename as strings", () => {
+    const ast = parse(`const d = __dirname;\nconst f = __filename;\n`);
+    const env = createEnvironment();
+    evaluateProgram(ast, env);
+
+    expect(typeValueEquals(env.lookup("d"), T.string)).toBe(true);
+    expect(typeValueEquals(env.lookup("f"), T.string)).toBe(true);
+  });
 });
 
 describe("SwitchStatement", () => {