@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.19

package/src/query.ts

@@ -207,8 +207,22 @@ export interface Queries {
   constraintOf(type: Type): Answer<Type | undefined>;
   /** The object and the index of an indexed-access type; none for another type. */
   indexedAccessOf(type: Type): Answer<{ readonly object: Type; readonly index: Type } | undefined>;
+  /**
+   * The types one type is spelled from besides its constituents, type arguments and members:
+   * a type parameter's constraint and default, a conditional's check, extends, true
+   * and false types, a mapped type's constraint, name and template, an indexed access's
+   * object and index, the operand of `keyof` or of a string mapping, a template literal's
+   * spans and a substitution's base and constraint. None for another type.
+   */
+  partsOf(type: Type): Answer<readonly Type[]>;
+  /** The type parameters of a signature, its `this` parameter's type and its predicate's type. */
+  signaturePartsOf(signature: Signature): Answer<readonly Type[]>;
   /** The symbol a type is declared by. */
   symbolOfType(type: Type): Answer<TSSymbol | undefined>;
+  /** The type alias a type was instantiated from, where it was. */
+  aliasSymbolOf(type: Type): Answer<TSSymbol | undefined>;
+  /** The type arguments the alias a type was instantiated from was given. */
+  aliasArgumentsOf(type: Type): Answer<readonly Type[]>;
   signaturesOf(type: Type, kind: SignatureKind): Answer<readonly Signature[]>;
   resolvedSignature(node: Node): Answer<Signature | undefined>;
   /** The signature each call-like node resolves to. */
@@ -223,6 +237,37 @@ export interface Queries {
   typeToString(type: Type): Answer<string>;
 }
 
+/** How to read the types one type is spelled from, as {@link Queries.partsOf} names them. */
+function partQuestion(type: Type): (() => readonly (Type | undefined)[]) | undefined {
+  if (type.isTypeParameter()) {
+    return () => [type.getConstraint(), type.getDefault()];
+  }
+  if (type.isConditionalType()) {
+    return () => [
+      type.getCheckType(),
+      type.getExtendsType(),
+      type.getTrueType(),
+      type.getFalseType(),
+    ];
+  }
+  if (type.isMappedType()) {
+    return () => [type.getConstraintType(), type.getNameType(), type.getTemplateType()];
+  }
+  if (type.isIndexedAccessType()) {
+    return () => [type.getObjectType(), type.getIndexType()];
+  }
+  if (type.isIndexType() || type.isStringMappingType()) {
+    return () => [type.getTarget()];
+  }
+  if (type.isTemplateLiteralType()) {
+    return () => type.getTypes();
+  }
+  if (type.isSubstitutionType()) {
+    return () => [type.getBaseType(), type.getConstraint()];
+  }
+  return undefined;
+}
+
 /**
  * The guarded questions over one project's checker. `configFile` names the project
  * in the log, `batch` sends many questions in one round trip, `log` is the run's,
@@ -528,12 +573,48 @@ export function queriesOf(
             () => ({ object: type.getObjectType(), index: type.getIndexType() }),
           )
         : undefined,
+    partsOf: (type) => {
+      const parts = partQuestion(type);
+      return parts === undefined
+        ? []
+        : one(
+            "getParts",
+            () => typeLocation(type),
+            () => parts().filter((part) => part !== undefined),
+          );
+    },
+    signaturePartsOf: (signature) =>
+      one(
+        "getSignatureParts",
+        () => `signature ${String(signature.id)}`,
+        () => {
+          const self =
+            signature.thisParameter === undefined ? undefined : signature.getThisParameter();
+          return [
+            ...((signature.typeParameters ?? []).length === 0 ? [] : signature.getTypeParameters()),
+            self === undefined ? undefined : checker.getTypeOfSymbol(self),
+            checker.getTypePredicateOfSignature(signature)?.type,
+          ].filter((part) => part !== undefined);
+        },
+      ),
     symbolOfType: (type) =>
       one(
         "getSymbol",
         () => typeLocation(type),
         () => type.getSymbol(),
       ),
+    aliasSymbolOf: (type) =>
+      one(
+        "getAliasSymbol",
+        () => typeLocation(type),
+        () => type.getAliasSymbol(),
+      ),
+    aliasArgumentsOf: (type) =>
+      one(
+        "getAliasTypeArguments",
+        () => typeLocation(type),
+        () => type.getAliasTypeArguments(),
+      ),
     signaturesOf: (type, kind) =>
       one(
         "getSignaturesOfType",

package/src/references/sink.ts

@@ -25,6 +25,13 @@ interface Valued {
   readonly value: Node;
 }
 
+/** One record by its file, with the node that names its target and whether `from`'s own annotation holds it. */
+interface Named {
+  readonly index: number;
+  readonly at: Node;
+  readonly annotated: boolean;
+}
+
 /**
  * Where every reference of one pass is made: it renders the position against the side's
  * root, takes the writing file's test class from the file classes, marks a use only a
@@ -36,17 +43,21 @@ export class Sink {
   readonly #testFile: (file: SourceFile) => boolean;
   readonly #consumer: ConsumerSide | undefined;
   readonly #found: Reference[] = [];
+  readonly #declaredAt: (node: Node) => string | undefined;
   readonly #valued = new Map<SourceFile, Valued[]>();
+  readonly #named = new Map<SourceFile, Named[]>();
   readonly #held = new Set<string>();
 
   constructor(
     root: string,
     testFile: (file: SourceFile) => boolean,
     consumer: ConsumerSide | undefined,
+    declaredAt: (node: Node) => string | undefined,
   ) {
     this.#root = root;
     this.#testFile = testFile;
     this.#consumer = consumer;
+    this.#declaredAt = declaredAt;
   }
 
   /** Whether a test file wrote one walked file's uses. */
@@ -87,6 +98,11 @@ export class Sink {
         test,
         ...(target.guessed === true ? { guessed: true as const } : {}),
       });
