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

package/src/interface-satisfaction.ts

@@ -29,7 +29,7 @@ import {
 } from "@typescript/native/ast";
 import { SymbolFlags, type Type } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.ts";
-import { emptyImplementation } from "./implementations.ts";
+import { emptyImplementation } from "./findings/implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Reference } from "./references.ts";
 import type { Exemption } from "./sweep.ts";

package/src/keyof-comparisons.ts

@@ -10,7 +10,10 @@ import {
   isCaseClause,
   isElementAccessExpression,
   isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
   isPropertyAccessExpression,
+  isStringLiteral,
   isSwitchStatement,
   isTypeOperatorNode,
   SyntaxKind,
@@ -20,12 +23,8 @@ import {
   type TypeNode,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Type } from "@typescript/native/sync";
-import type { AliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
-import type { Reference } from "./references.ts";
-import type { ProjectView } from "./session.ts";
+import type { Read, ReadRule } from "./references/read-rule.ts";
 import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The operators that compare their operands for equality. */
@@ -83,125 +82,141 @@ function literalNames(parts: readonly Type[]): readonly string[] {
 }
 
 /**
- * The references the key comparisons of one project's own files make to the members their
- * literal side names, each made by the declaration holding the comparison.
+ * The reads the key comparisons of a side's files make of the members their literal side
+ * names, each made by the declaration holding the comparison. A question the checker leaves
+ * unanswered holds what its answer could have read.
  */
-export function keyofComparisonReferences<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  chains: AliasChains,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const queries = project.queries;
-  const comparisons: Comparison[] = [];
-  for (const file of project.ownSourceFiles()) {
-    const fileId = held.declarations.get(nodeKey(file, file));
-    if (fileId === undefined) {
-      continue;
-    }
-    const visit = (node: Node, from: string): void => {
-      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-      if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
-        comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
-        comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
-      }
-      if (isSwitchStatement(node)) {
-        for (const clause of node.caseBlock.clauses) {
-          if (isCaseClause(clause)) {
-            comparisons.push({
-              file,
-              from: holder,
-              keyed: node.expression,
-              other: clause.expression,
+export const keyofComparisons: ReadRule = {
+  start() {
+    const comparisons: Comparison[] = [];
+    return {
+      visit(node, { file, from }) {
+        if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+          comparisons.push({ file, from, keyed: node.left, other: node.right });
+          comparisons.push({ file, from, keyed: node.right, other: node.left });
+        }
+        if (isSwitchStatement(node)) {
+          for (const clause of node.caseBlock.clauses) {
+            if (isCaseClause(clause)) {
+              comparisons.push({ file, from, keyed: node.expression, other: clause.expression });
+            }
+          }
+        }
+      },
+      reads({ project, chains }) {
+        const queries = project.queries;
+        const found: Read[] = [];
+        const named = comparisons.flatMap((one) => {
+          const name = nameOf(one.keyed);
+          return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
+            ? []
+            : [{ ...one, name }];
+        });
+        if (named.length === 0) {
+          return found;
+        }
+        // The operand's own declaration states the key type, which the checker resolves to
+        // the literals it admits and so no longer names the type the key indexes.
+        const symbols = queries.symbolsAt(named.map((one) => one.name));
+        const keyed = named.flatMap((one, at) => {
+          const asked = symbols[at];
+          const symbol =
+            asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+              ? asked
+              : queries.aliased(asked);
+          if (symbol === UNANSWERED) {
+            const text = literalText(one.other);
+            found.push({
+              kind: "held",
+              from: one.from,
+              ...(text === undefined ? {} : { names: [text] }),
             });
+            return [];
+          }
+          if (symbol === undefined) {
+            return [];
           }
+          const operands = symbol.declarations.flatMap((handle) => {
+            const declared = (
+              project.declarationAt(handle)?.node as { readonly type?: TypeNode } | undefined
+            )?.type;
+            return declared === undefined ? [] : keyofOperands(declared);
+          });
+          return operands.length === 0 ? [] : [{ ...one, operands }];
+        });
+        if (keyed.length === 0) {
+          return found;
         }
-      }
-      node.forEachChild((child) => {
-        visit(child, holder);
-      });
-    };
-    file.forEachChild((child) => {
-      visit(child, fileId);
-    });
-  }
-  const named = comparisons.flatMap((one) => {
-    const name = nameOf(one.keyed);
-    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
-      ? []
-      : [{ ...one, name }];
-  });
-  if (named.length === 0) {
-    return [];
-  }
-
-  // The operand's own declaration states the key type, which the checker resolves to
-  // the literals it admits and so no longer names the type the key indexes.
-  const symbols = queries.symbolsAt(named.map((one) => one.name));
-  const keyed = named.flatMap((one, at) => {
-    const asked = symbols[at];
-    const symbol =
-      asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
-        ? asked
-        : queries.aliased(asked);
-    if (symbol === UNANSWERED || symbol === undefined) {
-      return [];
-    }
-    const operands = symbol.declarations.flatMap((handle) => {
-      const declared = (
-        project.declarationAt(handle)?.node as { readonly type?: TypeNode } | undefined
-      )?.type;
-      return declared === undefined ? [] : keyofOperands(declared);
-    });
-    return operands.length === 0 ? [] : [{ ...one, operands }];
-  });
-  if (keyed.length === 0) {
-    return [];
-  }
-  const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
-  const types = queries.typesAt(nodes);
-  const typeOf = new Map<Node, Type>();
-  nodes.forEach((node, at) => {
-    const type = types[at];
-    if (type !== UNANSWERED && type !== undefined) {
-      typeOf.set(node, type);
-    }
-  });
-  const partsOf = (type: Type): readonly Type[] => {
-    const parts = queries.constituents(type);
-    return parts === UNANSWERED ? [type] : parts;
-  };
-
-  const found: Reference[] = [];
-  for (const one of keyed) {
-    const literal = typeOf.get(one.other);
-    const names = literal === undefined ? [] : literalNames(partsOf(literal));
-    if (names.length === 0) {
-      continue;
-    }
-    const position = renderPosition(one.file, root, one.other.getStart());
-    for (const operand of one.operands) {
-      const object = typeOf.get(operand);
-      for (const part of object === undefined ? [] : partsOf(object)) {
-        const properties = queries.propertiesOf(part);
-        for (const property of properties === UNANSWERED ? [] : properties) {
-          if (!names.includes(property.name)) {
-            continue;
+        const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+        const types = queries.typesAt(nodes);
+        const typeOf = new Map<Node, Type | typeof UNANSWERED>();
+        nodes.forEach((node, at) => {
+          const type = types[at];
+          if (type !== undefined) {
+            typeOf.set(node, type);
           }
-          for (const to of chains.declarationsOf(property)) {
+        });
+        const partsOf = (type: Type): readonly Type[] => {
+          const parts = queries.constituents(type);
+          return parts === UNANSWERED ? [type] : parts;
+        };
+        for (const one of keyed) {
+          const literal = typeOf.get(one.other);
+          const objects = one.operands.map((operand) => typeOf.get(operand));
+          if (literal === UNANSWERED) {
+            const known = objects.filter((type) => type !== undefined && type !== UNANSWERED);
             found.push({
+              kind: "held",
               from: one.from,
-              to,
-              position,
-              use: "read",
-              resolution: "keyed",
-              test: testFiles.has(position.path),
+              types: known.flatMap(partsOf),
+              ...(known.length < objects.length ? { members: true as const } : {}),
             });
+            continue;
+          }
+          const names = literal === undefined ? [] : literalNames(partsOf(literal));
+          if (names.length === 0) {
+            continue;
+          }
+          for (const object of objects) {
+            if (object === UNANSWERED) {
+              found.push({ kind: "held", from: one.from, names });
+              continue;
+            }
+            for (const part of object === undefined ? [] : partsOf(object)) {
+              const properties = queries.propertiesOf(part);
+              if (properties === UNANSWERED) {
+                found.push({ kind: "held", from: one.from, names });
+                continue;
+              }
+              for (const property of properties) {
+                if (!names.includes(property.name)) {
+                  continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                  found.push({
+                    kind: "named",
+                    from: one.from,
+                    to,
+                    file: one.file,
+                    at: one.other,
+                    use: "read",
+                    via: "keyed",
+                  });
+                }
+              }
+            }
           }
         }
-      }
-    }
-  }
-  return found;
+        return found;
+      },
+    };
+  },
+};
+
+/** The text a string or number literal operand spells, where it is one. */
+function literalText(node: Expression): string | undefined {
+  const at = parenthesesRemoved(node);
+  return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at)
+    ? at.text
+    : undefined;
 }

package/src/load/expected-module.ts

@@ -8,7 +8,13 @@ import { packageOfSpecifier } from "../dependencies.ts";
 import { MANIFEST } from "../fs/manifest.ts";
 import { entriesOf } from "../fs/tree.ts";
 import type { Host } from "../host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import {
+  cannotStartPackageName,
+  dirnamePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { dependencySpecifiers, installedPackage, manifestsAbove } from "./module-lookup.ts";
 import type { CompilerOptions } from "./plan.ts";
 
@@ -119,7 +125,7 @@ function expectedModule(
 ): string | undefined {
   const { host, targetRoot } = context;
   const fix = "run the generator or the build that writes it";
-  if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
+  if (cannotStartPackageName(specifier)) {
     return provided(host, resolvePath(dirnamePath(importer), specifier), false)
       ? undefined
       : `which names no file of the target: ${fix}`;

package/src/load/specifiers.ts

@@ -23,14 +23,17 @@ import type { Failure } from "../failure.ts";
 import { readManifestAt } from "../fs/manifest.ts";
 import type { Host } from "../host.ts";
 import { JAVASCRIPT_FILE } from "../javascript-file.ts";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isRelativeSpecifier,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { renderPosition, type Position } from "../position.ts";
 import { batched, type Engine, type ProjectView } from "../session.ts";
 import { dependencySpecifiers } from "./module-lookup.ts";
 
-/** A relative specifier: `.`, `..`, or one starting `./` or `../`. */
-const RELATIVE = /^\.\.?(?:\/|$)/u;
-
 /** One relative specifier of a JavaScript file that resolves to no file. */
 export interface UnresolvedSpecifier {
   readonly specifier: string;
@@ -141,7 +144,7 @@ export function readSpecifiers<Brand>(
     const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
     const specifier = usage.node.text;
     const name = packageOfSpecifier(specifier);
-    if (RELATIVE.test(specifier)) {
+    if (isRelativeSpecifier(specifier)) {
       const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
       if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
         unresolved.push({

package/src/load/synthesize.ts

@@ -132,6 +132,12 @@ const RUNTIME_OPTIONS = {
   node: { module: "nodenext", moduleResolution: "nodenext" },
 } as const satisfies Record<Runtime, Readonly<Record<string, string>>>;
 
+/** Whether one configuration is a program the run formed to resolve its modules as Node does. */
+export function formedForNode(configuration: Configuration): boolean {
+  const options = configuration.written?.["compilerOptions"];
+  return isRecord(options) && options["moduleResolution"] === RUNTIME_OPTIONS.node.moduleResolution;
+}
+
 /** The manifest members that say a package is written for Node. */
 const NODE_MEMBERS = ["main", "exports", "bin", "type"] as const;
 

package/src/load/workspace-resolution.ts

@@ -10,7 +10,14 @@ import { emittedFrom } from "./emit-map.ts";
 import { packageOfSpecifier } from "../dependencies.ts";
 import { gitIgnored } from "../git-ignore.ts";
 import type { Host } from "../host.ts";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  cannotStartPackageName,
+  dirnamePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { satisfies } from "../version-range.ts";
 import type { Workspace, WorkspaceMember } from "./workspace.ts";
 import { isRecord } from "../json-document.ts";
@@ -140,7 +147,7 @@ function dependsOn(specifier: string, member: WorkspaceMember, fromDir: string):
     member.version !== undefined && satisfies(member.version, range);
   if (specifier.startsWith("workspace:")) {
     const rest = specifier.slice("workspace:".length);
-    if (rest.startsWith(".") || rest.startsWith("/")) {
+    if (cannotStartPackageName(rest)) {
       return atPath(rest);
     }
     const alias = /^((?:@[^/@]+\/)?[^/@]+)@(.*)$/u.exec(rest);

package/src/matrix.ts

@@ -10,8 +10,10 @@ import type { InventorySymbol } from "./inventory.ts";
 import { byPosition } from "./position.ts";
 import type { Reference } from "./references.ts";
 import type { Root } from "./roots/root-set.ts";
+import { edgeWithheldBy } from "./tests/file-class.ts";
 import {
   reachedWithTheTests,
+  splitRefs,
   sweep,
   type Candidate,
   type Liveness,
@@ -270,13 +272,14 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
     }
     const held = matrix.heldIn[at] ?? [];
     const admitted = admittedAt(at);
-    const testRefs = union.made[at]?.test ?? 0;
+    const split = splitRefs(union.made[at], input.mode);
+    const testRefs = split.test;
     const heldByTests =
       heldBy[union.parent[at] ?? OUTSIDE] ??
       (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
     const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
     heldBy[at] = heldByTests;
-    const productionRefs = union.made[at]?.production ?? 0;
+    const productionRefs = split.production;
     const counted = all.every((candidate) => candidate.relation === "reference-counting");
     candidates.push({
       id: symbol.id,
@@ -325,7 +328,7 @@ function compiledReferences(
         }
         for (const edge of edges) {
           const to = graph.symbols[edge.to]?.id ?? "";
-          if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+          if (!edgeWithheldBy(mode, edge) && dead.has(to) && !kept.has(to)) {
             kept.add(to);
             changed = true;
           }

package/src/module-declarations.ts

@@ -15,20 +15,18 @@ import {
   isImportTypeNode,
   isLiteralTypeNode,
   isModuleDeclaration,
-  isNamespaceExport,
-  isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
   isStringLiteral,
   SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { namesImported } from "./import-bindings.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import { aliasFragment, nameComponent } from "./ref.ts";
-import type { Reference } from "./references.ts";
-import type { ProjectView } from "./session.ts";
+import type { Read, ReadRule } from "./references/read-rule.ts";
+import { isPathSpecifier } from "./paths.ts";
 
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node: Node | undefined): node is Node & { readonly text: string } {
@@ -58,33 +56,12 @@ function specifierOf(node: Node): (Node & { readonly text: string }) | undefined
   return undefined;
 }
 
-/**
- * The export names an import or a re-export reads from the module it names: none for a
- * namespace, a star or a bare form.
- */
-export function namesImported(node: Node): readonly string[] {
-  if (isImportDeclaration(node)) {
-    const clause = node.importClause;
-    const bindings = clause?.namedBindings;
-    return [
-      ...(clause?.name === undefined ? [] : ["default"]),
-      ...(bindings === undefined || isNamespaceImport(bindings)
-        ? []
-        : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
-    ];
-  }
-  const clause = isExportDeclaration(node) ? node.exportClause : undefined;
-  return clause === undefined || isNamespaceExport(clause)
-    ? []
-    : clause.elements.map((one) => (one.propertyName ?? one.name).text);
-}
-
 /**
  * Whether a specifier matches a declaration's name, the name's one `*` standing for any run.
  * A relative name is resolved against its own file, so no specifier names it by its text.
  */
 function namesModule(specifier: string, name: string): boolean {
-  if (/^(?:\.{1,2}(?:\/|$)|\/)/u.test(name)) {
+  if (isPathSpecifier(name)) {
     return false;
   }
   const star = name.indexOf("*");
@@ -161,76 +138,75 @@ interface Declared {
 }
 
 /**
- * The references the imports of one project's own files make to the module declarations
- * they name, each at the import's specifier.
+ * The reads the imports of a side's files make of the module declarations of the target they
+ * name, each at the import's specifier. A specifier the checker leaves unanswered still names
+ * a declaration by its name or pattern.
  */
-export function moduleDeclarationReferences<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const imports: Import[] = [];
-  const declared: Declared[] = [];
-  for (const file of project.ownSourceFiles()) {
-    const fileId = held.declarations.get(nodeKey(file, file));
-    if (fileId === undefined) {
-      continue;
-    }
-    const visit = (node: Node, from: string): void => {
-      const own = held.declarations.get(nodeKey(file, node));
-      if (isModuleDeclaration(node) && literalText(node.name) && own !== undefined) {
-        declared.push({ id: own, name: node.name });
-      }
-      const specifier = specifierOf(node);
-      if (specifier !== undefined) {
-        imports.push({ file, from, specifier, names: namesImported(node) });
-      }
-      node.forEachChild((child) => {
-        visit(child, own ?? from);
-      });
-    };
-    file.forEachChild((child) => {
-      visit(child, fileId);
-    });
-  }
-  if (declared.length === 0 || imports.length === 0) {
-    return [];
-  }
-
-  const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
-  const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
-  const moduleOf = (at: number): number | undefined => {
-    const symbol = answers[at];
-    return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
-  };
-
-  const named = namedBy(held);
-  const found: Reference[] = [];
-  imports.forEach((one, index) => {
-    const resolved = moduleOf(declared.length + index);
-    const position = renderPosition(one.file, root, one.specifier.getStart());
-    const read = (to: string, resolution: Reference["resolution"], test: boolean): void => {
-      found.push({ from: one.from, to, position, use: "read", resolution, test });
-    };
-    const test = testFiles.has(position.path);
-    const same = new Set(
-      declared
-        .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
-        .map((declaration) => declaration.id),
-    );
-    for (const id of same) {
-      read(id, "batch", test);
-    }
-    for (const declaration of named(one.specifier.text, one.names)) {
-      // A wildcard declaration is how the compiler types the file a matching specifier
-      // names, so the import uses it whoever writes it, a test included.
-      if (declaration.wildcard || !same.has(declaration.id)) {
-        for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "syntax", test && !declaration.wildcard);
+export const moduleDeclarations: ReadRule = {
+  start() {
+    const imports: Import[] = [];
+    return {
+      visit(node, { file, from }) {
+        const specifier = specifierOf(node);
+        if (specifier !== undefined) {
+          imports.push({ file, from, specifier, names: namesImported(node) });
         }
-      }
-    }
-  });
-  return found;
-}
+      },
+      reads({ project, held }) {
+        const found: Read[] = [];
+        // A module declaration whose name is a string is written at a file's top level.
+        const declared: Declared[] = project.ownSourceFiles().flatMap((file) =>
+          file.statements.flatMap((statement) => {
+            const id = held.declarations.get(nodeKey(file, statement));
+            return isModuleDeclaration(statement) && literalText(statement.name) && id !== undefined
+              ? [{ id, name: statement.name }]
+              : [];
+          }),
+        );
+        if (declared.length === 0 || imports.length === 0) {
+          return found;
+        }
+        const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
+        const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
+        const moduleOf = (at: number): number | undefined => {
+          const symbol = answers[at];
+          return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
+        };
+        const named = namedBy(held);
+        imports.forEach((one, index) => {
+          const resolved = moduleOf(declared.length + index);
+          const read = (to: string, via: "batch" | "syntax", production: boolean): void => {
+            found.push({
+              kind: "named",
+              from: one.from,
+              to,
+              file: one.file,
+              at: one.specifier,
+              use: "read",
+              via,
+              ...(production ? { production: true as const } : {}),
+            });
+          };
+          const same = new Set(
+            declared
+              .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
+              .map((declaration) => declaration.id),
+          );
+          for (const id of same) {
+            read(id, "batch", false);
+          }
+          for (const declaration of named(one.specifier.text, one.names)) {
+            // A wildcard declaration is how the compiler types the file a matching specifier
+            // names, so the import uses it whoever writes it, a test included.
+            if (declaration.wildcard || !same.has(declaration.id)) {
+              for (const to of [declaration.id, ...declaration.members]) {
+                read(to, "syntax", declaration.wildcard);
+              }
+            }
+          }
+        });
+        return found;
+      },
+    };
+  },
+};