@nudojs/core 0.1.0 → 0.3.0

package/src/__tests__/type-value.test.ts

@@ -1,15 +1,19 @@
 import { describe, it, expect } from "vitest";
 import {
   T,
+  type LiteralValue,
+  type TypeValue,
   typeValueEquals,
   simplifyUnion,
   widenLiteral,
+  collapseLiteralUnion,
   isSubtypeOf,
   typeValueToString,
   narrowType,
   subtractType,
   getPrimitiveTypeOf,
 } from "../type-value.ts";
+import { createTemplate } from "../refinements/template.ts";
 
 describe("T factory", () => {
   it("creates literal type values", () => {
@@ -118,6 +122,46 @@ describe("widenLiteral", () => {
   it("returns non-literal unchanged", () => {
     expect(widenLiteral(T.number)).toBe(T.number);
   });
+
+  it("collapses 20 number literals beyond maxLiterals to number", () => {
+    const members = Array.from({ length: 20 }, (_, i) => T.literal((i + 1) ** 2));
+    const u = { kind: "union", members } as const;
+    const result = collapseLiteralUnion(u, 4);
+    expect(result).toEqual(T.number);
+  });
+
+  it("collapses 5 string literals to string", () => {
+    const u = {
+      kind: "union",
+      members: ["a", "b", "c", "d", "e"].map((s) => T.literal(s)),
+    } as const;
+    const result = collapseLiteralUnion(u, 4);
+    expect(result).toEqual(T.string);
+  });
+
+  it("returns union unchanged when member count equals maxLiterals", () => {
+    const u: TypeValue = {
+      kind: "union",
+      members: [T.literal(1), T.literal(2), T.literal(3), T.literal(4)],
+    };
+    expect(collapseLiteralUnion(u, 4)).toBe(u);
+  });
+
+  it("mixed union: number literals absorbed by T.number, string literal kept (行为已修复：吸收律)", () => {
+    const u: TypeValue = {
+      kind: "union",
+      members: [T.literal(1), T.number, T.literal("x"), T.literal(2), T.literal(3)],
+    };
+    // 原断言期望原样返回 u；现 collapseLiteralUnion 复用 simplifyUnion 的吸收律，
+    // 数字字面量 1/2/3 被共存的 T.number 吸收，仅剩 ["x", number]（数量 ≤ 阈值不再坍缩）
+    expect(collapseLiteralUnion(u, 4)).toEqual(T.union(T.number, T.literal("x")));
+  });
+
+  it("returns non-union unchanged (single literal / T.number)", () => {
+    const lit = T.literal(1);
+    expect(collapseLiteralUnion(lit, 0)).toBe(lit);
+    expect(collapseLiteralUnion(T.number, 0)).toBe(T.number);
+  });
 });
 
 describe("isSubtypeOf", () => {
@@ -211,3 +255,65 @@ describe("getPrimitiveTypeOf", () => {
     expect(getPrimitiveTypeOf(T.array(T.number))).toBe("object");
   });
 });
+
+describe("union absorption law (3 | number → number)", () => {
+  it("absorbs number literal into number", () => {
+    expect(T.union(T.literal(3), T.number)).toBe(T.number);
+    expect(T.union(T.number, T.literal(3))).toBe(T.number);
+  });
+
+  it("absorbs string literal into string", () => {
+    expect(T.union(T.literal("a"), T.string)).toBe(T.string);
+    expect(T.union(T.string, T.literal("a"))).toBe(T.string);
+  });
+
+  it("absorbs boolean literal into boolean", () => {
+    expect(T.union(T.literal(true), T.boolean)).toBe(T.boolean);
+    expect(T.union(T.boolean, T.literal(false))).toBe(T.boolean);
+  });
+
+  it("absorbs bigint literal into bigint", () => {
+    // LiteralValue 类型暂不含 bigint，运行时以 cast 构造
+    expect(T.union(T.literal(10n as unknown as LiteralValue), T.bigint)).toBe(T.bigint);
+  });
+
+  it("absorbs template literal into string", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    expect(T.union(tmpl, T.string)).toBe(T.string);
+  });
+
+  it("absorbs only matching base across mixed members (order-stable)", () => {
+    // 1 被 number 吸收，"a" 无 string 在场而保留
+    const u = T.union(T.literal(1), T.number, T.literal("a"));
+    expect(u.kind).toBe("union");
+    if (u.kind === "union") {
+      expect(u.members).toHaveLength(2);
+      expect(typeValueEquals(u.members[0], T.number)).toBe(true);
+      expect(typeValueEquals(u.members[1], T.literal("a"))).toBe(true);
+    }
+  });
+
+  it("keeps different-base literal union (1 | \"a\")", () => {
+    const u = T.union(T.literal(1), T.literal("a"));
+    expect(u.kind).toBe("union");
+    if (u.kind === "union") {
+      expect(u.members).toHaveLength(2);
+    }
+  });
+
+  it("keeps pure literal unions (\"a\" | \"b\", 2 | -9)", () => {
+    expect(typeValueToString(T.union(T.literal("a"), T.literal("b")))).toBe('"a" | "b"');
+    expect(typeValueToString(T.union(T.literal(2), T.literal(-9)))).toBe("2 | -9");
+  });
+
+  it("keeps undefined/null literal unions untouched", () => {
+    expect(typeValueToString(T.union(T.undefined, T.string))).toBe("undefined | string");
+    expect(typeValueToString(T.union(T.null, T.literal(1)))).toBe("null | 1");
+  });
+
+  it("keeps pure primitive unions untouched (number | string | boolean)", () => {
+    expect(typeValueToString(T.union(T.number, T.string, T.boolean))).toBe(
+      "number | string | boolean",
+    );
+  });
+});

package/src/algebra/__tests__/abs-native.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFn, evalSource } from "../ast-eval.ts";
+import { abs, num, numLit, unknown } from "../abs.ts";
+import { v, lit } from "../term.ts";
+import { gt, pTrue } from "../pred.ts";
+import { typeValueToString } from "../../type-value.ts";
+import { absToTypeValue } from "../bridge.ts";
+import { formatAbs } from "../format.ts";
+
+function show(a: ReturnType<typeof analyzeFn>): string {
+  return typeValueToString(absToTypeValue(a));
+}
+
+describe("abs-native ast-eval", () => {
+  it("literal arith", () => {
+    const r = analyzeFn(`function f(){ return 1+2*3; }`, "f", []);
+    expect(show(r)).toBe("7");
+  });
+
+  it("param + 1 with constraint via phi in source", () => {
+    const src = `
+      function f(x) {
+        if (x > 0) return x + 1;
+        return 0;
+      }
+    `;
+    const r = analyzeFn(src, "f", [abs(num().shape, v("x"), gt(v("x"), lit(0)), "path")]);
+    // x>0 时 x+1 应带约束
+    expect(r.shape.k === "prim" || r.shape.k === "sum").toBe(true);
+  });
+
+  it("logical && short-circuit", () => {
+    const r = analyzeFn(`function f(){ return false && 1; }`, "f", []);
+    expect(show(r)).toBe("false");
+  });
+
+  it("typeof", () => {
+    const r = analyzeFn(`function f(){ return typeof 1; }`, "f", []);
+    expect(show(r)).toBe('"number"');
+  });
+
+  it("template literal", () => {
+    const r = analyzeFn(`function f(x){ return \`n=\${x}\`; }`, "f", [numLit(3)]);
+    expect(show(r)).toBe('"n=3"');
+  });
+
+  it("first-class arrow", () => {
+    const src = `
+      function f() {
+        const add = (a, b) => a + b;
+        return add(2, 3);
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(show(r)).toBe("5");
+  });
+
+  it("div and mod", () => {
+    expect(show(analyzeFn(`function f(){ return 10/2; }`, "f", []))).toBe("5");
+    expect(show(analyzeFn(`function f(){ return 10%3; }`, "f", []))).toBe("1");
+  });
+
+  it("nullish === decided", () => {
+    const r = analyzeFn(`function f(x){ return x === null; }`, "f", [numLit(1)]);
+    expect(show(r)).toBe("false");
+  });
+
+  it("for loop runs with update", () => {
+    const src = `
+      function f() {
+        let s = 0;
+        for (let i = 0; i < 3; i++) s = s + i;
+        return s;
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("for-of over tuple", () => {
+    const src = `
+      function f(xs) {
+        let s = 0;
+        for (const x of xs) s = s + x;
+        return s;
+      }
+    `;
+    const tup = abs({ k: "tuple", elements: [numLit(1), numLit(2)] }, undefined, undefined, "exact");
+    const r = analyzeFn(src, "f", [tup]);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("while with break", () => {
+    const src = `
+      function f() {
+        let i = 0;
+        while (true) {
+          i = i + 1;
+          if (i > 2) break;
+        }
+        return i;
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("try/catch binds thrown value", () => {
+    const src = `
+      function f() {
+        try {
+          throw 1;
+        } catch (e) {
+          return e;
+        }
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(show(r)).toBe("1");
+  });
+
+  it("string methods fold", () => {
+    expect(show(analyzeFn(`function f(){ return "abc".startsWith("a"); }`, "f", []))).toBe("true");
+    expect(show(analyzeFn(`function f(){ return "abc".toUpperCase(); }`, "f", []))).toBe('"ABC"');
+    expect(show(analyzeFn(`function f(){ return "hello".length; }`, "f", []))).toBe("5");
+  });
+
+  it("array join returns string", () => {
+    const r = analyzeFn(`function f(xs){ return xs.join(","); }`, "f", [
+      abs({ k: "arr", element: abs({ k: "prim", type: "string" }, undefined, undefined, "exact") }, undefined, undefined, "exact"),
+    ]);
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+
+  it("Math and global builtins on Abs", () => {
+    expect(show(analyzeFn(`function f(){ return Math.floor(3.7); }`, "f", []))).toBe("3");
+    expect(show(analyzeFn(`function f(){ return Math.max(1, 5); }`, "f", []))).toBe("5");
+    expect(show(analyzeFn(`function f(){ return Array.isArray([]); }`, "f", []))).toBe("true");
+    expect(show(analyzeFn(`function f(){ return parseInt("42"); }`, "f", []))).toBe("42");
+    expect(show(analyzeFn(`function f(){ return Number.isInteger(3); }`, "f", []))).toBe("true");
+  });
+
+  it("Object.keys of object shape", () => {
+    const src = `function f(){ return Object.keys({ a: 1, b: "x" }); }`;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "tuple" || r.shape.k === "arr").toBe(true);
+  });
+
+  it("Promise.resolve and then", () => {
+    const src = `
+      function f() {
+        return Promise.resolve(1).then((x) => x + 1);
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k).toBe("eff");
+  });
+
+  it("Date.now and RegExp.test", () => {
+    const n = analyzeFn(`function f(){ return Date.now(); }`, "f", []);
+    expect(n.shape.k === "prim" && (n.shape as { type: string }).type === "number").toBe(true);
+    const t = analyzeFn(`function f(){ return /a/.test("a"); }`, "f", []);
+    // 字面正则：.test 可能走 member 路径；至少 boolean 或 unknown
+    expect(t.shape.k === "prim" || t.shape.k === "unknown").toBe(true);
+  });
+
+  it("evalProgramAbs executes top-level", async () => {
+    const { evalProgramAbs } = await import("../ast-eval.ts");
+    const { env, last } = evalProgramAbs(`
+      const x = 1 + 2;
+      function inc(n) { return n + 1; }
+    `);
+    expect(env.vars.get("x")).toBeDefined();
+    expect(env.fns.has("inc")).toBe(true);
+  });
+});

package/src/algebra/__tests__/arithmetic.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from "vitest";
+import {
+  add,
+  sub,
+  mul,
+  div,
+  mod,
+  cmp,
+  numLit,
+  numVar,
+  strLit,
+  gtNum,
+  geNum,
+  ltNum,
+  lit,
+  v,
+  termToString,
+  predToString,
+  litValue,
+  implies,
+  simplifyTerm,
+  app,
+} from "../index.ts";
+
+describe("term simplify", () => {
+  it("folds 1+3", () => {
+    expect(simplifyTerm(app("+", [lit(1), lit(3)]))).toEqual(lit(4));
+  });
+  it("x+0 = x", () => {
+    expect(simplifyTerm(app("+", [v("x"), lit(0)]))).toEqual(v("x"));
+  });
+  it("0+x = x", () => {
+    expect(simplifyTerm(app("+", [lit(0), v("x")]))).toEqual(v("x"));
+  });
+  it("x*0 = 0", () => {
+    expect(simplifyTerm(app("*", [v("x"), lit(0)]))).toEqual(lit(0));
+  });
+});
+
+describe("add monotonicity", () => {
+  it("unconstrained any + 1: number|string 并集，term kept（real JS）", () => {
+    // 无契约时 x 是 any；score('x') 合法，+ 可能是拼接也可能是加法
+    const anyA = {
+      shape: { k: "any" as const },
+      term: v("A1"),
+      conf: "path" as const,
+    };
+    const r = add(anyA, numLit(1));
+    expect(r.shape.k).toBe("sum");
+    if (r.shape.k === "sum") {
+      const kinds = r.shape.members.map((m) =>
+        m.shape.k === "prim" ? (m.shape as { type: string }).type : m.shape.k,
+      );
+      expect(kinds.sort()).toEqual(["number", "string"]);
+    }
+    expect(termToString(r.term!)).toBe("(A1 + 1)");
+  });
+
+  it("unconstrained any - * / % → number (JS ToNumber)", () => {
+    const anyA = {
+      shape: { k: "any" as const },
+      term: v("A1"),
+      conf: "path" as const,
+    };
+    const one = numLit(1);
+    for (const [name, r] of [
+      ["sub", sub(anyA, one)],
+      ["mul", mul(anyA, one)],
+      ["div", div(anyA, one)],
+      ["mod", mod(anyA, one)],
+    ] as const) {
+      expect(r.shape, name).toEqual({ k: "prim", type: "number" });
+      expect(r.term, name).toBeDefined();
+    }
+    expect(termToString(sub(anyA, one).term!)).toBe("(A1 - 1)");
+  });
+
+  it("x>0 + 1 ⇒ term>1", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = add(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+  });
+
+  it("x>2 + y>3 ⇒ (x+y)>5", () => {
+    const phi = { op: "and" as const, args: [gtNum(v("x"), 2), gtNum(v("y"), 3)] };
+    const r = add(
+      numVar("x", gtNum(v("x"), 2)),
+      numVar("y", gtNum(v("y"), 3)),
+      phi,
+    );
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(5));
+    }
+  });
+
+  it("x≥1 + 0 literal keeps ≥ via simplify to x", () => {
+    const phi = geNum(v("x"), 1);
+    const r = add(numVar("x", geNum(v("x"), 1)), numLit(0), phi);
+    // x+0 simplifies to x
+    expect(termToString(r.term!)).toBe("x");
+  });
+
+  it("literal 2+3 = 5 exact", () => {
+    const r = add(numLit(2), numLit(3));
+    expect(litValue(r)).toBe(5);
+    expect(r.conf).toBe("exact");
+  });
+});
+
+describe("sub / mul", () => {
+  it("5-2 = 3", () => {
+    expect(litValue(sub(numLit(5), numLit(2)))).toBe(3);
+  });
+  it("x>0 - 1 ⇒ (x-1)>-1? x>0 ⇒ x-1 > -1", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = sub(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
+    expect(r.term).toBeDefined();
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(-1));
+    }
+  });
+  it("3*4 = 12", () => {
+    expect(litValue(mul(numLit(3), numLit(4)))).toBe(12);
+  });
+  it("x>0 * 2 ⇒ (x*2)>0", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(2), phi);
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(0));
+    }
+  });
+});
+
+describe("implies", () => {
+  it("x>0 ⊢ x>0", () => {
+    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊢ x≥0", () => {
+    expect(implies(gtNum(v("x"), 0), geNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊬ x>5", () => {
+    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 5))).toBe(false);
+  });
+  it("x>5 ⊢ x>0", () => {
+    expect(implies(gtNum(v("x"), 5), gtNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊢ x+1>1", () => {
+    const phi = gtNum(v("x"), 0);
+    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 1))).toBe(true);
+  });
+  it("x>0 ⊬ x+1>2", () => {
+    const phi = gtNum(v("x"), 0);
+    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 2))).toBe(false);
+  });
+});
+
+describe("cmp under phi", () => {
+  it("x>0, cmp(x, 0, >) → true", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = cmp("gt", numVar("x"), numLit(0), phi);
+    expect(litValue(r)).toBe(true);
+  });
+  it("1<3 → true", () => {
+    expect(litValue(cmp("lt", numLit(1), numLit(3)))).toBe(true);
+  });
+});

package/src/algebra/__tests__/ast-eval.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "vitest";
+import {
+  analyzeFn,
+  numLit,
+  numVar,
+  gtNum,
+  geNum,
+  v,
+  lit,
+  termToString,
+  predToString,
+  litValue,
+  leakIfNeeded,
+  maybeLeak,
+  exceedsBudget,
+  termDepth,
+  termNodes,
+  app,
+  resetLeakCounter,
+  mul,
+  add,
+} from "../index.ts";
+
+describe("AST eval: source → Abs", () => {
+  it("add(1,3) from real source → 4", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function main() { return add(1, 3); }
+    `;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(4);
+    expect(r.conf).toBe("exact");
+  });
+
+  it("scale(x) = add(x,1) under x>0 ⇒ (x+1)>1", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function scale(x) { return add(x, 1); }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "scale", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(r.term).toBeDefined();
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(1));
+    }
+  });
+
+  it("twice(x) nested add under x>0 ⇒ >2", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function twice(x) {
+        const c = add(x, 1);
+        return add(c, 1);
+      }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "twice", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(r.term).toBeDefined();
+    expect(r.pred).toBeDefined();
+    // ((x+1)+1) > 2 或 (x+2) > 2
+    const ps = predToString(r.pred!);
+    expect(ps).toContain("2");
+  });
+
+  it("if (x > 5) return x; return 0  with x>10 ⇒ x", () => {
+    const src = `
+      function pick(x) {
+        if (x > 5) return x;
+        return 0;
+      }
+    `;
+    const phi = gtNum(v("x"), 10);
+    const r = analyzeFn(src, "pick", [numVar("x", gtNum(v("x"), 10))], phi);
+    // true 分支返回 x（term=x），false 分支 0；join 后丢 term
+    // 但 true 分支在 Φ 下 x>5 成立，我们至少得到 number
+    expect(r.shape).toEqual({ k: "prim", type: "number" });
+  });
+
+  it("if (x > 0) return x + 1; return 0  with Φ x>0 ⇒ true branch", () => {
+    const src = `
+      function addOneIfPositive(x) {
+        if (x > 0) return x + 1;
+        return 0;
+      }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "addOneIfPositive", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+  });
+
+  it("literal only function", () => {
+    const src = `
+      function f() { return 1 + 2 * 3; }
+    `;
+    // 注意：JS 里 1+2*3 = 7，我们的 BinaryExpression 是左结合遍历
+    // Babel AST: (1 + (2 * 3)) —— 乘法优先，AST 已带优先级
+    const r = analyzeFn(src, "f", []);
+    expect(litValue(r)).toBe(7);
+  });
+
+  it("string concat from source", () => {
+    const src = `
+      function greet(name) { return "hi, " + name; }
+    `;
+    const r = analyzeFn(src, "greet", [numLit(1)]);
+    // number + string 在 JS 里是字符串，我们 isStrPrim 一侧即可
+    // 实参是 number，左侧是 string → 走 string 拼接
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+});
+
+describe("leak", () => {
+  it("small term does not leak", () => {
+    resetLeakCounter();
+    const t = app("+", [v("x"), lit(1)]);
+    expect(exceedsBudget(t)).toBe(false);
+    const a = add(numVar("x"), numLit(1));
+    const leaked = leakIfNeeded(a);
+    expect(leaked.term).toEqual(a.term);
+  });
+
+  it("deep term leaks to fresh var + eq", () => {
+    resetLeakCounter();
+    let t = v("x");
+    for (let i = 0; i < 10; i++) {
+      t = app("+", [t, lit(1)]);
+    }
+    expect(termDepth(t)).toBeGreaterThan(6);
+    expect(exceedsBudget(t)).toBe(true);
+
+    const a = { shape: { k: "prim" as const, type: "number" as const }, term: t, conf: "path" as const };
+    const leaked = maybeLeak(a, { maxDepth: 4, maxNodes: 20 }, "acc");
+    expect(leaked.term?.op).toBe("var");
+    if (leaked.term?.op === "var") {
+      expect(leaked.term.id.startsWith("acc$")).toBe(true);
+    }
+    expect(leaked.pred?.op).toBe("eq");
+  });
+});
+
+describe("mul negative flips bounds", () => {
+  it("x>0 * -2 ⇒ (x*-2) < 0", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(-2), phi);
+    expect(r.pred).toBeDefined();
+    expect(r.pred!.op).toBe("lt");
+    if (r.pred!.op === "lt") {
+      expect(r.pred!.b).toEqual(lit(0));
+    }
+  });
+});