@nudojs/service 0.2.1 → 0.3.0

package/src/__tests__/bpath-arg-provenance.test.ts

@@ -0,0 +1,104 @@
+import { it, expect, describe, afterAll } from "vitest";
+import { analyzeFile, clearBPathCache } from "@nudojs/service";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function analyze(src: string) {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-prov-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "prov", version: "1.0.0" }));
+  writeFileSync(join(dir, "index.js"), src);
+  clearBPathCache();
+  return analyzeFile(join(dir, "index.js"), src);
+}
+
+describe("B argument provenance on method-missing", () => {
+  it("origin points at the argument literal, not just the callee", () => {
+    const src = `function badNum(n) {
+  return n.toUpperCase();
+}
+const boom = badNum(42);
+`;
+    const r = analyze(src);
+    const diags = r.diagnostics.filter(
+      (d) => d.code === "nudo:no-method" && d.message.includes("toUpperCase"),
+    );
+    expect(diags.length).toBe(1);
+    const origin = diags[0]!.origin;
+    expect(origin).toBeDefined();
+    // `const boom = badNum(42);` — 42 starts at column 20
+    expect(origin!.line).toBe(4);
+    expect(origin!.column).toBeGreaterThanOrEqual(18);
+    expect(origin!.column).toBeLessThanOrEqual(22);
+  });
+
+  it("mocked top-level call does not hit real fetch", () => {
+    const src = `// @nudo:mock fetch = sinon.stub().onFirstCall().returns({ data: "first" })
+function run() { return fetch(); }
+const r = run();
+function badNum(n) {
+  return n.toUpperCase();
+}
+const boom = badNum(7);
+`;
+    const r = analyze(src);
+    const fetchErrs = r.diagnostics.filter(
+      (d) => d.message.includes("fetch") && d.severity === "error",
+    );
+    expect(fetchErrs).toHaveLength(0);
+    const diags = r.diagnostics.filter(
+      (d) => d.code === "nudo:no-method" && d.message.includes("toUpperCase"),
+    );
+    expect(diags.length).toBe(1);
+    expect(diags[0]!.origin?.column).toBeGreaterThanOrEqual(16);
+  });
+
+  it("unknown-global is not double-reported with builtin-unknown", () => {
+    const src = `function f() {
+  return WeakRef;
+}
+const boom = f();
+`;
+    const r = analyze(src);
+    const globals = r.diagnostics.filter((d) => d.code === "nudo:unknown-global");
+    const builtins = r.diagnostics.filter((d) => d.code === "nudo:builtin-unknown");
+    expect(builtins.some((d) => d.message.includes("WeakRef"))).toBe(true);
+    expect(globals.filter((d) => d.message.includes("WeakRef"))).toHaveLength(0);
+  });
+
+  it("B reports unknown-recv for method on unknown param (no TypeValue double)", () => {
+    const src = `function lonely(u) {
+  return u.toUpperCase();
+}
+`;
+    const r = analyze(src);
+    const unknownRecv = r.diagnostics.filter(
+      (d) => d.code === "nudo:unknown-recv" && d.message.includes("toUpperCase"),
+    );
+    expect(unknownRecv.length).toBe(1);
+    expect(unknownRecv[0]!.severity).toBe("warning");
+    // B 已报则不应再有 no-method 同名
+    expect(
+      r.diagnostics.filter((d) => d.code === "nudo:no-method" && d.message.includes("toUpperCase")),
+    ).toHaveLength(0);
+  });
+
+  it("B reports unknown-recv for property on unknown", () => {
+    const src = `function lonely(u) {
+  return u.foo;
+}
+`;
+    const r = analyze(src);
+    const diags = r.diagnostics.filter(
+      (d) => (d.code === "nudo:unknown-recv" || d.code === "nudo:no-method") && d.message.includes("foo"),
+    );
+    expect(diags.length).toBeGreaterThanOrEqual(1);
+    expect(diags.some((d) => d.code === "nudo:unknown-recv")).toBe(true);
+  });
+});

