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

package/src/contextual-uses.ts

@@ -3,27 +3,31 @@
  * An object-literal property writes the member of its name on each constituent of the
  * literal's contextual type that declares one. A value reaching a position typed by another
  * object type reads each of its members that type declares, through array elements and
- * function parameters and results too; a class instance there is the
- * interface-satisfaction class's evidence instead.
+ * the parameters and results of functions and constructors too; a class instance there is
+ * the interface-satisfaction class's evidence instead.
  */
 
 import {
+  isClassDeclaration,
+  isClassExpression,
   isComputedPropertyName,
   isGetAccessorDeclaration,
   isIdentifier,
   isMethodDeclaration,
+  isMethodSignatureDeclaration,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectLiteralExpression,
   isPropertyAssignment,
   isSetAccessorDeclaration,
   isShorthandPropertyAssignment,
+  isSpreadAssignment,
   isStringLiteral,
   type Expression,
   type Node,
   type ObjectLiteralExpression,
 } from "@typescript/native/unstable/ast";
-import { SignatureKind, 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";
@@ -45,14 +49,14 @@ export interface FlowAt {
 }
 
 /** One use the contextual types make: the node it is written at and the members it names. */
-export interface ContextualUse {
+interface ContextualUse {
   readonly at: Node;
   readonly from: string;
   readonly ids: readonly string[];
 }
 
 /** What the contextual types of one project's literals and values use, and what asking cost. */
-export interface ContextualUses {
+interface ContextualUses {
   /** Each literal property that writes a member, by the property's node. */
   readonly writes: readonly ContextualUse[];
   /** Each value whose members a position typed by another object type reads. */
@@ -93,8 +97,9 @@ function propertyName(
   return undefined;
 }
 
-/** The parameter and result types of one call signature, each where the checker answered. */
+/** The parameter and result types of one call or construct signature, each where the checker answered. */
 interface Called {
+  readonly kind: SignatureKind;
   readonly parameters: readonly (Type | undefined)[];
   readonly result: Type | undefined;
 }
@@ -113,9 +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;
+  /** 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))
+  );
 }
 
 /**
@@ -135,6 +161,11 @@ export function contextualUses<Brand>(
   const queries = project.queries;
   const ownPaths = project.ownPaths();
   const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+  const privateNames = new Set(
+    held.symbols
+      .filter((symbol) => symbol.visibility === "private-name")
+      .map((symbol) => symbol.id),
+  );
   let batches = 0;
   let lookups = 0;
   const batchesOf = (count: number): number => Math.ceil(count / cap);
@@ -173,10 +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)),
+        declarations: property.declarations.filter((handle) => ownPaths.has(handle.path)),
       });
     }
     tables.set(type.id, table);
@@ -240,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. */
@@ -268,14 +305,37 @@ 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, read once per type. */
+  /**
+   * The parameter and return types of a type's one call signature, or of its one construct
+   * signature where it has no call signature, read once per type.
+   */
   const callOf = (type: Type): Called | undefined => {
     if (calls.has(type.id)) {
       return calls.get(type.id);
     }
     lookups += 1;
-    const signatures = queries.signaturesOf(type, SignatureKind.Call);
+    let kind = SignatureKind.Call;
+    let signatures = queries.signaturesOf(type, kind);
+    if (isAnswered(signatures) && signatures.length === 0) {
+      lookups += 1;
+      kind = SignatureKind.Construct;
+      signatures = queries.signaturesOf(type, kind);
+    }
     let called: Called | undefined;
     const [signature, ...more] = isAnswered(signatures) ? signatures : [];
     if (signature !== undefined && more.length === 0) {
@@ -285,6 +345,7 @@ export function contextualUses<Brand>(
       const result = queries.returnTypeOf(signature);
       lookups += parameters.length + 1;
       called = {
+        kind,
         parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
         result: isAnswered(result) ? result : undefined,
       };
@@ -295,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,
@@ -324,13 +386,24 @@ 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);
-        if (called === undefined || other === undefined) {
+        if (called === undefined || other?.kind !== called.kind) {
           continue;
         }
         other.parameters.forEach((parameter, index) => {
@@ -358,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));
     });
   };
 
@@ -413,5 +486,50 @@ 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 }] : [],
+    ),
+  );
+  batches += batchesOf(spreads.length);
+  const spreadTypes = queries.typesAt(
+    spreads.map((one) => one.value),
+    cap,
+  );
+  spreads.forEach(({ value, from }, index) => {
+    const type = spreadTypes[index];
+    if (type === undefined || !isAnswered(type)) {
+      return;
+    }
+    // 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) && copied(member);
+    const ids = [
+      ...new Set(
+        partsOf(type).flatMap((part) =>
+          [...membersOf(part).values()].flatMap((member) =>
+            member.ids.filter((id) => own(member, id)),
+          ),
+        ),
+      ),
+    ];
+    if (ids.length > 0) {
+      reads.push({ at: value, from, ids });
+    }
+  });
   return { writes, reads, batches, lookups };
 }

