@nudojs/cli 0.1.0 → 0.2.1

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", () => {

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);
+  });
+});