@cplieger/deadset-ts 5.0.0 → 5.1.1

package/src/roots.ts

@@ -8,8 +8,18 @@
  * under reachability and still a candidate under reference counting.
  */
 
-import type { SourceFile } from "@typescript/native/unstable/ast";
+import {
+  isExpressionWithTypeArguments,
+  isFunctionLikeDeclaration,
+  isPropertyAccessExpression,
+  isQualifiedName,
+  isTypeQueryNode,
+  isTypeReferenceNode,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.ts";
+import type { ParseFile } from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import { globExpression } from "./glob.ts";
@@ -87,8 +97,8 @@ export interface Roots {
   readonly unmatched: readonly string[];
   /**
    * Every declaration of the project, where the checker left the module or export table
-   * of an entry or a published file unanswered, and none otherwise: which of them that
-   * file exports is unknown.
+   * of an entry or a published file unanswered, since which of them that file exports is
+   * unknown; otherwise each one an unanswered published type name may name.
    */
   readonly unanswered: readonly string[];
 }
@@ -100,10 +110,10 @@ export interface RootOptions {
   /** The target's own manifest. */
   readonly manifest: Manifest;
   /**
-   * The entry points the other packages of the target's workspace name, each already
-   * marked published or not by its own manifest's rule.
+   * The entry points the target's other packages name, its workspace's members and the
+   * packages below it, each already marked published or not by its own manifest's rule.
    */
-  readonly workspaceEntries?: readonly ManifestEntry[] | undefined;
+  readonly otherPackages?: readonly ManifestEntry[] | undefined;
   /** `roots.patterns` from the resolved configuration. */
   readonly patterns: readonly string[];
   /** `ts.entry_files` from the resolved configuration. */
@@ -112,6 +122,8 @@ export interface RootOptions {
   readonly conventions?: Conventions | undefined;
   /** `ts.test_files` from the resolved configuration. */
   readonly testFiles: readonly string[];
+  /** The parser the configuration files no program holds are read with, where they are read. */
+  readonly parse?: ParseFile | undefined;
   /** Whether the target is a library, so a consumer outside it reaches its published API. */
   readonly publishedAPI: boolean;
 }
@@ -241,7 +253,7 @@ export function roots<Brand>(
         entry.published &&
         (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
     })),
-    ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+    ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
   ];
   for (const { entry, publishes } of entries) {
     if (options.publishedAPI && publishes) {
@@ -268,7 +280,14 @@ export function roots<Brand>(
     : conventionEntries(options.conventions, files)) {
     enter(file, "convention", row, true);
   }
-  for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot)) {
+  for (const point of entryPoints(
+    project,
+    files,
+    options.testFiles,
+    options.host,
+    targetRoot,
+    options.parse,
+  )) {
     enter(point.file, point.rule, point.source, point.exports);
   }
   for (const file of files.byPath.values()) {
@@ -300,10 +319,11 @@ export function roots<Brand>(
     }
   }
 
-  if (options.publishedAPI) {
-    for (const id of publishedAPI(published, exportsOf, held)) {
-      add(id, "published-api", "");
-    }
+  const api = options.publishedAPI
+    ? publishedAPI(project, published, exportsOf, held, files.byPath)
+    : { ids: [], guessed: [] };
+  for (const id of api.ids) {
+    add(id, "published-api", "");
   }
 
   const unmatched = configured(held, options.patterns, add);
@@ -320,7 +340,7 @@ export function roots<Brand>(
     configFile: project.configFile,
     liveUnderReachability: ordered,
     unmatched,
-    unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+    unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
   };
 }
 
@@ -378,55 +398,143 @@ function exportTables<Brand>(
 const EXPORTING_CONTAINERS: ReadonlySet<string> = new Set(["file", "namespace"]);
 
 /**
- * Every declaration a consumer of the library can name: what the published files
- * export, and below each, the members a consumer reaches through it.
- *
- * The published files are the ones `exports` reaches where the manifest declares
- * one, because a package that declares `exports` has said exactly what a consumer may
- * import; where it declares none, they are the ones the members that preceded it
- * name. Below a published module or namespace the walk follows what its export table
- * names; below any other published declaration it follows every member a consumer
- * can write: a public one, and a protected one, which a consumer's subclass names. A
- * private member is not published, nor is anything below one, and a type parameter
- * is not published either, because a consumer supplies a type argument by position.
- *
- * A published file is not itself published. A consumer imports a module and names
- * what it exports; the file is a root because the manifest names it, which is a
- * different reason.
+ * Every declaration a consumer of the library can name: what the published files export
+ * and, below each, the members a consumer writes: a namespace's exported ones, any other
+ * declaration's public and protected ones, never a private one or a type parameter. A
+ * declaration a published one's type names is published too, exported or not. A type name
+ * the checker leaves unanswered publishes every declaration spelled as it is, and those are
+ * `guessed`. A published file is not itself published.
  */
-function publishedAPI(
+function publishedAPI<Brand>(
+  project: ProjectView<Brand>,
   published: readonly SourceFile[],
   exportsOf: ReadonlyMap<string, readonly string[]>,
   held: Inventory,
-): readonly string[] {
+  byPath: ReadonlyMap<string, SourceFile>,
+): { readonly ids: readonly string[]; readonly guessed: readonly string[] } {
   const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
   const children = childrenOf(held);
+  const nodes = declarationNodes(held, byPath);
+  const chains = aliasChains(project, held);
   const reached = new Set<string>();
+  const guessed = new Set<string>();
   const pending: string[] = [];
+  const reach = (id: string): void => {
+    if (!reached.has(id) && byId.get(id)?.kind !== "file") {
+      reached.add(id);
+      pending.push(id);
+    }
+  };
   for (const file of published) {
     for (const id of exportsOf.get(file.fileName) ?? []) {
       if (byId.get(id)?.kind === "file") {
         pending.push(id);
-      } else if (!reached.has(id)) {
-        reached.add(id);
-        pending.push(id);
+      } else {
+        reach(id);
       }
     }
   }
-  for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-    const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-    for (const member of children.get(next) ?? []) {
-      const reachable = exporting
-        ? member.exported
-        : member.visibility !== "private" && member.visibility !== "private-name";
-      if (member.kind === "type-parameter" || reached.has(member.id) || !reachable) {
-        continue;
+  while (pending.length > 0) {
+    const round: string[] = [];
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+      round.push(next);
+      const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+      for (const member of children.get(next) ?? []) {
+        const reachable = exporting
+          ? member.exported
+          : member.visibility !== "private" && member.visibility !== "private-name";
+        if (member.kind !== "type-parameter" && reachable) {
+          reach(member.id);
+        }
       }
-      reached.add(member.id);
-      pending.push(member.id);
     }
+    const named = round.flatMap((id) => {
+      const symbol = byId.get(id);
+      return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+    });
+    project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+      if (symbol === UNANSWERED) {
+        for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+          guessed.add(id);
+          reach(id);
+        }
+      } else if (symbol !== undefined) {
+        for (const target of chains.chainOf(symbol)) {
+          reach(target.id);
+        }
+      }
+    });
   }
-  return [...reached];
+  return { ids: [...reached], guessed: [...guessed] };
+}
+
+/** The type names declarations of the inventory write, each file walked once, when first asked. */
+function declarationNodes(
+  held: Inventory,
+  byPath: ReadonlyMap<string, SourceFile>,
+): { typeNamesOf(symbol: InventorySymbol): readonly Node[] } {
+  const walked = new Map<string, { byId: Map<string, Node>; nodes: Set<Node> }>();
+  const nodesIn = (path: string): { byId: Map<string, Node>; nodes: Set<Node> } => {
+    const known = walked.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    const found = { byId: new Map<string, Node>(), nodes: new Set<Node>() };
+    const file = byPath.get(path);
+    if (file !== undefined) {
+      const visit = (node: Node): void => {
+        const id = held.declarations.get(nodeKey(file, node));
+        if (id !== undefined) {
+          found.nodes.add(node);
+          if (!found.byId.has(id)) {
+            found.byId.set(id, node);
+          }
+        }
+        node.forEachChild(visit);
+      };
+      visit(file);
+    }
+    walked.set(path, found);
+    return found;
+  };
+  return {
+    typeNamesOf: (symbol) => {
+      const { byId, nodes } = nodesIn(symbol.position.path);
+      const declaration = byId.get(symbol.id);
+      return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+    },
+  };
+}
+
+/**
+ * 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.
+ */
+function typeNamesOf(declaration: Node, nested: ReadonlySet<Node>): readonly Node[] {
+  const found: Node[] = [];
+  const visit = (node: Node): void => {
+    if (node !== declaration && nested.has(node)) {
+      return;
+    }
+    if (isTypeReferenceNode(node)) {
+      found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+    } else if (isExpressionWithTypeArguments(node)) {
+      found.push(
+        isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression,
+      );
+    } else if (isTypeQueryNode(node)) {
+      found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
+    }
+    const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
+    node.forEachChild((child) => {
+      if (child !== body) {
+        visit(child);
+      }
+    });
+  };
+  visit(declaration);
+  return found;
 }
 
 /**

package/src/session.ts

@@ -485,8 +485,8 @@ function projectsOf(
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
  * built as that program, or opened from the configuration it writes, instead of as a project.
  * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. The snapshot is disposed after the last visit and the client released
- * after it, whether the visit completed or threw.
+ * under `"record"`. `last` runs after the last visit while the client still answers; the
+ * snapshot is disposed and the client released after it, whether the visit completed or threw.
  */
 export function runSession<Result>(
   engine: Engine,
@@ -494,6 +494,7 @@ export function runSession<Result>(
   visit: ProjectVisitor<Result>,
   unopened: Unopened = "refuse",
   programs: ReadonlyMap<string, WorkspaceProgram> = new Map(),
+  last: () => void = () => undefined,
 ): SessionResult<Result> {
   try {
     const built: string[] = [];
@@ -531,6 +532,7 @@ export function runSession<Result>(
         }
         projects.push(visit(viewOf(project, configFile, engine, log)));
       }
+      last();
       return {
         projects,
         unopened: missing,

package/src/stores.ts

@@ -22,6 +22,8 @@ export interface Stores {
    * configuration. A production mode counts none a test file made.
    */
   readonly references: readonly Reference[];
+  /** The declarations a test file reads, which a production mode counts no read of. */
+  readonly readInTests: ReadonlySet<string>;
   /**
    * The class members declared by a getter or a setter. A store into one runs the
    * setter, which is code rather than state.
@@ -71,6 +73,13 @@ export function storesOf(
     references: per.flatMap((one) =>
       one.references.filter((reference) => !mode.production || !reference.test),
     ),
+    readInTests: new Set(
+      per.flatMap((one) =>
+        one.references
+          .filter((reference) => reference.test && reference.use !== "write")
+          .map((reference) => reference.to),
+      ),
+    ),
     accessors: new Set(per.flatMap((one) => one.accessors)),
     exempt: new Set(exempt.map((record) => record.id)),
   };

package/src/template-field.ts

@@ -125,12 +125,74 @@ function stringEnd(text: string, from: number): number {
   return at + 1;
 }
 
-/** The identifiers one action's inner text writes outside a quoted string, with their offsets in it. */
-function identifiersOf(inner: string): readonly { name: string; offset: number }[] {
+/** The end of the `${` substitution whose expression starts at `from`, past its closing brace. */
+function substitutionEnd(text: string, from: number): number {
+  let depth = 1;
+  let at = from;
+  while (at < text.length) {
+    const char = text[at];
+    if (char === '"' || char === "'") {
+      at = stringEnd(text, at);
+      continue;
+    }
+    if (char === "`") {
+      at = templateEnd(text, at, () => undefined);
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return at + 1;
+      }
+    }
+    at += 1;
+  }
+  return at;
+}
+
+/** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
+function templateEnd(
+  text: string,
+  from: number,
+  substitution: (expression: string, offset: number) => void,
+): number {
+  let at = from + 1;
+  while (at < text.length && text[at] !== "`") {
+    if (text[at] === "\\") {
+      at += 2;
+      continue;
+    }
+    if (text[at] === "$" && text[at + 1] === "{") {
+      const start = at + 2;
+      const end = substitutionEnd(text, start);
+      substitution(text.slice(start, end - 1), start);
+      at = end;
+      continue;
+    }
+    at += 1;
+  }
+  return at + 1;
+}
+
+/**
+ * The identifiers one action's inner text writes outside a quoted string, with their offsets
+ * in it. In `script` text, a component's markup, a template literal's substitutions are code.
+ */
+function identifiersOf(inner: string, script = false): readonly { name: string; offset: number }[] {
   const found: { name: string; offset: number }[] = [];
   let at = 0;
   while (at < inner.length) {
     const char = inner[at] ?? "";
+    if (char === "`" && script) {
+      at = templateEnd(inner, at, (expression, offset) => {
+        for (const one of identifiersOf(expression, true)) {
+          found.push({ name: one.name, offset: offset + one.offset });
+        }
+      });
+      continue;
+    }
     if (char === '"' || char === "'" || char === "`") {
       at = stringEnd(inner, at);
       continue;
@@ -183,7 +245,7 @@ function namesOf(text: string, delimiters: TemplateDelimiters): readonly Named[]
 /** Every identifier the markup of one component file writes in an action. */
 function markupNamesOf(text: string): readonly Named[] {
   return readComponent(text).markup.flatMap((one) =>
-    identifiersOf(one.text).map(({ name, offset }) => ({
+    identifiersOf(one.text, true).map(({ name, offset }) => ({
       name,
       offset: one.start + offset,
       action: one.action,

package/src/value-flow.ts

@@ -0,0 +1,104 @@
+/**
+ * The values a program hands to a position the checker types from its context: the
+ * initializer of a declaration whose type is written, an assignment's right side, an
+ * argument, a returned value, an arrow function's expression body, an array element, an
+ * object property, and the operand of `as` or `satisfies`.
+ */
+
+import {
+  isArrayLiteralExpression,
+  isArrowFunction,
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isConditionalExpression,
+  isIdentifier,
+  isNewExpression,
+  isParameterDeclaration,
+  isParenthesizedExpression,
+  isPropertyAssignment,
+  isPropertyDeclaration,
+  isReturnStatement,
+  isSatisfiesExpression,
+  isShorthandPropertyAssignment,
+  isSpreadElement,
+  isVariableDeclaration,
+  SyntaxKind,
+  type Expression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+
+/** The operators of an assignment whose right side is stored into the left side's type. */
+const STORES: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.EqualsToken,
+  SyntaxKind.QuestionQuestionEqualsToken,
+  SyntaxKind.BarBarEqualsToken,
+  SyntaxKind.AmpersandAmpersandEqualsToken,
+]);
+
+/** Whether a declaration writes its type, so its initializer is read in that type's context. */
+function writesType(node: Node): boolean {
+  return (node as { readonly type?: Node }).type !== undefined;
+}
+
+/**
+ * The values one written expression hands on: the expression itself, or what it
+ * evaluates to through parentheses, a conditional and the operators whose result is
+ * one of their operands.
+ */
+export function valuesOf(expression: Expression): readonly Expression[] {
+  if (isParenthesizedExpression(expression)) {
+    return valuesOf(expression.expression);
+  }
+  if (isConditionalExpression(expression)) {
+    return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
+  }
+  if (isBinaryExpression(expression)) {
+    const operator = expression.operatorToken.kind;
+    if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+      return [...valuesOf(expression.left), ...valuesOf(expression.right)];
+    }
+    if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
+      return valuesOf(expression.right);
+    }
+  }
+  return [expression];
+}
+
+/** The expressions one node hands to a position typed by its context. */
+export function handedOn(node: Node): readonly Expression[] {
+  if (
+    (isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
+    node.initializer !== undefined &&
+    writesType(node)
+  ) {
+    return [node.initializer];
+  }
+  if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
+    return [node.right];
+  }
+  if (isCallExpression(node) || isNewExpression(node)) {
+    return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
+  }
+  if (isReturnStatement(node)) {
+    return node.expression === undefined ? [] : [node.expression];
+  }
+  if (isArrowFunction(node)) {
+    return node.body.kind === SyntaxKind.Block ? [] : [node.body];
+  }
+  if (isArrayLiteralExpression(node)) {
+    return node.elements.filter(
+      (element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression,
+    );
+  }
+  if (isPropertyAssignment(node)) {
+    return [node.initializer];
+  }
+  if (isShorthandPropertyAssignment(node)) {
+    return isIdentifier(node.name) ? [node.name] : [];
+  }
+  if (isAsExpression(node) || isSatisfiesExpression(node)) {
+    return [node.expression];
+  }
+  return [];
+}

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.1.0";
+export const CONTRACT_VERSION = "5.2.0";