package/src/convention-rows.ts

@@ -53,6 +53,16 @@ export interface PackageKey {
   readonly files: readonly string[];
 }
 
+/** One configuration property whose strings name files the test runner loads beside the tests. */
+export interface TestFileReading extends MoveReading {
+  /**
+   * The properties that move the directory the strings are read against, the first one the
+   * file writes deciding, read against the manifest's directory, which stands where none is
+   * written. A value that is not one string literal leaves the file's strings unread.
+   */
+  readonly roots: readonly string[];
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -91,6 +101,8 @@ export interface ConventionRow {
    * string there names no file the tool runs or loads.
    */
   readonly selections?: readonly MoveReading[];
+  /** The properties whose strings name a file the test runner loads beside the tests, a test file. */
+  readonly testFiles?: readonly TestFileReading[];
   /**
    * The members whose strings name a package the tool loads: the package itself, a
    * subpath of it, or the package followed by `:` and a name.
@@ -144,6 +156,13 @@ const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 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` and `globalSetup` against that root
+ * (https://vitest.dev/config/setupfiles, https://vitest.dev/config/globalsetup).
+ */
+const VITEST_ROOTS = ["test.root", "root"] as const;
+
 /** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
 const ANGULAR_ENTRIES = [
   "src/{main,main.server,server,polyfills,test}.ts",
@@ -642,5 +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 },
+      { property: "test.globalSetup", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+    ],
   },
 ];

package/src/conventions.ts

@@ -55,6 +55,7 @@ import {
   type OptionsCall,
   type PackageKey,
   type ShortNameReading,
+  type TestFileReading,
 } from "./convention-rows.ts";
 import { documentStrings } from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
@@ -70,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. */
@@ -119,6 +125,8 @@ export interface Conventions {
   readonly uses: readonly string[];
   /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
   readonly selected: ReadonlyMap<string, Selected>;
+  /** The files, absolute, an applied row's test-file properties name. */
+  readonly testFiles: ReadonlySet<string>;
 }
 
 /** The strings one configuration file holds at selection keys, which root no file. */
@@ -608,6 +616,43 @@ function holdsValue(held: Node, value: true | string): boolean {
   );
 }
 
+/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
+function testFileRoot(file: SourceFile, dir: string, reading: TestFileReading): string | undefined {
+  for (const property of reading.roots) {
+    const values = valuesAt(file, property, reading.call);
+    if (values.length > 0) {
+      const texts = new Set(values.map(literalText));
+      const [text] = texts;
+      return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
+    }
+  }
+  return dir;
+}
+
+/** The files an applied row's test-file properties name. */
+function testFilesNamed(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  readings: readonly TestFileReading[],
+  into: Set<string>,
+): void {
+  for (const reading of readings) {
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      const at = testFileRoot(file, dir, reading);
+      if (at === undefined) {
+        continue;
+      }
+      for (const node of stringsAt(file, reading.property, reading.call)) {
+        const text = literalText(node);
+        if (text !== undefined && text !== "") {
+          into.add(resolvePath(at, text));
+        }
+      }
+    }
+  }
+}
+
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(
   host: Host,
@@ -953,6 +998,7 @@ export function readConventions(
   const failures: ConventionFailure[] = [];
   const uses = new Set<string>();
   const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
+  const testFiles = new Set<string>();
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
     const versions = new Map<string, string | undefined>();
@@ -966,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);
@@ -1025,6 +1075,7 @@ export function readConventions(
         uses.add(name);
       }
       selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
+      testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -1055,6 +1106,7 @@ export function readConventions(
     failures,
     uses: [...uses].sort(compare),
     selected,
+    testFiles,
   };
 }