package/src/__tests__/bpath-as.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+describe("@nudo:as on B path", () => {
+  it("overrides VariableDeclaration init value", () => {
+    const source = `
+/**
+ * @nudo:case "test" ("{}")
+ */
+function loadConfig(path) {
+  // @nudo:as T.object({ port: T.number, host: T.string })
+  const config = JSON.parse(path);
+  return config;
+}
+`;
+    const result = analyzeFile("/test/as.js", source);
+    const res = typeValueToString(result.functions[0].cases[0].result);
+    expect(res).toContain("port: number");
+    expect(res).toContain("host: string");
+  });
+
+  it("overrides ReturnStatement value", () => {
+    const source = `
+/**
+ * @nudo:case "test" ("{}")
+ */
+function loadConfig(path) {
+  // @nudo:as T.object({ name: T.string, age: T.number })
+  return JSON.parse(path);
+}
+`;
+    const result = analyzeFile("/test/as2.js", source);
+    const res = typeValueToString(result.functions[0].cases[0].result);
+    expect(res).toContain("name: string");
+    expect(res).toContain("age: number");
+  });
+
+  it("does not affect statements without @nudo:as", () => {
+    const source = `
+/**
+ * @nudo:case "test" (5)
+ */
+function add(x) {
+  // @nudo:as T.literal(99)
+  const y = x + 1;
+  const z = x + 2;
+  return z;
+}
+`;
+    const result = analyzeFile("/test/as3.js", source);
+    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("7");
+  });
+});

package/src/__tests__/bpath-cache-key.test.ts

@@ -0,0 +1,33 @@
+import { it, expect, describe, afterEach } from "vitest";
+import { tryRunBPath, tryBPathCall, clearBPathCache } from "@nudojs/service";
+import { litValue } from "@nudojs/core";
+
+afterEach(() => clearBPathCache());
+
+describe("bRunCache key", () => {
+  // 同长度、前 200+ 字符完全相同、尾部不同的两份源码：
+  // 旧前缀截断键会命中同一条缓存，静默返回陈旧结果。
+  const head = `// ${"x".repeat(210)}\nexport function f() { return `;
+  const srcA = `${head}1; }`;
+  const srcB = `${head}2; }`;
+
+  it("same source twice returns the identical cached run", () => {
+    const a = tryRunBPath(srcA, "/test/cache-key.js");
+    const b = tryRunBPath(srcA, "/test/cache-key.js");
+    expect(a).toBeDefined();
+    expect(b).toBe(a);
+  });
+
+  it("same length + same prefix but different tail must not collide", () => {
+    const r1 = tryRunBPath(srcA, "/test/cache-key.js");
+    const r2 = tryRunBPath(srcB, "/test/cache-key.js");
+    expect(r1).toBeDefined();
+    expect(r2).toBeDefined();
+    expect(r2).not.toBe(r1);
+
+    // 语义正确性：srcB 的求值必须看到 f() = 2，而非 srcA 的陈旧 1
+    const out = tryBPathCall(srcB, "/test/cache-key.js", "f", []);
+    if (!out) throw new Error("expected f to resolve via B path");
+    expect(litValue(out)).toBe(2);
+  });
+});

