@nudojs/cli 0.2.1 → 0.3.0

package/src/__tests__/builtin-api.test.ts

@@ -1,308 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({
-        name: fn.name,
-        caseName: dir.name,
-        result: typeValueToString(result.value),
-      });
-    }
-  }
-  return results;
-}
-
-describe("Built-in API Tests", () => {
-  it("Date.now() should return number", () => {
-    const results = runTest(`
-// @nudo:case "now" ()
-function getTimestamp() {
-  return Date.now();
-}
-`);
-    console.log("Date.now() result:", results[0].result);
-    expect(results[0].result).toBe("number");
-  });
-
-  it("Math.floor() should return number", () => {
-    const results = runTest(`
-// @nudo:case "floor" (3.7)
-function floorIt(x) {
-  return Math.floor(x);
-}
-`);
-    console.log("Math.floor() result:", results[0].result);
-    expect(results[0].result).toBe("number");
-  });
-
-  it("Math.random() should return number", () => {
-    const results = runTest(`
-// @nudo:case "random" ()
-function getRandom() {
-  return Math.random();
-}
-`);
-    console.log("Math.random() result:", results[0].result);
-    expect(results[0].result).toBe("number");
-  });
-
-  it("JSON.stringify() should return string", () => {
-    const results = runTest(`
-// @nudo:case "stringify" ({a: 1})
-function toJson(obj) {
-  return JSON.stringify(obj);
-}
-`);
-    console.log("JSON.stringify() result:", results[0].result);
-    expect(results[0].result).toBe("string");
-  });
-
-  it("JSON.parse(literal string) decodes the literal's exact structure", () => {
-    const results = runTest(`
-// @nudo:case "fixture" ()
-function parseFixture() {
-  return JSON.parse('{"a":1,"b":[2,"x"]}');
-}
-// @nudo:case "scalars" ()
-function parseScalars() {
-  return JSON.parse('{"n":null,"t":true,"s":"x"}');
-}
-`);
-    console.log("JSON.parse literal results:", results.map((r) => r.result));
-    expect(results[0].result).toBe('{ a: 1, b: [2, "x"] }');
-    expect(results[1].result).toBe('{ n: null, t: true, s: "x" }');
-  });
-
-  it("JSON.parse degrades to unknown for non-literal, invalid, or reviver calls", () => {
-    const results = runTest(`
-// @nudo:case "invalid" ('not json')
-// @nudo:case "symbolic" (T.string)
-// @nudo:case "reviver" ('{"a":1}', T.unknown)
-function parseArg(text, rev) {
-  return JSON.parse(text, rev);
-}
-`);
-    console.log("JSON.parse degradation results:", results.map((r) => r.result));
-    expect(results.map((r) => r.result)).toEqual(["unknown", "unknown", "unknown"]);
-  });
-
-  it("Object.keys() should return string[]", () => {
-    const results = runTest(`
-// @nudo:case "keys" ({a: 1, b: 2})
-function getKeys(obj) {
-  return Object.keys(obj);
-}
-`);
-    console.log("Object.keys() result:", results[0].result);
-    // Object.keys returns actual keys from the object
-    expect(results[0].result).toBe('["a", "b"]');
-  });
-
-  it("Object.prototype.hasOwnProperty.call(obj, key) should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "own" ({a: 1})
-function checkOwn(obj) {
-  return Object.prototype.hasOwnProperty.call(obj, 'a');
-}
-`);
-    console.log("Object.prototype.hasOwnProperty.call result:", results[0].result);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("Object.prototype predicate family (isPrototypeOf, propertyIsEnumerable) should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "proto" ({a: 1})
-function checkProto(obj) {
-  const a = Object.prototype.isPrototypeOf.call({}, obj);
-  const b = Object.prototype.propertyIsEnumerable.call(obj, 'a');
-  return a && b;
-}
-`);
-    console.log("Object.prototype predicates result:", results[0].result);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("Object.prototype members resolve through plain objects (member access and destructuring)", () => {
-    const results = runTest(`
-// @nudo:case "member" ({x: 1})
-function viaMember(obj) {
-  return obj.hasOwnProperty('x');
-}
-`);
-    console.log("obj.hasOwnProperty result:", results[0].result);
-    expect(results[0].result).toBe("boolean");
-
-    // Destructuring reads through the prototype chain in real JS, so
-    // `const { hasOwnProperty } = obj` yields a function, not undefined —
-    // and never the native JS function (plain records must be own-guarded).
-    const destructured = runTest(`
-// @nudo:case "destructure" ({y: 1})
-function viaDestructure(obj) {
-  const { hasOwnProperty } = obj;
-  return hasOwnProperty.call(obj, 'y');
-}
-`);
-    console.log("destructured hasOwnProperty result:", destructured[0].result);
-    expect(destructured[0].result).toBe("boolean");
-  });
-
-  it("Object.prototype.toString.call(x) yields the receiver's brand literal", () => {
-    const results = runTest(`
-// @nudo:case "plain" ({a: 1})
-// @nudo:case "array" ([1, 2])
-// @nudo:case "fn" ((a) => a)
-function brand(x) {
-  return Object.prototype.toString.call(x);
-}
-`);
-    console.log("brand results:", results.map((r) => r.result));
-    expect(results[0].result).toBe('"[object Object]"');
-    expect(results[1].result).toBe('"[object Array]"');
-    expect(results[2].result).toBe('"[object Function]"');
-  });
-
-  it("Object.prototype.toString.call brands null/undefined and primitives", () => {
-    const results = runTest(`
-// @nudo:case "null" (null)
-// @nudo:case "undefined" (undefined)
-// @nudo:case "number" (T.number)
-function brand(x) {
-  return Object.prototype.toString.call(x);
-}
-`);
-    console.log("brand results:", results.map((r) => r.result));
-    expect(results[0].result).toBe('"[object Null]"');
-    expect(results[1].result).toBe('"[object Undefined]"');
-    expect(results[2].result).toBe('"[object Number]"');
-  });
-
-  it("Object.prototype.toString.call(new Map()) brands with the class name", () => {
-    const results = runTest(`
-// @nudo:case "map" ()
-function brandMap() {
-  return Object.prototype.toString.call(new Map());
-}
-`);
-    console.log("brand Map result:", results[0].result);
-    expect(results[0].result).toBe('"[object Map]"');
-  });
-
-  it("Object.getPrototypeOf maps receivers onto cached prototype singletons", () => {
-    const results = runTest(`
-// @nudo:case "plain" ({a: 1})
-// @nudo:case "array" ([1])
-function proto(x) {
-  return Object.getPrototypeOf(x);
-}
-`);
-    console.log("getPrototypeOf results:", results.map((r) => r.result.slice(0, 24)));
-    expect(results[0].result).toContain("Object {");
-    expect(results[1].result).toContain("Array {");
-  });
-
-  it("Object.getPrototypeOf identity compares equal to X.prototype", () => {
-    const results = runTest(`
-// @nudo:case "plain" ({a: 1})
-function protoEq(x) {
-  return Object.getPrototypeOf(x) === Object.prototype;
-}
-`);
-    expect(results[0].result).toBe("true");
-  });
-
-  it("Object.getOwnPropertyDescriptor returns a value-carrying descriptor", () => {
-    const results = runTest(`
-// @nudo:case "hit" ({a: 1})
-function desc(x) {
-  const d = Object.getOwnPropertyDescriptor(x, 'a');
-  return d ? d.value : 'missing';
-}
-`);
-    console.log("descriptor value:", results[0].result);
-    expect(results[0].result).toBe("1");
-  });
-
-  it("Object.getOwnPropertyDescriptor misses return undefined", () => {
-    const results = runTest(`
-// @nudo:case "miss" ({a: 1})
-function descMiss(x) {
-  return Object.getOwnPropertyDescriptor(x, 'b');
-}
-`);
-    console.log("descriptor miss:", results[0].result);
-    expect(results[0].result).toBe("undefined");
-  });
-
-  it("Buffer namespace resolves: from/prototype feed the clone-style proto chain", () => {
-    const results = runTest(`
-// @nudo:case "from" ({a: 1})
-function buf(x) {
-  const proto = Object.getPrototypeOf(x);
-  if (proto === Buffer.prototype) {
-    return Buffer.from(x);
-  }
-  return Object.create(proto);
-}
-`);
-    console.log("buffer chain result:", results[0].result);
-    expect(results[0].result).toBe("{}");
-  });
-
-  it("String.fromCharCode/fromCodePoint with all-literal codes return exact string literals", () => {
-    const results = runTest(`
-// @nudo:case "sep" ()
-function lineSep() {
-  return String.fromCharCode(0x2028);
-}
-// @nudo:case "multi" ()
-function pair() {
-  return String.fromCharCode(72, 105);
-}
-// @nudo:case "point" ()
-function fromPoint() {
-  return String.fromCodePoint(65);
-}
-// @nudo:case "empty" ()
-function none() {
-  return String.fromCharCode();
-}
-`);
-    console.log("String static literal results:", results.map((r) => r.result));
-    expect(results.map((r) => r.result)).toEqual([
-      JSON.stringify(String.fromCharCode(0x2028)),
-      '"Hi"',
-      '"A"',
-      '""',
-    ]);
-  });
-
-  it("String.fromCharCode/fromCodePoint degrade to string for non-literal args", () => {
-    const results = runTest(`
-// @nudo:case "symbolic" (T.number)
-function sym(code) {
-  return String.fromCharCode(code);
-}
-// @nudo:case "mixed" (65, T.number)
-function mixed(a, b) {
-  return String.fromCharCode(a, b);
-}
-// @nudo:case "pointSym" (T.number)
-function pointSym(code) {
-  return String.fromCodePoint(code);
-}
-`);
-    console.log("String static degradation results:", results.map((r) => r.result));
-    expect(results.map((r) => r.result)).toEqual(["string", "string", "string"]);
-  });
-});

