@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.3

package/src/configuration-files.ts

@@ -426,7 +426,7 @@ export function configurationFiles(
     outside:
       parse === undefined
         ? []
-        : outsideModules(host, [...dirs], files, holdsManifest, parse, named),
+        : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
   };
 }
 
@@ -480,11 +480,12 @@ export function resolveRelativeSpecifier(
 
 /**
  * The configuration modules of the directories that hold a manifest which the program
- * does not hold, and the files they import by a relative specifier, until no further
- * file joins. A file that cannot be read is skipped.
+ * does not hold, and the project files below `root` they import by a relative specifier,
+ * until no further file joins. A file that cannot be read is skipped.
  */
 function outsideModules(
   host: Host,
+  root: string,
   dirs: readonly string[],
   files: SourceFiles,
   holdsManifest: (dir: string) => boolean,
@@ -533,7 +534,7 @@ function outsideModules(
     outside.manifestDirs.push(next.manifestDir);
     for (const specifier of relativeSpecifiers(outside.file)) {
       const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
-      if (reached !== undefined) {
+      if (reached !== undefined && isProjectPath(root, reached)) {
         pending.push({ path: reached, manifestDir: next.manifestDir });
       }
     }

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "5.0.0",
     result: "pass",
-    digest: "sha256:26c486907df44fb8eaf3f749f60a6010ac94e7cfeeda70c4aa406445193ab80a",
+    digest: "sha256:c46c7d06b6f0c58504c5f311870efefc0b85f18c2c46ba7d7b722081cb370c0c",
   },
   gaps: [],
 } as const;

package/src/contextual-uses.ts

@@ -8,10 +8,13 @@
  */
 
 import {
+  isClassDeclaration,
+  isClassExpression,
   isComputedPropertyName,
   isGetAccessorDeclaration,
   isIdentifier,
   isMethodDeclaration,
+  isMethodSignatureDeclaration,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectLiteralExpression,
@@ -24,7 +27,7 @@ import {
   type Node,
   type ObjectLiteralExpression,
 } from "@typescript/native/unstable/ast";
-import { SignatureKind, SymbolFlags, type Type } from "@typescript/native/unstable/sync";
+import { SignatureKind, type NodeHandle, type Type } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import type { Inventory, SymbolKind } from "./inventory.ts";
 import { isAnswered, type PropertyTables } from "./query.ts";
@@ -115,11 +118,30 @@ interface Checked {
 /** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
 interface Member {
   readonly ids: readonly string[];
+  /** The inventory's interface methods it is, which a position reads but no literal writes. */
+  readonly methods: readonly string[];
   readonly handles: ReadonlySet<string>;
   /** Whether a declaration of it is in one of the target's own files. */
   readonly own: boolean;
-  /** Whether the checker reads it as an accessor. */
-  readonly accessor: boolean;
+  /** The checker's declarations of it in the target's own files. */
+  readonly declarations: readonly NodeHandle[];
+}
+
+/**
+ * Whether an object spread copies a member a declaration declares: a method, a method
+ * signature and a class's accessor are no own data property of the value, while an
+ * accessor of an interface or a type literal describes one. It is decided on the
+ * declaration, because a mapped type over a class keeps the class's declarations on
+ * plain property symbols.
+ */
+function copiedBySpread(node: Node): boolean {
+  if (isMethodDeclaration(node) || isMethodSignatureDeclaration(node)) {
+    return false;
+  }
+  return !(
+    (isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) &&
+    (isClassDeclaration(node.parent) || isClassExpression(node.parent))
+  );
 }
 
 /**
@@ -182,11 +204,14 @@ export function contextualUses<Brand>(
         ids: chains
           .declarationsOf(property)
           .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+        methods: chains
+          .declarationsOf(property)
+          .filter((id) => kinds.get(id) === "interface-method"),
         handles: new Set(
           property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`),
         ),
         own: property.declarations.some((handle) => ownPaths.has(handle.path)),
-        accessor: (property.flags & SymbolFlags.Accessor) !== 0,
+        declarations: property.declarations.filter((handle) => ownPaths.has(handle.path)),
       });
     }
     tables.set(type.id, table);
@@ -250,8 +275,10 @@ export function contextualUses<Brand>(
     cap,
   );
   /** The members a position may read structurally: those of object types, not of classes. */
-  const readable = (member: Member): readonly string[] =>
-    member.ids.filter((id) => kinds.get(id) === "type-member");
+  const readable = (member: Member): readonly string[] => [
+    ...member.ids.filter((id) => kinds.get(id) === "type-member"),
+    ...member.methods,
+  ];
   const carries = (part: Type): boolean =>
     [...membersOf(part).values()].some((member) => readable(member).length > 0);
   /** Whether an object type has members and declares none of them in the target. */
@@ -278,6 +305,20 @@ export function contextualUses<Brand>(
     return element;
   };
 
+  const argumentsOf = new Map<number, readonly Type[]>();
+  /** The type arguments of an instantiation of a generic type, read once per type. */
+  const typeArgumentsOf = (type: Type): readonly Type[] => {
+    const known = argumentsOf.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    lookups += type.isTypeReference() ? 1 : 0;
+    const held = queries.typeArguments(type);
+    const found = isAnswered(held) ? held : [];
+    argumentsOf.set(type.id, found);
+    return found;
+  };
+
   const calls = new Map<number, Called | undefined>();
   /**
    * The parameter and return types of a type's one call signature, or of its one construct
@@ -315,10 +356,11 @@ export function contextualUses<Brand>(
 
   /**
    * Each object type a value of `source` is checked as against the object types of
-   * `target`: the value's own, and through array elements and through a function's
-   * parameters, checked the other way, and its result. A source that is one of the
-   * target's own object types matches it as it stands. Each pair is compared once, which
-   * ends the walk over a recursive type.
+   * `target`: the value's own, and through array elements, a function's parameters,
+   * checked the other way, and result, and the type arguments two instantiations share
+   * by place, an array among them, as an array reaches `Iterable<T>`.
+   * A source that is one of the target's own object types matches it as it stands. Each
+   * pair is compared once, which ends the walk over a recursive type.
    */
   const compared = (
     source: Type | undefined,
@@ -344,9 +386,20 @@ export function contextualUses<Brand>(
       }
       const element = elementOf(one);
       const called = element === undefined ? callOf(one) : undefined;
+      const sourceArguments = typeArgumentsOf(one);
       for (const part of targets) {
+        const partElement = elementOf(part);
+        if (element !== undefined && partElement !== undefined) {
+          compared(element, partElement, into, seen);
+          continue;
+        }
+        const targetArguments = typeArgumentsOf(part);
+        // A defaulted trailing parameter, as `Iterable<T, TReturn, TNext>` has, leaves
+        // the places two instantiations share comparable.
+        sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
+          compared(argument, targetArguments[index], into, seen);
+        });
         if (element !== undefined) {
-          compared(element, elementOf(part), into, seen);
           continue;
         }
         const other = called === undefined ? undefined : callOf(part);
@@ -378,7 +431,7 @@ export function contextualUses<Brand>(
       if (element !== undefined) {
         return mayCarry(element, seen);
       }
-      return callOf(part) !== undefined;
+      return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
     });
   };
 
@@ -433,6 +486,19 @@ export function contextualUses<Brand>(
       reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
     }
   });
