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

package/src/contextual-uses.ts

@@ -3,8 +3,8 @@
  * 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 {
@@ -18,12 +18,13 @@ import {
   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, SymbolFlags, 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 +46,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 +94,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;
 }
@@ -116,6 +118,8 @@ interface Member {
   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;
 }
 
 /**
@@ -135,6 +139,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);
@@ -177,6 +186,7 @@ export function contextualUses<Brand>(
           property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`),
         ),
         own: property.declarations.some((handle) => ownPaths.has(handle.path)),
+        accessor: (property.flags & SymbolFlags.Accessor) !== 0,
       });
     }
     tables.set(type.id, table);
@@ -269,13 +279,22 @@ export function contextualUses<Brand>(
   };
 
   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 +304,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,
       };
@@ -330,7 +350,7 @@ export function contextualUses<Brand>(
           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) => {
@@ -413,5 +433,39 @@ export function contextualUses<Brand>(
       reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
     }
   });
+  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.
+    // 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
+    // (https://tc39.es/ecma262/#sec-copydataproperties).
+    const own = (member: Member, id: string): boolean =>
+      !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-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,12 @@ 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` against that root (https://vitest.dev/config/setupfiles).
+ */
+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 +660,6 @@ 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 }],
   },
 ];

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";
@@ -119,6 +120,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 +611,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 +993,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>();
@@ -1025,6 +1066,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 +1097,7 @@ export function readConventions(
     failures,
     uses: [...uses].sort(compare),
     selected,
+    testFiles,
   };
 }
 

package/src/dependencies.ts

@@ -59,7 +59,7 @@ const SECTIONS: readonly (readonly [string, DependencySection])[] = [
 const PROJECT_OWNER = "";
 
 /** One dependency a manifest the run reads declares. */
-export interface DeclaredDependency {
+interface DeclaredDependency {
   readonly name: string;
   readonly section: DependencySection;
   /** Where the manifest writes the dependency's key, below the target root. */
@@ -78,7 +78,7 @@ export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
 }
 
 /** What the installed copy of one declared dependency states about itself. */
-export interface InstalledDependency {
+interface InstalledDependency {
   /** The commands its manifest's `bin` declares, by name. */
   readonly commands: readonly string[];
 }
@@ -366,16 +366,20 @@ export function projectNeeds<Brand>(
       use(ownersOf(file, held, node), dependenciesNamed(text, names));
     }
   }
-  for (const document of configuration.documents) {
-    const names = declaredAt(document.path);
-    for (const text of document.strings) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  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));
+      }
     }
   }