package/src/__tests__/builtin-functions.test.ts

@@ -1,313 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function infer(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({
-        name: fn.name,
-        caseName: dir.name,
-        result: typeValueToString(result.value),
-      });
-    }
-  }
-  return results;
-}
-
-describe("Built-in Functions", () => {
-  describe("String()", () => {
-    it("converts number to string", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe('"42"');
-    });
-
-    it("converts string to string (identity)", () => {
-      const results = infer(`
-// @nudo:case "str" ("hello")
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe('"hello"');
-    });
-
-    it("converts boolean to string", () => {
-      const results = infer(`
-// @nudo:case "true" (true)
-// @nudo:case "false" (false)
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe('"true"');
-      expect(results[1].result).toBe('"false"');
-    });
-
-    it("converts null to string", () => {
-      const results = infer(`
-// @nudo:case "null" (null)
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe('"null"');
-    });
-
-    it("converts undefined to string", () => {
-      const results = infer(`
-// @nudo:case "undef" (undefined)
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe('"undefined"');
-    });
-
-    it("returns string for symbolic input", () => {
-      const results = infer(`
-// @nudo:case "sym" (T.number)
-function foo(x) { return String(x); }
-`);
-      expect(results[0].result).toBe("string");
-    });
-
-    it("returns empty string for no args", () => {
-      const results = infer(`
-// @nudo:case "empty" ()
-function foo() { return String(); }
-`);
-      expect(results[0].result).toBe('""');
-    });
-  });
-
-  describe("Number()", () => {
-    it("converts string to number", () => {
-      const results = infer(`
-// @nudo:case "str" ("42")
-function foo(x) { return Number(x); }
-`);
-      expect(results[0].result).toBe("42");
-    });
-
-    it("converts number to number (identity)", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-function foo(x) { return Number(x); }
-`);
-      expect(results[0].result).toBe("42");
-    });
-
-    it("converts boolean to number", () => {
-      const results = infer(`
-// @nudo:case "true" (true)
-// @nudo:case "false" (false)
-function foo(x) { return Number(x); }
-`);
-      expect(results[0].result).toBe("1");
-      expect(results[1].result).toBe("0");
-    });
-
-    it("returns number for symbolic input", () => {
-      const results = infer(`
-// @nudo:case "sym" (T.string)
-function foo(x) { return Number(x); }
-`);
-      expect(results[0].result).toBe("number");
-    });
-  });
-
-  describe("Boolean()", () => {
-    it("converts truthy values", () => {
-      const results = infer(`
-// @nudo:case "str" ("hello")
-// @nudo:case "num" (42)
-function foo(x) { return Boolean(x); }
-`);
-      expect(results[0].result).toBe("true");
-      expect(results[1].result).toBe("true");
-    });
-
-    it("converts falsy values", () => {
-      const results = infer(`
-// @nudo:case "zero" (0)
-// @nudo:case "empty" ("")
-// @nudo:case "null" (null)
-function foo(x) { return Boolean(x); }
-`);
-      expect(results[0].result).toBe("false");
-      expect(results[1].result).toBe("false");
-      expect(results[2].result).toBe("false");
-    });
-  });
-
-  describe("parseInt()", () => {
-    it("returns number", () => {
-      const results = infer(`
-// @nudo:case "str" ("42")
-function foo(x) { return parseInt(x); }
-`);
-      expect(results[0].result).toBe("number");
-    });
-  });
-
-  describe("parseFloat()", () => {
-    it("returns number", () => {
-      const results = infer(`
-// @nudo:case "str" ("3.14")
-function foo(x) { return parseFloat(x); }
-`);
-      expect(results[0].result).toBe("number");
-    });
-  });
-
-  describe("isNaN()", () => {
-    it("returns boolean", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-// @nudo:case "nan" (NaN)
-function foo(x) { return isNaN(x); }
-`);
-      expect(results[0].result).toBe("boolean");
-      expect(results[1].result).toBe("boolean");
-    });
-  });
-
-  describe("isFinite()", () => {
-    it("returns boolean", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-// @nudo:case "inf" (Infinity)
-function foo(x) { return isFinite(x); }
-`);
-      expect(results[0].result).toBe("boolean");
-      expect(results[1].result).toBe("boolean");
-    });
-  });
-
-  describe("encodeURIComponent()", () => {
-    it("returns string", () => {
-      const results = infer(`
-// @nudo:case "str" ("hello world")
-function foo(x) { return encodeURIComponent(x); }
-`);
-      expect(results[0].result).toBe("string");
-    });
-  });
-
-  describe("console methods", () => {
-    it("console.log returns undefined", () => {
-      const results = infer(`
-// @nudo:case "str" ("hello")
-function foo(x) { return console.log(x); }
-`);
-      expect(results[0].result).toBe("undefined");
-    });
-  });
-
-  describe("Math methods", () => {
-    it("Math.abs returns number", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-function foo(x) { return Math.abs(x); }
-`);
-      expect(results[0].result).toBe("number");
-    });
-
-    it("Math.floor returns number", () => {
-      const results = infer(`
-// @nudo:case "num" (3.14)
-function foo(x) { return Math.floor(x); }
-`);
-      expect(results[0].result).toBe("number");
-    });
-  });
-
-  describe("Global numeric constants", () => {
-    it("Infinity / -Infinity / NaN resolve to number", () => {
-      const results = infer(`
-// @nudo:case "constants" ()
-function foo() {
-  return [Infinity, -Infinity, NaN];
-}
-`);
-      // 修复前：Infinity/NaN 走未知全局（unknown）且触发 nudo:unknown-global；
-      // 现在通过 BUILTIN_STATIC_METHODS 接线解析为 number。
-      // 常量显示 number 即可——case 序列化器对非有限数返回 null，不产
-      // 字面量值。数组字面量求值为 tuple。
-      expect(results[0].result).toBe("[number, number, number]");
-    });
-
-    it("Number static constants resolve to number", () => {
-      const results = infer(`
-// @nudo:case "num-consts" ()
-function foo() {
-  return [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, Number.MAX_VALUE, Number.EPSILON];
-}
-`);
-      // 修复前：Number.MAX_SAFE_INTEGER 报 unknown-property 且值为 undefined
-      expect(results[0].result).toBe("[number, number, number, number]");
-    });
-
-    it("Math.PI / Math.E resolve to number", () => {
-      const results = infer(`
-// @nudo:case "math-consts" ()
-function foo() { return Math.PI + Math.E; }
-`);
-      // 修复前：Math.PI 走 unknown-property（undefined）
-      expect(results[0].result).toBe("number");
-    });
-  });
-
-  describe("Loose equality", () => {
-    it("literal == evaluates via JS coercion", () => {
-      const results = infer(`
-// @nudo:case "num" ()
-// @nudo:case "str-num" ()
-function foo() {
-  return [5 == 3, "5" == 5];
-}
-`);
-      // 修复前：== 未实现（unknown）；现在两字面量操作数按 JS 宽松相
-      // 等求值：5 == 3 → false，"5" == 5 → true
-      expect(results[0].result).toBe("[false, true]");
-    });
-
-    it("non-literal == degrades to boolean", () => {
-      const results = infer(`
-// @nudo:case "sym" (T.string)
-function foo(x) {
-  return x == "5";
-}
-`);
-      // 任一操作数非字面量：退化为 boolean
-      expect(results[0].result).toBe("boolean");
-    });
-  });
-
-  describe("Integration with narrowing", () => {
-    it("String() after typeof check", () => {
-      const results = infer(`
-// @nudo:case "str" ("hello")
-// @nudo:case "num" (42)
-function foo(x) {
-  if (typeof x === "string") return x.toUpperCase();
-  return String(x);
-}
-`);
-      expect(results[0].result).toBe('"HELLO"');
-      expect(results[1].result).toBe('"42"');
-    });
-
-    it("String() in template literal", () => {
-      const results = infer(`
-// @nudo:case "num" (42)
-function foo(x) { return \`value: \${String(x)}\`; }
-`);
-      expect(results[0].result).toBe('"value: 42"');
-    });
-  });
-});