+      if (this.#consumer === undefined && !("column" in at)) {
+        const named = this.#named.get(file) ?? [];
+        named.push({ index: this.#found.length - 1, at, annotated: this.#annotates(at, from) });
+        this.#named.set(file, named);
+      }
       if (use === "write" && value !== undefined) {
         const valued = this.#valued.get(file) ?? [];
         valued.push({ index: this.#found.length - 1, value });
@@ -95,6 +111,27 @@ export class Sink {
     }
   }
 
+  /**
+   * Whether a name sits in the annotation of `from`'s own declaration. An annotation holds
+   * no block, so the walk stops at the first declaration or block above the name.
+   */
+  #annotates(name: Node, from: string): boolean {
+    if (name.kind === SyntaxKind.SourceFile) {
+      return false;
+    }
+    let child = name;
+    let parent = name.parent;
+    while (parent.kind !== SyntaxKind.Block && parent.kind !== SyntaxKind.SourceFile) {
+      const id = this.#declaredAt(parent);
+      if (id !== undefined) {
+        return id === from && (parent as { readonly type?: Node }).type === child;
+      }
+      child = parent;
+      parent = parent.parent;
+    }
+    return false;
+  }
+
   /** Holds declarations an unanswered question could have made live, and the one whose read asked it. */
   hold(ids: Iterable<string>): void {
     for (const id of ids) {
@@ -130,6 +167,14 @@ export class Sink {
         }
       }
     }
+    for (const [file, named] of this.#named) {
+      for (const { index, carriers } of carriersIn(named, this.#valued.get(file) ?? [], found)) {
+        const reference = found[index];
+        if (reference !== undefined) {
+          found[index] = { ...reference, carriers };
+        }
+      }
+    }
     found.sort(
       (a, b) =>
         byPosition(a.position, b.position) ||
@@ -211,3 +256,59 @@ function aloneIn(
   }
   return result;
 }
+
+/**
+ * The carriers of each named record of one file: `from` where its own annotation holds the
+ * name, then the target of each write whose stored value holds it and that names another
+ * declaration, the innermost value first. Values nest or are disjoint.
+ */
+function carriersIn(
+  named: readonly Named[],
+  writes: readonly Valued[],
+  found: readonly Reference[],
+): readonly { index: number; carriers: readonly string[] }[] {
+  const byStart = [...named].sort((a, b) => a.at.pos - b.at.pos);
+  const holding = new Map<number, Valued[]>();
+  for (const write of writes) {
+    let low = 0;
+    let high = byStart.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if ((byStart[middle]?.at.pos ?? 0) < write.value.pos) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    for (let at = low; at < byStart.length; at += 1) {
+      const one = byStart[at];
+      if (one === undefined || one.at.pos >= write.value.end) {
+        break;
+      }
+      if (one.at.end <= write.value.end) {
+        holding.set(one.index, [...(holding.get(one.index) ?? []), write]);
+      }
+    }
+  }
+  const result: { index: number; carriers: readonly string[] }[] = [];
+  for (const one of named) {
+    const reference = found[one.index];
+    if (reference === undefined) {
+      continue;
+    }
+    const carriers = one.annotated ? [reference.from] : [];
+    const values = [...(holding.get(one.index) ?? [])].sort(
+      (a, b) => a.value.end - a.value.pos - (b.value.end - b.value.pos),
+    );
+    for (const write of values) {
+      const to = found[write.index]?.to;
+      if (to !== undefined && to !== reference.to && !carriers.includes(to)) {
+        carriers.push(to);
+      }
+    }
+    if (carriers.length > 0) {
+      result.push({ index: one.index, carriers });
+    }
+  }
+  return result;
+}

package/src/references.ts

@@ -94,6 +94,13 @@ export interface Reference {
    * declaration with its writes deletes too.
    */
   readonly alone?: readonly string[];
+  /**
+   * The declarations whose deletion with their writes deletes the referencing name,
+   * innermost first: `from` where the name is in its own annotation, then each declaration
+   * a write of the same file stores into whose stored value holds the name. Absent where
+   * there is none, and on a consumer's reference.
+   */
+  readonly carriers?: readonly string[];
 }
 
 /** The consumer one reference pass reads the files of, beside the target it names. */
@@ -185,13 +192,13 @@ export function references<Brand>(
               relativePath(consumer.root, file.fileName) !== undefined &&
               relativePath(targetRoot, file.fileName) === undefined,
           );
-  const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer);
   const ownPaths = project.ownPaths();
   const fileIds = new Set(
     held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id),
   );
   const declaredAt = (node: Node): string | undefined =>
     declarations.get(nodeKey(node.getSourceFile(), node));
+  const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer, declaredAt);
 
   let moduleBodies: ReadonlyMap<string, readonly InventorySymbol[]> | undefined;
   /**

package/src/roots/manifest.ts

@@ -9,6 +9,7 @@ import type { Host } from "../host.ts";
 import { isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.ts";
 import { isRecord } from "../json-document.ts";
 import { MANIFEST, manifestAt, readJSON } from "../fs/manifest.ts";
+import type { HeldText } from "../commands/held.ts";
 import { pathsNamed, readCommands } from "../commands/read.ts";
 
 /** The three members that name an entry point beside `exports` and `bin`. */
@@ -41,12 +42,12 @@ export interface ManifestEntry {
   /** The directory of the manifest that names it, which `path` was resolved against. */
   readonly dir: string;
   /**
-   * On an entry that names no entry point, whose path is the manifest's directory, the text
-   * layer 3 holds: a whole command string the package runs, or the whole text of nodemon's
+   * On an entry that names no entry point, whose path is the manifest's directory, the texts
+   * layer 3 reads: a whole command string the package runs, or the values of nodemon's
    * configuration one is read from. Rooting enters no file for it and holds each file
-   * `spelledFiles` reads the text to name.
+   * `spelledFiles` reads their words to name.
    */
-  readonly held?: string;
+  readonly held?: readonly HeldText[];
 }
 
 /**
@@ -68,8 +69,9 @@ function below(member: string, key: string): string {
 
 /**
  * The whole text of nodemon's configuration, the manifest's `nodemonConfig` member and the
- * `nodemon.json` beside it, by the member each is. Layer 3 holds it whole, because nodemon runs
- * commands from keys besides `exec`, `events` among them: https://github.com/remy/nodemon#config-files
+ * `nodemon.json` beside it, by the member each is. The dependency rule reads it whole, and
+ * layer 3 each of its values, because nodemon runs commands from keys besides `exec`, `events`
+ * among them: https://github.com/remy/nodemon#config-files
  */
 export function nodemonTexts(
   host: Host,
@@ -89,6 +91,40 @@ export function nodemonTexts(
   ];
 }
 
+/**
+ * The texts layer 3 reads of one text of nodemon's configuration: each value of it but its
+ * `exec` command, which is read as a command string of its own, those under `events` read as
+ * command strings too, and the whole text where it does not parse. Its keys are never read.
+ */
+function nodemonValues(text: string): readonly HeldText[] {
+  let config: unknown;
+  try {
+    config = JSON.parse(text);
+  } catch {
+    return [{ text, shell: false }];
+  }
+  const found: HeldText[] = [];
+  const visit = (value: unknown, shell: boolean): void => {
+    if (Array.isArray(value) || isRecord(value)) {
+      for (const one of Object.values(value)) {
+        visit(one, shell);
+      }
+    } else if (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean"
+    ) {
+      found.push({ text: String(value), shell });
+    }
+  };
+  for (const [key, value] of Object.entries(isRecord(config) ? config : { "": config })) {
+    if (key !== "exec" || typeof value !== "string") {
+      visit(value, key === "events");
+    }
+  }
+  return found;
+}
+
 /**
  * The command strings one manifest runs, each at the member it is written under: each of its
  * `scripts`, and the `exec` command of nodemon's configuration, in the manifest's `nodemonConfig`
@@ -219,10 +255,19 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     for (const path of new Set(pathsNamed(readCommands(command, ".")).map((one) => one.path))) {
       found.push({ member, path, role: "script", published: false });
     }
-    found.push({ member, path: ".", role: "script", published: false, held: command });
+    found.push({
+      member,
+      path: ".",
+      role: "script",
+      published: false,
+      held: [{ text: command, shell: true, tested: member.startsWith("scripts[") }],
+    });
   }
   for (const { member, text } of nodemonTexts(host, targetRoot, manifest)) {
-    found.push({ member, path: ".", role: "script", published: false, held: text });
+    const held = nodemonValues(text);
+    if (held.length > 0) {
+      found.push({ member, path: ".", role: "script", published: false, held });
+    }
   }
 
   return {

package/src/roots/published-reach.ts

@@ -235,7 +235,9 @@ function declarationNodes(
   return {
     typeNamesOf: (symbol) => {
       const { byId, nodes } = nodesIn(symbol.position.path);
-      return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
+      return (byId.get(symbol.id) ?? []).flatMap((declaration) =>
+        typeNamesOf(declaration, (nested) => nodes.has(nested)),
+      );
     },
     nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
   };
@@ -438,12 +440,15 @@ function inferredTypeSymbols<Brand>(
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a
  * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
+ * declaration nested in this one that `readAlone` says is read on its own.
  */
-function typeNamesOf(declaration: Node, nested: ReadonlySet<Node>): readonly Node[] {
+export function typeNamesOf(
+  declaration: Node,
+  readAlone: (nested: Node) => boolean,
+): readonly Node[] {
   const found: Node[] = [];
   const visit = (node: Node): void => {
-    if (node !== declaration && nested.has(node)) {
+    if (node !== declaration && readAlone(node)) {
       return;
     }
     if (isTypeReferenceNode(node)) {

package/src/roots/root-set.ts

@@ -22,6 +22,7 @@ import { typeQueryAliases } from "../type-query-alias.ts";
 import { bytewise } from "../text/compare.ts";
 import { holdsManifest } from "../fs/manifest.ts";
 import { globExpression } from "../text/glob.ts";
+import { heldWords, type HeldText } from "../commands/held.ts";
 import { spelledFiles } from "../text/named-files.ts";
 import type { Workflows } from "../entries/workflow-steps.ts";
 import { extensionOf, OUTPUT_EXTENSIONS } from "../extensions.ts";
@@ -104,6 +105,8 @@ export interface HeldScripts {
   readonly dir: string;
   /** Each file, by its path below the target root. */
   readonly files: readonly string[];
+  /** Whether a word that may write the file a command runs writes no path text (`roots.13`). */
+  readonly unwritten: boolean;
 }
 
 /** What decides the roots beside the declarations themselves. */
@@ -304,11 +307,12 @@ export function matchRef(pattern: string, ref: string): boolean {
 }
 
 /**
- * Per package, the own files its held texts name, as `spelledFiles` reads them, but those a
- * root enters with all they export: a command can use no more of such a file than the root
- * keeps live. A manifest's are its entries' held texts, and the target root's package has the
- * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
- * file they are read from.
+ * Per package, the own files the words of its held texts name, as `spelledFiles` reads them,
+ * but those a root enters with all they export: a command can use no more of such a file than
+ * the root keeps live. A manifest's are its entries' held texts, and the target root's package
+ * has the workflow steps, git hooks and makefile recipes beside its own, with the values of
+ * each file they are read from. A package is listed too where a word that may write the file
+ * a command runs writes no path text.
  */
 function scriptHolds(
   entries: readonly ManifestEntry[],
@@ -325,24 +329,22 @@ function scriptHolds(
     .filter((file) => !rooted.has(file.fileName))
     .map((file) => ({ file, paths: [file.fileName, ...files.writtenAs(file)] }));
   const cwd = host.workingDirectory();
-  const commands = new Map<string, string[]>([
-    [
-      resolvePath(cwd, targetRoot),
-      [...workflows.readings.map((reading) => reading.held), ...workflows.texts],
-    ],
-  ]);
+  const root = resolvePath(cwd, targetRoot);
+  const commands = new Map<string, HeldText[]>([[root, [...workflows.held]]]);
   for (const entry of entries) {
     if (entry.held !== undefined) {
       const dir = resolvePath(cwd, entry.dir);
-      commands.set(dir, [...(commands.get(dir) ?? []), entry.held]);
+      commands.set(dir, [...(commands.get(dir) ?? []), ...entry.held]);
     }
   }
   const held: HeldScripts[] = [];
   for (const [dir, texts] of commands) {
-    const named = spelledFiles(texts.join("\n"), dir, spelled);
-    if (named.length > 0) {
-      const paths = named.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
-      held.push({ dir, files: paths });
+    const named = spelledFiles(heldWords(texts), dir, root, spelled);
+    if (named.files.length > 0 || named.unwritten) {
+      const paths = named.files.map(
+        (file) => relativePath(targetRoot, file.fileName) ?? file.fileName,
+      );
+      held.push({ dir, files: paths, unwritten: named.unwritten });
     }
   }
   return held;

package/src/stores.ts

@@ -12,7 +12,8 @@ import {
 import { nodeKey, type Inventory } from "./inventory.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
-import type { Exemption, Mode } from "./sweep.ts";
+import type { Exemption } from "./exempt.ts";
+import type { Mode } from "./tests/file-class.ts";
 import { classedAsTest, madeByTestCode, withheldBy } from "./tests/file-class.ts";
 
 /** One run's stores and reads, over every configuration. */

package/src/tests/file-class.ts

@@ -8,14 +8,31 @@
  */
 
 import type { SourceFile } from "@typescript/native/ast";
-import type { Edge } from "../graph.ts";
+import type { Edge } from "../liveness/graph.ts";
 import { renderPosition } from "../position.ts";
 import type { Reference } from "../references.ts";
 import type { ProjectView } from "../session.ts";
-import type { Mode } from "../sweep.ts";
 import { bytewise } from "../text/compare.ts";
 import { globExpression } from "../text/glob.ts";
 
+/**
+ * The run's reference mode, decided once by the composition and read by every stage
+ * that counts references.
+ */
+export interface Mode {
+  /**
+   * Counts no reference a test file made, under either relation. Every reference a root
+   * in a test file makes is such a reference, so nothing only a test reaches is live.
+   */
+  readonly production: boolean;
+  /**
+   * Classes a reference a loaded consumer's test file made as a production one rather than a
+   * test one, `analysis.consumer_tests` at `production`: a classification, not a filter, so it
+   * decides the split a candidate reports as well as what a production sweep counts.
+   */
+  readonly consumerTestsProduction?: boolean;
+}
+
 /** One rule that classified files as test files, and how many files it matched. */
 export interface TestFileRule {
   /** The rule's name, as a report's own rule list spells one. */