sift-light 1.0.0

package/src/test-navigation-facts.ts

@@ -0,0 +1,261 @@
+import { literalText, nodeText, type ModuleFacts } from "./import-model.js";
+import { syntaxField } from "./syntax-tree.js";
+
+const FUNCTIONS = new Set([
+  "function_declaration",
+  "function_expression",
+  "generator_function_declaration",
+  "generator_function",
+  "arrow_function",
+  "method_definition",
+]);
+const SCOPES = new Set([
+  ...FUNCTIONS,
+  "program",
+  "statement_block",
+  "catch_clause",
+  "for_statement",
+  "for_in_statement",
+  "class_body",
+]);
+const TEST_NAMES = new Set(["test", "it", "describe"]);
+const FRAMEWORKS = new Map([
+  ["node:test", "node:test"],
+  ["bun:test", "bun:test"],
+  ["vitest", "Vitest"],
+  ["@jest/globals", "Jest"],
+]);
+
+export interface TestCaseFact {
+  node: number;
+  name?: string;
+  callback?: number;
+  framework?: string;
+  testKind: string;
+  modifiers: string[];
+  status: "recognized" | "syntax-candidate";
+  notes: string[];
+}
+interface LocalBinding {
+  name: string;
+  node: number;
+  scope: number;
+}
+
+function nearestScope(
+  facts: ModuleFacts,
+  node: number | null | undefined,
+  functionOnly = false,
+): number {
+  let current = node;
+  while (current !== null && current !== undefined) {
+    const value = facts.syntax.nodes[current];
+    if (!value) break;
+    if (
+      functionOnly ? FUNCTIONS.has(value.kind) || value.kind === "program" : SCOPES.has(value.kind)
+    )
+      return current;
+    current = value.parent;
+  }
+  return 0;
+}
+
+function patternIdentifiers(facts: ModuleFacts, root: number | undefined): number[] {
+  if (root === undefined) return [];
+  const output: number[] = [];
+  const pending = [root];
+  while (pending.length) {
+    const id = pending.pop();
+    if (id === undefined) break;
+    const node = facts.syntax.nodes[id];
+    if (
+      !node ||
+      node.field === "type" ||
+      (node.field === "value" && facts.syntax.nodes[node.parent ?? -1]?.kind !== "pair_pattern") ||
+      node.field === "right" ||
+      node.field === "key" ||
+      node.kind === "type_annotation"
+    )
+      continue;
+    if (node.kind === "identifier" || node.kind === "shorthand_property_identifier_pattern")
+      output.push(id);
+    else pending.push(...(facts.syntax.children[id] ?? []));
+  }
+  return output;
+}
+
+/** Lexical ownership only. This intentionally makes no type/runtime binding claim. */
+export class TestBindings {
+  readonly facts: ModuleFacts;
+  #bindings = new Map<string, LocalBinding[]>();
+  #declarations = new Set<number>();
+  constructor(facts: ModuleFacts) {
+    this.facts = facts;
+    const add = (ids: number[], scope: number): void => {
+      for (const node of ids) {
+        this.#declarations.add(node);
+        const name = nodeText(facts, node) ?? "";
+        const values = this.#bindings.get(name) ?? [];
+        values.push({ name, node, scope });
+        this.#bindings.set(name, values);
+      }
+    };
+    for (let id = 0; id < facts.syntax.nodes.length; id++) {
+      const node = facts.syntax.nodes[id];
+      if (!node) continue;
+      if (node.kind === "variable_declarator") {
+        const parent = node.parent === null ? undefined : facts.syntax.nodes[node.parent];
+        add(
+          patternIdentifiers(facts, syntaxField(facts.syntax, id, "name")),
+          nearestScope(facts, node.parent, parent?.kind === "variable_declaration"),
+        );
+      }
+      if (FUNCTIONS.has(node.kind)) {
+        add(
+          patternIdentifiers(
+            facts,
+            syntaxField(facts.syntax, id, "parameters") ??
+              syntaxField(facts.syntax, id, "parameter"),
+          ),
+          id,
+        );
+        const name = syntaxField(facts.syntax, id, "name");
+        if (name !== undefined && node.kind !== "method_definition")
+          add([name], node.kind.endsWith("declaration") ? nearestScope(facts, node.parent) : id);
+      }
+      if (node.kind === "class_declaration" || node.kind === "class") {
+        const name = syntaxField(facts.syntax, id, "name");
+        if (name !== undefined)
+          add([name], node.kind === "class_declaration" ? nearestScope(facts, node.parent) : id);
+      }
+      if (node.kind === "catch_clause")
+        add(patternIdentifiers(facts, syntaxField(facts.syntax, id, "parameter")), id);
+    }
+  }
+  shadowed(name: string, occurrence: number): boolean {
+    const local = this.#bindings.get(name);
+    if (!local?.length) return false;
+    const ancestors = new Set<number>();
+    let current: number | null = occurrence;
+    while (current !== null) {
+      ancestors.add(current);
+      current = this.facts.syntax.nodes[current]?.parent ?? null;
+    }
+    return local.some((binding) => ancestors.has(binding.scope));
+  }
+  isReference(node: number): boolean {
+    const value = this.facts.syntax.nodes[node];
+    if (
+      !value ||
+      this.#declarations.has(node) ||
+      !["identifier", "shorthand_property_identifier"].includes(value.kind)
+    )
+      return false;
+    let current: number | null = value.parent;
+    while (current !== null) {
+      const ancestor = this.facts.syntax.nodes[current];
+      if (!ancestor) break;
+      if (
+        [
+          "import_statement",
+          "export_statement",
+          "type_annotation",
+          "type_arguments",
+          "type_parameters",
+          "type_alias_declaration",
+          "interface_declaration",
+        ].includes(ancestor.kind)
+      )
+        return false;
+      current = ancestor.parent;
+    }
+    return true;
+  }
+}
+
+interface Callee {
+  root: string;
+  rootNode: number;
+  properties: string[];
+}
+function callee(facts: ModuleFacts, node: number | undefined): Callee | undefined {
+  if (node === undefined) return undefined;
+  const value = facts.syntax.nodes[node];
+  if (!value) return undefined;
+  if (value.kind === "identifier")
+    return { root: nodeText(facts, node) ?? "", rootNode: node, properties: [] };
+  if (value.kind !== "member_expression") return undefined;
+  const object = callee(facts, syntaxField(facts.syntax, node, "object"));
+  const property = syntaxField(facts.syntax, node, "property");
+  if (
+    !object ||
+    property === undefined ||
+    facts.syntax.nodes[property]?.kind !== "property_identifier"
+  )
+    return undefined;
+  return { ...object, properties: [...object.properties, nodeText(facts, property) ?? ""] };
+}
+
+export function collectTestCases(facts: ModuleFacts, bindings: TestBindings): TestCaseFact[] {
+  const cases: TestCaseFact[] = [];
+  for (let id = 0; id < facts.syntax.nodes.length; id++) {
+    if (facts.syntax.nodes[id]?.kind !== "call_expression") continue;
+    const call = callee(facts, syntaxField(facts.syntax, id, "function"));
+    if (!call) continue;
+    const imported = facts.imports.find((binding) => binding.local === call.root);
+    const properties = [...call.properties];
+    let kind = call.root;
+    let framework: string | undefined;
+    const notes: string[] = [];
+    if (imported && !imported.typeOnly && !bindings.shadowed(call.root, call.rootNode)) {
+      framework = FRAMEWORKS.get(imported.source ?? "");
+      if (imported.kind === "namespace") kind = properties.shift() ?? "";
+      else if (imported.kind === "default" && imported.source === "node:test") kind = "test";
+      else kind = imported.imported;
+    } else if (imported) notes.push("test-binding-shadowed-or-type-only");
+    if (!TEST_NAMES.has(kind)) continue;
+    if (!framework) notes.push("framework-binding-unresolved");
+    const modifiers = properties.filter((property) => property === "skip" || property === "only");
+    if (modifiers.length !== properties.length || modifiers.length > 1)
+      notes.push("parameterized-or-custom-test-wrapper-unsupported");
+    const argumentsNode = syntaxField(facts.syntax, id, "arguments");
+    const argumentsList =
+      argumentsNode === undefined
+        ? []
+        : (facts.syntax.children[argumentsNode] ?? []).filter(
+            (child) =>
+              facts.syntax.nodes[child]?.named && facts.syntax.nodes[child]?.kind !== "comment",
+          );
+    const nameNode = argumentsList[0];
+    const nameKind = nameNode === undefined ? undefined : facts.syntax.nodes[nameNode]?.kind;
+    const name =
+      nameKind === "string" || nameKind === "template_string"
+        ? literalText(nodeText(facts, nameNode))
+        : undefined;
+    if (name === undefined) notes.push("dynamic-or-missing-test-name");
+    const last = argumentsList.at(-1);
+    const callback =
+      last !== undefined &&
+      ["arrow_function", "function_expression", "generator_function"].includes(
+        facts.syntax.nodes[last]?.kind ?? "",
+      )
+        ? last
+        : undefined;
+    if (callback === undefined) notes.push("explicit-test-callback-unavailable");
+    const supportedArguments =
+      argumentsList.length === 2 ||
+      (argumentsList.length === 3 && facts.syntax.nodes[argumentsList[1] ?? -1]?.kind === "object");
+    if (!supportedArguments) notes.push("test-arguments-unsupported");
+    cases.push({
+      node: id,
+      ...(name !== undefined ? { name } : {}),
+      ...(callback !== undefined ? { callback } : {}),
+      ...(framework !== undefined ? { framework } : {}),
+      testKind: kind,
+      modifiers,
+      status: notes.length === 0 ? "recognized" : "syntax-candidate",
+      notes,
+    });
+  }
+  return cases;
+}