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

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/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/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. */