+  const copies = new Map<Member, boolean>();
+  /** Whether a spread copies the member: where any declaration of it declares data. */
+  const copied = (member: Member): boolean => {
+    let known = copies.get(member);
+    if (known === undefined) {
+      known = member.declarations.some((handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node === undefined || copiedBySpread(node);
+      });
+      copies.set(member, known);
+    }
+    return known;
+  };
   const spreads = literals.flatMap(({ literal, from }) =>
     literal.properties.flatMap((property) =>
       isSpreadAssignment(property) ? [{ value: property.expression, from }] : [],
@@ -448,12 +514,10 @@ export function contextualUses<Brand>(
     if (type === undefined || !isAnswered(type)) {
       return;
     }
-    // A spread gets every own enumerable property, an overwritten key's getter included.
-    // So it reads each data member but a class's accessor, which sits on the prototype with
-    // the class's methods (never data members), and a private name, which is no property
+    // A spread gets every own enumerable property, an overwritten key's getter included,
+    // and no private name, which is no property
     // (https://tc39.es/ecma262/#sec-copydataproperties).
-    const own = (member: Member, id: string): boolean =>
-      !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-member");
+    const own = (member: Member, id: string): boolean => !privateNames.has(id) && copied(member);
     const ids = [
       ...new Set(
         partsOf(type).flatMap((part) =>

package/src/convention-rows.ts

@@ -158,7 +158,8 @@ const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 
 /**
  * The properties Vitest takes its project root from, `test.root` before Vite's `root`; it
- * resolves `setupFiles` against that root (https://vitest.dev/config/setupfiles).
+ * resolves `setupFiles` and `globalSetup` against that root
+ * (https://vitest.dev/config/setupfiles, https://vitest.dev/config/globalsetup).
  */
 const VITEST_ROOTS = ["test.root", "root"] as const;
 
@@ -660,6 +661,9 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       { property: "test.coverage.include", files: [VITEST_CONFIG] },
       { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
     ],
-    testFiles: [{ property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS }],
+    testFiles: [
+      { property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+      { property: "test.globalSetup", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+    ],
   },
 ];

package/src/conventions.ts

@@ -71,6 +71,11 @@ export interface ConventionManifest {
   readonly dir: string;
   /** The manifest's path below the target root, `/`-separated. */
   readonly path: string;
+  /**
+   * Whether the manifest is a nested package's, whose install no run requires: an
+   * enabling package it declares and nothing installs applies no row and fails nothing.
+   */
+  readonly nested?: boolean;
 }
 
 /** One row a run applied, as the report lists it. */
@@ -1007,7 +1012,11 @@ export function readConventions(
       }
       const version = versions.get(row.package);
       if (version === undefined) {
-        if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
+        if (
+          missing.has(row.package) ||
+          manifest.nested === true ||
+          !declares(declared, row.package, REQUIRED_SECTIONS)
+        ) {
           continue;
         }
         missing.add(row.package);

package/src/dependencies.ts

@@ -71,28 +71,37 @@ interface DeclaredDependency {
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
 export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
   return {
-    packages: new Set(packages),
     uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+    at: new Map([[ANYWHERE, new Set(packages)]]),
     unanswered: [],
   };
 }
 
+/** The key of {@link ProjectNeeds.at} for a use no file of the target governs. */
+const ANYWHERE = "";
+
 /** What the installed copy of one declared dependency states about itself. */
 interface InstalledDependency {
   /** The commands its manifest's `bin` declares, by name. */
   readonly commands: readonly string[];
+  /** The packages its manifest's `peerDependencies` names, optional ones included. */
+  readonly peers: readonly string[];
 }
 
 /** What one project's own files and configuration need from outside the target. */
 export interface ProjectNeeds {
-  /** Every package a use names or resolves to. */
-  readonly packages: ReadonlySet<string>;
   /**
    * Per declaration of the inventory, the packages the uses written inside it name; a
    * use is held by the innermost declaration around it. The empty key holds what the
    * compiler configuration names, which no deletion removes.
    */
   readonly uses: ReadonlyMap<string, ReadonlySet<string>>;
+  /**
+   * Per absolute path of the file a use is written in, the packages it names, which a
+   * dependency only a manifest at or above that file declares serves. The empty key holds
+   * the uses no one file holds, which every manifest's dependency of that name serves.
+   */
+  readonly at: ReadonlyMap<string, ReadonlySet<string>>;
   /**
    * The files writing a module specifier the checker left unanswered, each of which may
    * use any dependency a manifest at or above it declares.
@@ -104,11 +113,14 @@ export interface ProjectNeeds {
 export interface Dependencies {
   /** Every declared dependency, manifest by manifest, in the order each writes them. */
   readonly declared: readonly DeclaredDependency[];
-  /** Every package some project needs. */
+  /**
+   * The declared dependencies, by {@link declarationKey}, a use written at or below their
+   * manifest's directory needs, and each declared peer of a needed one.
+   */
   readonly needed: ReadonlySet<string>;
   /**
    * The declared dependencies whose command a script entry of the manifest declaring them,
-   * or a workflow step for the target's manifest, runs, each by {@link declarationKey}.
+   * or a workflow step of the target, runs, each by {@link declarationKey}.
    */
   readonly ran: ReadonlySet<string>;
   /**
@@ -322,9 +334,10 @@ export function projectNeeds<Brand>(
     programPackages,
   );
   const uses = new Map<string, Set<string>>();
-  const use = (owners: readonly string[], named: Iterable<string>): void => {
+  const at = new Map<string, Set<string>>();
+  const use = (owners: readonly string[], named: Iterable<string>, path: string): void => {
     for (const one of named) {
-      packages.add(one);
+      at.set(path, (at.get(path) ?? new Set()).add(one));
       for (const owner of owners) {
         let set = uses.get(owner);
         if (set === undefined) {
@@ -335,11 +348,14 @@ export function projectNeeds<Brand>(
       }
     }
   };
-  use([PROJECT_OWNER], packages);
+  use([PROJECT_OWNER], packages, project.configFile);
 
   const unanswered: string[] = [];
   for (const file of project.ownSourceFiles()) {
-    if (fileNeeds(project, held, file, programPackages, use)) {
+    const inFile = (owners: readonly string[], named: Iterable<string>): void => {
+      use(owners, named, file.fileName);
+    };
+    if (fileNeeds(project, held, file, programPackages, inFile)) {
       unanswered.push(file.fileName);
     }
   }
@@ -363,14 +379,14 @@ export function projectNeeds<Brand>(
   for (const { file } of configuration.modules) {
     const names = declaredAt(file.fileName);
     for (const { node, text } of moduleStrings(file)) {
-      use(ownersOf(file, held, node), dependenciesNamed(text, names));
+      use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
     }
   }
   for (const { strings, manifestDirs } of configuration.documents) {
     for (const manifestDir of manifestDirs) {
       const names = declaredAt(joinPath(manifestDir, "package.json"));
       for (const text of strings) {
-        use([PROJECT_OWNER], dependenciesNamed(text, names));
+        use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
       }
     }
   }
@@ -378,11 +394,11 @@ export function projectNeeds<Brand>(
     for (const manifestDir of manifestDirs) {
       const names = declaredAt(joinPath(manifestDir, "package.json"));
       for (const { text } of moduleStrings(file)) {
-        use([PROJECT_OWNER], dependenciesNamed(text, names));
+        use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
       }
     }
   }
-  return { packages, uses, unanswered };
+  return { uses, at, unanswered };
 }
 
 /** The declarations of the inventory a use written at one node belongs to. */
@@ -638,8 +654,10 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
     const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
     if (read !== undefined && isRecord(read.value)) {
       const bin = read.value["bin"];
+      const peers = read.value["peerDependencies"];
       // A string `bin` names one command, the package's name without its scope.
       return {
+        peers: isRecord(peers) ? Object.keys(peers) : [],
         commands:
           typeof bin === "string"
             ? bin === ""
@@ -711,13 +729,53 @@ function isInside(path: string, dir: string): boolean {
   return dir === "" || path.startsWith(`${dir}/`);
 }
 
+/** The directory below the target root a declared dependency's manifest is in, `""` being the root. */
+function manifestDir(dependency: DeclaredDependency): string {
+  const dir = dirnamePath(dependency.position.path);
+  return dir === "." ? "" : dir;
+}
+
+/**
+ * Adds to `needed` each declared dependency that the installed manifest of a needed or
+ * run declared dependency names as a peer, until no further one joins: the declaration of
+ * that name in the needing dependency's manifest or in a manifest above it, where the
+ * installed peer is resolved from. `peers` holds each declaration's installed peers by
+ * {@link declarationKey}.
+ */
+function addNeededPeers(
+  declared: readonly DeclaredDependency[],
+  peers: ReadonlyMap<string, readonly string[]>,
+  needed: Set<string>,
+  ran: ReadonlySet<string>,
+): void {
+  const pending = declared.filter(
+    (dependency) => needed.has(declarationKey(dependency)) || ran.has(declarationKey(dependency)),
+  );
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    const below = manifestDir(next);
+    for (const peer of peers.get(declarationKey(next)) ?? []) {
+      for (const dependency of declared) {
+        const key = declarationKey(dependency);
+        if (
+          dependency.name === peer &&
+          !needed.has(key) &&
+          (below === manifestDir(dependency) || isInside(below, manifestDir(dependency)))
+        ) {
+          needed.add(key);
+          pending.push(dependency);
+        }
+      }
+    }
+  }
+}
+
 /**
- * The run's dependency evidence: the target's manifest and each workspace member's in
- * `members` below the target root, read with the position of every dependency each
- * declares, what the projects and the commands its scripts and workflow steps run need,
- * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
- * in configurations the run could not build. A manifest the program cannot read declares
- * nothing.
+ * The run's dependency evidence over the target's manifest and those of `members` and
+ * `nested` packages below the root: each declared dependency's position, what the projects,
+ * scripts and workflow steps need, and each deletion candidate's last uses. A member in
+ * `unbuilt` holds source only in configurations the run could not build. An unreadable
+ * manifest declares nothing, nor does a nested package's uninstalled dependency, because
+ * no run requires a nested package to be installed.
  */
 export function dependenciesOf(
   host: Host,
@@ -726,12 +784,13 @@ export function dependenciesOf(
   candidates: readonly string[],
   members: readonly string[] = [],
   unbuiltMembers: readonly string[] = [],
+  nested: readonly string[] = [],
 ): Dependencies {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const scopeOf = packageScope(host, targetRoot);
   const manifests = new Map<string, string>([[root, MANIFEST]]);
   const unbuilt = new Set<string>();
-  for (const dir of [...members, ...unbuiltMembers]) {
+  for (const dir of [...members, ...unbuiltMembers, ...nested]) {
     const below = relativePath(root, dir);
     if (below !== undefined && !manifests.has(dir)) {
       manifests.set(dir, `${below}/${MANIFEST}`);
@@ -746,6 +805,8 @@ export function dependenciesOf(
   const workflow = new Set(workflowTokens(host, targetRoot));
   const declared: DeclaredDependency[] = [];
   const ran = new Set<string>();
+  const peers = new Map<string, readonly string[]>();
+  const uninstalledHere = new Set(nested);
   for (const [dir, path] of manifests) {
     const read = readJSON(host, joinPath(dir, MANIFEST));
     if (read === undefined || !isRecord(read.value)) {
@@ -753,13 +814,16 @@ export function dependenciesOf(
     }
     const tokens = scriptTokensOf(read.value);
     for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
-      declared.push(dependency);
       const found = installedOf(host, dir, dependency.name);
+      if (found === undefined && uninstalledHere.has(dir)) {
+        continue;
+      }
+      declared.push(dependency);
       if (found === undefined) {
         continue;
       }
-      const runs = (command: string): boolean =>
-        tokens.has(command) || (dir === root && workflow.has(command));
+      peers.set(declarationKey(dependency), found.peers);
+      const runs = (command: string): boolean => tokens.has(command) || workflow.has(command);
       if (found.commands.some(runs)) {
         ran.add(declarationKey(dependency));
       }
@@ -769,25 +833,38 @@ export function dependenciesOf(
   // A declaration several projects compile is one user, and a use any project makes is
   // a use, so the uses are merged by declaration before anything is counted.
   const needed = new Set<string>();
+  const byName = new Map<string, DeclaredDependency[]>();
+  for (const dependency of declared) {
+    byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
+  }
   const uses = new Map<string, Set<string>>();
   for (const project of perProject) {
     // A specifier the checker left unanswered may resolve to any dependency a manifest at
     // or above its file declares, and what the configuration needs is never deleted.
     const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
-    const unknown = declared
-      .filter((dependency) => {
-        const dir = dirnamePath(dependency.position.path);
-        return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
-      })
-      .map((dependency) => dependency.name);
+    const unknownDeclared = declared.filter((dependency) =>
+      unanswered.some((file) => isInside(file, manifestDir(dependency))),
+    );
+    unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+    const unknown = unknownDeclared.map((dependency) => dependency.name);
     const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)] as const];
     for (const [id, used] of [...project.uses, ...held]) {
       const merged = uses.get(id) ?? new Set<string>();
       used.forEach((one) => merged.add(one));
       uses.set(id, merged);
     }
-    [...project.packages, ...unknown].forEach((one) => needed.add(one));
+    for (const [path, named] of project.at) {
+      const below = path === ANYWHERE ? undefined : relativePath(root, path);
+      for (const one of named) {
+        for (const dependency of byName.get(one) ?? []) {
+          if (below === undefined || isInside(below, manifestDir(dependency))) {
+            needed.add(declarationKey(dependency));
+          }
+        }
+      }
+    }
   }
+  addNeededPeers(declared, peers, needed, ran);
   const users = new Map<string, number>();
   for (const used of uses.values()) {
     used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));