-  for (const { file, manifestDir } of configuration.outside) {
-    const names = declaredAt(joinPath(manifestDir, "package.json"));
-    for (const { text } of moduleStrings(file)) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  for (const { file, manifestDirs } of configuration.outside) {
+    for (const manifestDir of manifestDirs) {
+      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      for (const { text } of moduleStrings(file)) {
+        use([PROJECT_OWNER], dependenciesNamed(text, names));
+      }
     }
   }
   return { packages, uses, unanswered };

package/src/discover.ts

@@ -34,7 +34,7 @@ export class DiscoveryError extends Error {
 const ERROR_CATEGORY: number = DiagnosticCategory.Error;
 
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic: Diagnostic): boolean {
+function isError(diagnostic: Diagnostic): boolean {
   return diagnostic.category === ERROR_CATEGORY;
 }
 
@@ -113,7 +113,7 @@ export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
 }
 
 /** One project a run analyzes. */
-export interface DiscoveredProject {
+interface DiscoveredProject {
   /**
    * The name a run gives the project: the identifier the build matrix declares for
    * it, or, for a project discovery derived, its configuration file's path below the
@@ -162,7 +162,7 @@ export function isGuess(discovery: Discovery, configFile: string): boolean {
 }
 
 /** Every project discovery found, and where each came from. */
-export interface Discovery {
+interface Discovery {
   /** The projects, in discovery order, each once. */
   readonly projects: readonly DiscoveredProject[];
   /**

package/src/edges.ts

@@ -39,7 +39,7 @@ const REFERENCE_WANT =
   "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
   constructor(at: string, text: string, want: string) {
     super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
     this.name = "EdgesError";
@@ -174,7 +174,7 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
 }
 
 /** One side's verdict, as an evaluation names it. */
-export type EdgeState = "live" | "dead" | "absent";
+type EdgeState = "live" | "dead" | "absent";
 
 /** One edge evaluation: one side of this language, its state, and the finding it holds. */
 export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
@@ -184,7 +184,7 @@ export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
 }
 
 /** The findings a report publishes, and one evaluation per declared side of this language. */
-export interface Evaluated<F extends Finding> {
+interface Evaluated<F extends Finding> {
   readonly findings: readonly F[];
   /** Ordered by edge, then by side, each compared bytewise. */
   readonly evaluations: readonly EdgeEvaluation<F>[];

package/src/entry-points.ts

@@ -64,7 +64,7 @@ export type EntryRule =
   | "workflow-step";
 
 /** One file a rule enters. */
-export interface EntryPoint {
+interface EntryPoint {
   readonly file: SourceFile;
   readonly rule: EntryRule;
   /**

package/src/exempt-classes.ts

@@ -1,16 +1,12 @@
 /**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on, the confidence it is recorded at and, for a class that runs
- * on TypeScript, which private members it may retain.
- *
- * The rows are written out rather than read from the Contract at run time, for the
- * reason the fixed severity codes are, and a test holds them equal to the Contract
- * release this analyzer implements. A class name is a type, so a detector table or a
- * record naming a class the vocabulary does not hold, or one that runs on another
- * language only, does not compile.
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
+ * languages and, for a TypeScript class, which private members it may retain. The rows are
+ * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
+ * A class name is a type, so a table or a record naming a class outside the vocabulary, or
+ * one of another language only, does not compile.
  */
 
-import type { Confidence, Language } from "./config.ts";
+import type { Language } from "./config.ts";
 
 /**
  * Whether a class may retain a member declared with the `private` modifier, and one
@@ -27,7 +23,6 @@ export interface TypeScriptVisibility {
 interface ExemptionClassRow {
   readonly class: string;
   readonly languages: readonly Language[];
-  readonly confidence: Confidence;
   /** Present exactly on a class that runs on TypeScript. */
   readonly typescriptVisibility?: TypeScriptVisibility;
 }
@@ -37,59 +32,50 @@ export const EXEMPTION_CLASSES = [
   {
     class: "interface-satisfaction",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: false, privateName: false },
   },
-  { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
-  { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
-  { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+  { class: "encoding-reflection", languages: ["go"] },
+  { class: "format-verb-contract", languages: ["go"] },
+  { class: "errors-duck-typing", languages: ["go"] },
   {
     class: "enum-group",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: false, privateName: false },
   },
   {
     class: "generated-file",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
-  { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+  { class: "linkname-cgo-asm-plugin", languages: ["go"] },
   {
     class: "template-field",
     languages: ["go", "ts"],
-    confidence: "possible",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "reflective-lookup",
     languages: ["go", "ts"],
-    confidence: "possible",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "decorator",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "injection-container",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "framework-lifecycle",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "serialization-contract",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
 ] as const satisfies readonly ExemptionClassRow[];

package/src/exempt.ts

@@ -64,9 +64,7 @@ export type Detector = <Brand>(input: DetectorInput<Brand>) => readonly Evidence
 export type Detectors = ReadonlyMap<TSExemptionClass, Detector>;
 
 /** What decides which records of one project stand. */
-export interface Holding {
-  /** The classes the configuration switches off, whose detectors do not run. */
-  readonly disabled: ReadonlySet<ExemptionClass>;
+interface Holding {
   readonly mode: Mode;
   /** The paths the reference pass classified as test files. */
   readonly testFiles: ReadonlySet<string>;
@@ -154,23 +152,8 @@ function detected<Brand>(
   }
 }
 
-/**
- * The records one project's detectors found, each class in the vocabulary's order and
- * none of a switched-off class. Evidence on a private member the class's row says it
- * cannot retain is dropped first, whatever the detector found. Under a production mode
- * a record whose evidence is written in a test file holds nothing, as a reference a
- * test file makes is none there.
- */
-export function computeExemptions<Brand>(
-  input: DetectorInput<Brand>,
-  detectors: Detectors,
-  holding: Holding,
-): readonly Exemption[] {
-  return detectExemptions(input, detectors, holding).records;
-}
-
 /** One project's records, and the evidence a production mode found in a test file. */
-export interface Detected {
+interface Detected {
   readonly records: readonly Exemption[];
   /**
    * Under a production mode, each record whose evidence is written in a test file. It
@@ -180,18 +163,11 @@ export interface Detected {
   readonly inTestFiles: readonly Exemption[];
 }
 
-/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
-export function detectExemptions<Brand>(
-  input: DetectorInput<Brand>,
-  detectors: Detectors,
-  holding: Holding,
-): Detected {
-  return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
-}
-
 /**
  * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads.
+ * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
+ * vocabulary's order and a switched-off class runs not at all; evidence on a private
+ * member the class's row says it cannot retain is dropped, whatever the detector found.
  */
 export function evidenceRecords<Brand>(
   input: DetectorInput<Brand>,

package/src/file-facts.ts

@@ -22,7 +22,7 @@ const DECLARATION_FILE = /\.d\.(?:[^./]+\.)?[mc]?ts$/u;
 const LINE_BREAK = /\r\n|[\n\r\u2028\u2029]/gu;
 
 /** One source file below the target root. */
-export interface TreeFile {
+interface TreeFile {
   /** The path below the target root, with the solidus as separator. */
   readonly path: string;
   /** The stable reference of the file's module. */

package/src/finding.ts

@@ -25,7 +25,7 @@ export interface FindingPosition {
 }
 
 /** What a finding is about. */
-export interface FindingSubject {
+interface FindingSubject {
   /** The stable symbol reference, or for a configured root the root as written. */
   readonly ref: string;
   /** The subject kind, from the closed vocabulary of the finding schema. */
@@ -65,6 +65,8 @@ export interface FindingDetails {
   readonly entry?: SuppressionEntry;
   /** On the intra-function kinds: the external rules that report the same kind, as the vocabulary lists them. */
   readonly overlap?: readonly string[];
+  /** On a deletable finding: the dependencies whose last use deleting the subject removes. */
+  readonly removesLastUseOf?: readonly string[];
 }
 
 /** One suppression in the four-member form the ignore file and the baseline share. */