package/src/__tests__/bpath-calls.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { tryBPathCallFull, analyzeFile } from "@nudojs/service";
+import { $lit, litValue, typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path call site collection", () => {
+  it("records calls during B evaluation", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-bcall-"));
+    dirs.push(dir);
+    const src = `
+function helper(x) { return x + 1; }
+export function caller(n) { return helper(n); }
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, src, "utf-8");
+    const full = tryBPathCallFull(src, p, "caller", [$lit(4)], { collectCalls: true });
+    expect(full).toBeDefined();
+    expect(litValue(full!.result)).toBe(5);
+    expect(full!.calls?.length).toBeGreaterThanOrEqual(1);
+    expect(full!.calls!.map((c) => c.fnName)).toContain("helper");
+  });
+
+  it("analyzeFile still synthesizes call@ for uncalled helper", () => {
+    const source = `
+function uncalled(x) {
+  return x * 2;
+}
+
+/**
+ * @nudo:case "t" (5)
+ */
+function caller(y) {
+  return uncalled(y);
+}
+`;
+    const result = analyzeFile("/test/bcall.js", source);
+    const uncalled = result.functions.find((f) => f.name === "uncalled");
+    expect(uncalled).toBeDefined();
+    expect(uncalled!.cases.length).toBeGreaterThanOrEqual(1);
+    const names = uncalled!.cases.map((c) => c.name);
+    expect(names.some((n) => n.startsWith("call@") || n.startsWith("entry@"))).toBe(true);
+    // 结果应为 10
+    const hit = uncalled!.cases.find((c) => c.name.startsWith("call@"));
+    if (hit) {
+      expect(typeValueToString(hit.result)).toBe("10");
+    }
+  });
+});

package/src/__tests__/bpath-diagnostics.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { collectBPathDiagnostics } from "@nudojs/service";
+
+describe("B-path static diagnostics", () => {
+  it("marks statements after return as unreachable", () => {
+    const src = `
+function f() {
+  return 1;
+  const dead = 2;
+  console.log("no");
+}
+`;
+    const d = collectBPathDiagnostics(src);
+    expect(d.unreachable.length).toBeGreaterThanOrEqual(1);
+    // dead 声明与后续 console
+    const lines = d.unreachable.map((u) => u.range.start.line);
+    expect(lines.some((l) => l >= 4)).toBe(true);
+  });
+
+  it("marks statements after throw as unreachable", () => {
+    const src = `
+function f(n) {
+  if (n) {
+    throw new Error("x");
+    return 1;
+  }
+  return 0;
+}
+`;
+    const d = collectBPathDiagnostics(src);
+    expect(d.unreachable.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("does not flag code after if/else both return", () => {
+    const src = `
+function f(n) {
+  if (n) { return 1; } else { return 2; }
+}
+`;
+    const d = collectBPathDiagnostics(src);
+    // if 内无后续语句
+    expect(d.unreachable).toHaveLength(0);
+  });
+
+  it("flags unknown global calls as builtin-unknown", () => {
+    const src = `
+function f() {
+  return someNativeApi(1);
+}
+`;
+    const d = collectBPathDiagnostics(src);
+    expect(d.builtinUnknown.map((b) => b.name)).toContain("someNativeApi");
+  });
+
+  it("extraKnown (@nudo:mock / @nudo:env covered) globals are not flagged", () => {
+    const src = `
+function f() {
+  return someNativeApi(1);
+}
+`;
+    expect(collectBPathDiagnostics(src, ["someNativeApi"]).builtinUnknown).toHaveLength(0);
+    // 无覆盖时仍报
+    expect(collectBPathDiagnostics(src).builtinUnknown.map((b) => b.name)).toContain("someNativeApi");
+  });
+
+  it("does not flag locals, imports, or known globals", () => {
+    const src = `
+import { helper } from "./h.js";
+function local(x) { return x; }
+function f() {
+  const y = local(1);
+  return helper(y) + Math.max(1, 2) + JSON.stringify(y);
+}
+`;
+    const d = collectBPathDiagnostics(src);
+    expect(d.builtinUnknown).toHaveLength(0);
+  });
+});

package/src/__tests__/bpath-env-modules.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { analyzeFile, clearBPathCache } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path env modules (node:path)", () => {
+  it("path.join via import from node:path", () => {
+    clearBPathCache();
+    const source = `/// @nudo:env node
+
+import { join } from "node:path";
+
+/**
+ * @nudo:case "test" ("src", "utils", "index.js")
+ */
+function buildPath(a, b, c) {
+  return join(a, b, c);
+}
+`;
+    const result = analyzeFile("/test/pathmod.js", source);
+    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"src/utils/index.js"');
+  });
+});

package/src/__tests__/bpath-env.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { analyzeFile, tryBPathCall, isBPathCapable, clearBPathCache } from "@nudojs/service";
+import { typeValueToString, $lit, absToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path @nudo:env", () => {
+  it("isBPathCapable allows builtin and path env", () => {
+    expect(isBPathCapable("function f() { return 1; }", ["es"])).toBe(true);
+    expect(isBPathCapable("function f() { return 1; }", ["./custom.ts"])).toBe(true);
+  });
+
+  it("JSON.parse via @nudo:env es", () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-env-"));
+    dirs.push(dir);
+    const main = `/// @nudo:env es
+
+/**
+ * @nudo:case "t" ("{}")
+ */
+export function parseId(s) {
+  return typeof JSON.parse(s);
+}
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, main, "utf-8");
+    const r = tryBPathCall(main, p, "parseId", [$lit("{}")], { envNames: ["es"] });
+    expect(r).toBeDefined();
+    expect(absToString(r!)).toContain("string");
+  });
+
+  it("analyzeFile works with @nudo:env es", () => {
+    clearBPathCache();
+    const source = `/// @nudo:env es
+
+/**
+ * @nudo:case "t" (5)
+ */
+function addOne(n) {
+  return Math.floor(n) + 1;
+}
+`;
+    const result = analyzeFile("/test/env.js", source);
+    const fn = result.functions.find((f) => f.name === "addOne");
+    expect(fn).toBeDefined();
+    expect(typeValueToString(fn!.cases[0].result)).toBe("6");
+  });
+
+  it("arrowFn @nudo:mock injects into B-path (no real fetch call)", () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-mock-b-"));
+    dirs.push(dir);
+    // 回归：arrowFn mock 落在 seedFns，此前 B 路径注入只吃 seedVars——
+    // 函数体内的 fetch 调用落到真实原生 fetch，拿 Abs 当 URL 直接崩
+    const source = `// @nudo:mock fetch = (url) => ({ ok: true, json: () => ({ id: 1, name: "ada" }) })
+async function loadUser(id) {
+  const res = await fetch("/users/" + id);
+  return res.json();
+}
+loadUser(42);
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, source, "utf-8");
+    const result = analyzeFile(p, source);
+    const fn = result.functions.find((f) => f.name === "loadUser");
+    expect(fn).toBeDefined();
+    const call = fn!.cases.find((c) => c.name.startsWith("call@"));
+    expect(call).toBeDefined();
+    expect(call!.intension?.abs).toContain("ada");
+    // mock 覆盖后 fetch 不再是 builtin-unknown
+    expect(result.diagnostics.some((d) => d.code === "nudo:builtin-unknown")).toBe(false);
+  });
+});

package/src/__tests__/bpath-hosted-skip.test.ts

@@ -0,0 +1,71 @@
+import { it, expect, describe, afterAll } from "vitest";
+import { analyzeFile, clearBPathCache, isBPathCapable } from "@nudojs/service";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function analyze(src: string, file = "index.js") {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-hosted-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "hosted", version: "1.0.0" }));
+  const p = join(dir, file);
+  writeFileSync(p, src);
+  clearBPathCache();
+  return { result: analyzeFile(p, src), path: p, src };
+}
+
+describe("B-hosted skips TypeValue evaluateProgram", () => {
+  it("capable file is B-hosted and still infers cases", () => {
+    const src = `/**
+ * @nudo:case "n" (3)
+ */
+export function scale(x) {
+  return x * 2 + 1;
+}
+`;
+    const { result, path } = analyze(src);
+    expect(isBPathCapable(src, [])).toBe(true);
+    const fn = result.functions.find((f) => f.name === "scale");
+    expect(fn?.cases).toHaveLength(1);
+    expect(fn?.cases[0]?.result.kind).toBe("literal");
+    // 无 TypeValue 专有叠报
+    expect(result.diagnostics.filter((d) => d.code === "nudo:unknown-global")).toHaveLength(0);
+    expect(result.bindings.has("scale")).toBe(true);
+  });
+
+  it("import + top-level call still yields call@ cases", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-hosted2-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "h2", version: "1.0.0" }));
+    writeFileSync(
+      join(dir, "util.js"),
+      `export function twice(n) { return n * 2; }
+`,
+    );
+    const src = `import { twice } from "./util.js";
+const boom = twice(21);
+export function go(n) { return twice(n); }
+`;
+    writeFileSync(join(dir, "index.js"), src);
+    clearBPathCache();
+    const r = analyzeFile(join(dir, "index.js"), src);
+    const go = r.functions.find((f) => f.name === "go");
+    const twice = r.functions.find((f) => f.name === "twice");
+    expect(go).toBeDefined();
+    // 跨文件导出可能合成 externalFunctions 或本文件 twice
+    expect(go!.cases.length + (twice?.cases.length ?? 0)).toBeGreaterThan(0);
+  });
+
+  it("nodeTypeMap is populated without TypeValue env walk", () => {
+    const src = `const n = 1;
+export function id(x) { return x; }
+`;
+    const { result } = analyze(src);
+    expect(result.nodeTypeMap.size).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/bpath-import-default-ns.test.ts

@@ -0,0 +1,106 @@
+import { it, expect, describe, afterAll } from "vitest";
+import { analyzeFile, clearBPathCache } from "@nudojs/service";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function setup() {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-imp-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "imp", version: "1.0.0" }));
+  writeFileSync(
+    join(dir, "util.js"),
+    `export function add(a, b) {
+  return a + b;
+}
+export default function mul(a, b) {
+  return a * b;
+}
+`,
+  );
+  return dir;
+}
+
+function goResult(dir: string, src: string) {
+  writeFileSync(join(dir, "index.js"), src);
+  const r = analyzeFile(join(dir, "index.js"), src);
+  const go = r.functions.find((f) => f.name === "go");
+  return { result: go?.cases[0]?.result, diagnostics: r.diagnostics };
+}
+
+describe("B-path import default / namespace", () => {
+  it("named import", () => {
+    clearBPathCache();
+    const dir = setup();
+    const { result } = goResult(
+      dir,
+      `import { add } from "./util.js";
+/**
+ * @nudo:case "nums" (1, 2)
+ */
+export function go(a, b) {
+  return add(a, b);
+}
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 3 });
+  });
+
+  it("default import of export default function", () => {
+    clearBPathCache();
+    const dir = setup();
+    const { result, diagnostics } = goResult(
+      dir,
+      `import mul from "./util.js";
+/**
+ * @nudo:case "nums" (3, 4)
+ */
+export function go(a, b) {
+  return mul(a, b);
+}
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 12 });
+    expect(diagnostics.filter((d) => d.severity === "error")).toHaveLength(0);
+  });
+
+  it("namespace import member call", () => {
+    clearBPathCache();
+    const dir = setup();
+    const { result, diagnostics } = goResult(
+      dir,
+      `import * as util from "./util.js";
+/**
+ * @nudo:case "nums" (5, 6)
+ */
+export function go(a, b) {
+  return util.add(a, b);
+}
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 11 });
+    expect(diagnostics.filter((d) => d.severity === "error")).toHaveLength(0);
+  });
+
+  it("namespace import default slot", () => {
+    clearBPathCache();
+    const dir = setup();
+    const { result } = goResult(
+      dir,
+      `import * as util from "./util.js";
+/**
+ * @nudo:case "nums" (2, 5)
+ */
+export function go(a, b) {
+  return util.default(a, b);
+}
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 10 });
+  });
+});

package/src/__tests__/bpath-method-dedupe.test.ts

@@ -0,0 +1,65 @@
+import { it, expect, describe } from "vitest";
+import { analyzeFile } from "@nudojs/service";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+function analyze(src: string) {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-bdedup-"));
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "bdedup", version: "1.0.0" }));
+  writeFileSync(join(dir, "index.js"), src);
+  return analyzeFile(join(dir, "index.js"), src);
+}
+
+describe("B method-missing provenance + dedupe", () => {
+  it("no-method is not double-reported when B and TypeValue both see the call", () => {
+    // B case 执行 + evaluateProgram 顶层 const 调用都会碰到 toUpperCase 缺失；
+    // 按名去重后只应剩一条。
+    const src = `
+/**
+ * @nudo:case "n" (42)
+ */
+function demo(n) {
+  return n.toUpperCase();
+}
+
+const boom = demo(42);
+`;
+    const r = analyze(src);
+    const methodDiags = r.diagnostics.filter(
+      (d) => d.code === "nudo:no-method" && d.message.includes("toUpperCase"),
+    );
+    expect(methodDiags.length).toBe(1);
+  });
+
+  it("TypeValue-only method diags are kept when B does not report the name", () => {
+    const src = `
+function badNum(n) {
+  return n.toUpperCase();
+}
+const boom = badNum(42);
+`;
+    const r = analyze(src);
+    const diags = r.diagnostics.filter((d) => d.code === "nudo:no-method");
+    expect(diags.length).toBeGreaterThanOrEqual(1);
+    expect(diags.some((d) => d.message.includes("toUpperCase"))).toBe(true);
+  });
+
+  it("same name:line is reported at most once", () => {
+    const src = `
+/**
+ * @nudo:case "null" (null)
+ * @nudo:case "num" (1)
+ */
+function demo(o) {
+  return o.foo;
+}
+`;
+    const r = analyze(src);
+    const fooDiags = r.diagnostics.filter(
+      (d) => d.code === "nudo:no-method" && d.message.includes("'foo'"),
+    );
+    const keys = fooDiags.map((d) => `${d.range.start.line}:${d.message}`);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+});