@cplieger/deadset-ts 8.0.0-dev.20 → 8.0.0-dev.22

package/dist/src/alias-chain.js

@@ -1,12 +1,12 @@
 /**
  * Where an import or export chain leads in one project: from one symbol to each
  * declaration of the target it is, and along the chain of aliases it heads to each
- * declaration every link of that chain is.
+ * declaration every link of that chain is, and what a name resolves to through them.
  */
 import { isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceExport, isNamespaceImport, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { isParameterProperty, nodeKey } from "./inventory.js";
-import { UNANSWERED } from "./query.js";
+import { must, UNANSWERED } from "./query.js";
 /**
  * The chain walks over one project, against the declarations of `held`, the same
  * project's inventory.
@@ -145,3 +145,34 @@ export function aliasChains(project, held) {
         nextDeclared,
     };
 }
+/**
+ * What each of a batch of nodes resolves to, every alias followed to the declaration
+ * it stands for. A node the checker resolves to nothing, and an alias that resolves
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
+ */
+export function resolvedTargets(project, nodes) {
+    const followed = new Map();
+    const targets = new Map();
+    project
+        .symbolsAt(nodes.map((node) => project.handle(node)))
+        .map(must)
+        .forEach((symbol, index) => {
+        const node = nodes[index];
+        if (symbol === undefined || node === undefined) {
+            return;
+        }
+        let target = symbol;
+        if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+            if (!followed.has(symbol.id)) {
+                const aliased = must(project.queries.aliased(symbol));
+                followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+            }
+            target = followed.get(symbol.id);
+        }
+        if (target !== undefined) {
+            targets.set(node, target);
+        }
+    });
+    return targets;
+}

package/dist/src/analysis.js

@@ -10,7 +10,6 @@ import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
 import { consumerReferences } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
-import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { carriersOf, NO_CARRIERS } from "./exposure.js";
 import { deprecatedDeclarations } from "./deprecation.js";
@@ -19,19 +18,16 @@ import { loadRun } from "./load/load.js";
 import { readSources } from "./entries/sources.js";
 import { readWorkflows } from "./entries/workflow-steps.js";
 import { readEdgeSides } from "./edges.js";
-import { enumGroup } from "./enum-group.js";
 import { bindingsOf, distinctBindings } from "./bindings.js";
-import { generatedFile, generatedFilesOf } from "./generated-file.js";
+import { generatedFilesOf } from "./exemptions/generated-file.js";
 import { inOperandNames } from "./findings/in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, isUnansweredRecord, writtenRecords, } from "./exempt.js";
+import { DETECTORS, detection } from "./exemptions/detectors.js";
+import { exemptionsOf, settle } from "./exemptions/lifecycle.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
-import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./findings/implementations.js";
-import { injectionContainer } from "./injection-container.js";
-import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import {} from "./inventory.js";
 import { inventory } from "./inventory/enumerate.js";
@@ -40,10 +36,9 @@ import { matrixOf, referenceKey } from "./liveness/matrix.js";
 import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { skippedUnits } from "./type-errors.js";
-import { reflectiveLookup } from "./reflective-lookup.js";
 import { references } from "./references.js";
 import { rootSet, unmatchedEverywhere, } from "./roots/root-set.js";
-import { decodedMembers, serializationContract } from "./serialization-contract.js";
+import { decodedMembers } from "./exemptions/serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./tests/outside.js";
 import { formedForNode } from "./load/synthesize.js";
 import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
@@ -54,7 +49,6 @@ import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { sweep } from "./liveness/sweep.js";
-import { readTemplates, templateField } from "./template-field.js";
 import { bytewise } from "./text/compare.js";
 import { holdsManifest, manifestAt } from "./fs/manifest.js";
 import { runDirectories } from "./entries/run-directories.js";
@@ -230,18 +224,6 @@ export function productionMode(config) {
         consumerTestsProduction: config.analysis.consumer_tests === "production",
     };
 }
-/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-export const DETECTORS = new Map([
-    ["interface-satisfaction", interfaceSatisfaction],
-    ["enum-group", enumGroup],
-    ["generated-file", generatedFile],
-    ["template-field", templateField],
-    ["reflective-lookup", reflectiveLookup],
-    ["decorator", decorator],
-    ["injection-container", injectionContainer],
-    ["framework-lifecycle", frameworkLifecycle],
-    ["serialization-contract", serializationContract],
-]);
 /** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
 const DEV_SECTION = "devDependencies";
 const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"];
@@ -288,11 +270,8 @@ function testEvidence(host, targetRoot, projects) {
  */
 function readRun(engine, host, scope, config, mode, detectors, extra) {
     const targetRoot = scope.target.path;
-    const disabled = disabledClasses(config);
-    const templates = disabled.has("template-field")
-        ? { delimiters: config.analysis.template_delimiters, files: [] }
-        : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
+    const detect = detection(host, targetRoot, config, consumers, detectors);
     const directories = runDirectories(host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text));
     const read = readProjects(engine, host, scope, config, (project, opened) => {
         const projectRead = opened.read();
@@ -303,17 +282,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             formedForNode: projectRead.formedForNode,
         });
         const testFiles = testFilePaths(project, targetRoot, testFile);
-        const evidence = evidenceRecords({
-            project,
-            held: projectRead.held,
-            targetRoot,
-            templates,
-            ts: config.ts,
-            consumers,
-            ...(config.analysis.generated_files === "include"
-                ? {}
-                : { generated: projectRead.generated }),
-        }, detectors, disabled);
+        const evidence = detect({ project, held: projectRead.held, generated: projectRead.generated });
         const components = project.ownSourceFiles().filter(isComponentFile);
         const injected = project.program
             .getSourceFileNames()
@@ -378,27 +347,26 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             ...one.decoded.copied,
         ]),
     ]);
-    const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
-    const settled = settledSatisfaction(withOutside.map((one, index) => ({
-        evidence: evidence[index] ?? [],
+    const settled = settle(withOutside.map((one) => ({
+        records: one.evidence,
         held: one.projectRead.held,
-    })), [...withOutside.flatMap((one) => one.references), ...read.result.references]);
+        testFiles: new Set([...one.testFiles, ...support]),
+    })), {
+        references: [...withOutside.flatMap((one) => one.references), ...read.result.references],
+        written,
+        mode,
+    });
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
-        const satisfied = settled[index];
-        const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
-            mode,
-            testFiles: new Set([...one.testFiles, ...support]),
-        });
-        const exempt = detected.records;
-        const made = [...one.references, ...(satisfied?.references ?? [])];
+        const exempt = settled[index]?.records ?? [];
+        const made = [...one.references, ...(settled[index]?.references ?? [])];
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
         const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
         const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
+            references: made,
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
@@ -420,7 +388,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 ...projectRead.rooted.unanswered,
                 ...made.filter((reference) => reference.guessed === true).map((reference) => reference.to),
                 ...one.held,
-                ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+                ...exempt.filter((record) => record.unanswered === true).map((record) => record.id),
                 ...one.decoded.unanswered,
             ],
             filledOutside: one.decoded.filled,
@@ -470,33 +438,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         workflows: read.result.workflows,
     };
 }
-/**
- * The test references exemption evidence written in a test file makes: each is a read of
- * the declaration it would retain, made by the test file at the evidence's site.
- */
-function evidenceReferences(symbols, inTestFiles) {
-    if (inTestFiles.length === 0) {
-        return [];
-    }
-    const files = new Map(symbols
-        .filter((symbol) => symbol.kind === "file")
-        .map((symbol) => [symbol.position.path, symbol.id]));
-    return inTestFiles.flatMap((record) => {
-        const from = files.get(record.site.path);
-        return from === undefined
-            ? []
-            : [
-                {
-                    from,
-                    to: record.id,
-                    position: record.site,
-                    use: "read",
-                    resolution: "syntax",
-                    test: true,
-                },
-            ];
-    });
-}
 /**
  * The declarations a write the mode counts stores into, a write a test-support file
  * makes being a test's.

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "6.0.0",
+        corpusVersion: "6.1.0",
         result: "pass",
-        digest: "sha256:e4af2b9bcd07fd745101bf3215cd21e9df1448bdc332a791f25d5676cf15c794",
+        digest: "sha256:fcfdf88a7d45e1ac96545ef10c8427462260f4e81641d4d808b80086256bb6b7",
     },
     gaps: [],
 };

package/dist/src/contract/contract.generated.js

@@ -3,7 +3,7 @@ export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"];
 export const SCHEMA_VERSION = "9.0.0";
 export const FACTS_VERSION = "1.0.0";
-export const CORPUS_VERSION = "6.0.0";
+export const CORPUS_VERSION = "6.1.0";
 export const CODE_PREFIX = "DS";
 export const FAMILY_KEY_LENGTH = 4;
 export const LANGUAGES = ["go", "ts", "proto"];
@@ -266,7 +266,7 @@ export const KIND_ROWS = [
         subject: "part",
         holdsLive: false,
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A function's `length` counts each parameter before the first one with a default or a rest, and code holding the function may read it, so in TypeScript an unread parameter that `length` counts is reported at `probable` where the function is used as a value or is a root, which a library's published API is and which code outside the program calls, and a function whose `length` the program reads through its own name reports no parameter. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
         details: { overlap: "required" },
         defaultEnabled: true,
         defaultSeverity: "warn",
@@ -371,7 +371,7 @@ export const KIND_ROWS = [
         languages: ["go", "ts"],
         subject: "declaration",
         holdsLive: true,
-        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Four subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. A Go function a driver finds by its exported name is excluded, whatever else refers to it, because unexporting it stops the driver from running it: a test, a benchmark, a fuzz test or an example of a test file, TestMain, a test method a suite runner calls, and a go-fuzz entry point. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
@@ -386,7 +386,7 @@ export const KIND_ROWS = [
         languages: ["go"],
         subject: "declaration",
         holdsLive: true,
-        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Four subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. A Go function a driver finds by its exported name is excluded, whatever else refers to it, because unexporting it stops the driver from running it: a test, a benchmark, a fuzz test or an example of a test file, TestMain, a test method a suite runner calls, and a go-fuzz entry point. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
@@ -1361,6 +1361,7 @@ export const FAILURE_CLASSES = {
     "unwritten-output": "run",
     "unreportable-path": "run",
     "memory-exhausted": "run",
+    "missing-toolchain": "run",
     "missing-analyzer": "run",
     "unadmitted-analyzer": "run",
     "unresolved-edge": "run",

package/dist/src/dependencies.js

@@ -67,7 +67,7 @@ export function packageOfSpecifier(specifier) {
     return second === undefined || second === "" || first === "@" ? undefined : `${first}/${second}`;
 }
 /** The package an installed file belongs to, read below the last dependency directory of its path. */
-function packageOfPath(path) {
+export function packageOfPath(path) {
     const at = path.lastIndexOf(MODULES_SEGMENT);
     return at < 0 ? undefined : packageOfSpecifier(path.slice(at + MODULES_SEGMENT.length));
 }

package/dist/src/exemptions/argument-places.js

@@ -0,0 +1,131 @@
+/**
+ * Which parameter place each argument of a call binds, the one reading every question
+ * about a call's arguments asks. A plain argument fills the next place, and a spread or
+ * an `apply` list typed as a tuple whose elements are all required fills one place per
+ * element. Any other spread or list has no known length: from its first place on, each of
+ * its element types, and every later argument, may fill any place, so a value is never
+ * read as missing a parameter only because its place could not be read. The type at each
+ * place is the checker's answer for it, so this reading names places and never types them.
+ */
+import { isSpreadElement } from "@typescript/native/ast";
+import { ElementFlags } from "@typescript/native/sync";
+import { must } from "../query.js";
+/** The element flags of a tuple type; none for another type. */
+function elementFlags(project, type) {
+    const target = type.isTupleType() ? must(project.queries.targetOf(type)) : undefined;
+    return target?.isTupleTypeTarget() === true ? target.elementFlags : [];
+}
+/** What a spread argument puts at the places it fills, and how many it fills at least. */
+function spread(project, type) {
+    const { queries } = project;
+    if (type === undefined) {
+        return { types: [undefined], fixed: false, least: 0 };
+    }
+    if (type.isTupleType()) {
+        const flags = elementFlags(project, type);
+        return {
+            types: must(queries.typeArguments(type)).slice(0, flags.length),
+            fixed: flags.every((flag) => (flag & ElementFlags.Required) !== 0),
+            least: flags.filter((flag) => (flag & ElementFlags.Required) !== 0).length,
+        };
+    }
+    if (must(queries.isArray(type))) {
+        return { types: must(queries.typeArguments(type)), fixed: false, least: 0 };
+    }
+    // Another iterable's elements are read off its type arguments, as `Set<T>` holds `T`.
+    return { types: [type, ...must(queries.typeArguments(type))], fixed: false, least: 0 };
+}
+/** The element types of a tuple of `count` required elements; none for another type. */
+export function knownElements(project, type, count) {
+    if (!type.isTupleType()) {
+        return undefined;
+    }
+    const elements = spread(project, type);
+    return elements.fixed && elements.types.length === count ? elements.types : undefined;
+}
+/**
+ * The places each argument fills, `types` holding the type of each argument's value; it
+ * may be empty where no argument is a spread and no given type is read. `listed` reads
+ * the last argument as a list whose elements the places bind.
+ */
+export function spansOf(project, args, listed, types) {
+    const spans = [];
+    let place = 0;
+    let open = false;
+    for (const [at, argument] of args.entries()) {
+        const type = types[at];
+        if (!isSpreadElement(argument) && !(listed && at === args.length - 1)) {
+            spans.push({ argument: at, first: place, given: [type], open, spread: false });
+            place += 1;
+            continue;
+        }
+        const elements = spread(project, type);
+        open ||= !elements.fixed;
+        spans.push({ argument: at, first: place, given: elements.types, open, spread: true });
+        place += elements.least;
+    }
+    return spans;
+}
+/**
+ * The places of one signature as the checker counts them: one per parameter, and in
+ * place of a rest as many as the `length` the checker answers for its type, where that
+ * is a number literal or a union of them. Any other `length`, an array's or an array-like
+ * interface's `number` among them, leaves the rest open.
+ */
+export function layoutOf(project, signature) {
+    const { queries } = project;
+    const fixed = signature.parameters.length;
+    const rest = must(queries.restTypeOf(signature));
+    if (rest === undefined) {
+        return { count: fixed, repeats: false };
+    }
+    const length = must(queries.propertyTypeOf(rest, "length"));
+    const lengths = length === undefined ? [] : must(queries.constituents(length));
+    const bounds = lengths.flatMap((one) => (one.isNumberLiteralType() ? [one.value] : []));
+    if (bounds.length > 0 && bounds.length === lengths.length) {
+        return { count: fixed - 1 + Math.max(...bounds), repeats: false };
+    }
+    return { count: fixed, repeats: true };
+}
+/**
+ * The parameter place each argument binds in a signature of `layout`, with the type it
+ * gives there. A span of unknown length binds every place from its first to the last the
+ * layout counts, and past them, where the rest is open, one `rest` placement for every
+ * later place, or else its first place alone. A place past every place of a layout that
+ * does not repeat is `uncovered`.
+ */
+export function placesIn(spans, layout) {
+    const placed = [];
+    const add = (span, place, rest) => {
+        const uncovered = place >= layout.count && !layout.repeats;
+        const elements = span.open
+            ? span.given.map((given, element) => ({ given, element }))
+            : [{ given: span.given[place - span.first], element: place - span.first }];
+        placed.push(...elements.map((one) => ({ argument: span.argument, place, uncovered, rest, ...one })));
+    };
+    for (const span of spans) {
+        const open = span.open && layout.repeats;
+        const end = !span.open
+            ? span.first + span.given.length
+            : Math.max(layout.count, open ? span.first : span.first + 1);
+        for (let place = span.first; place < end; place += 1) {
+            add(span, place, false);
+        }
+        if (open) {
+            add(span, Math.max(layout.count, span.first), true);
+        }
+    }
+    return placed;
+}
+/**
+ * Whether a span fills the parameter declared at `index`, a rest parameter every place
+ * from it on; with `element`, whether that element of a span that is not open does.
+ */
+export function fills(span, index, rest, element) {
+    if (element !== undefined && !span.open) {
+        const place = span.first + element;
+        return rest ? place >= index : place === index;
+    }
+    const last = span.open ? Number.POSITIVE_INFINITY : span.first + span.given.length - 1;
+    return rest ? last >= index : span.first <= index && index <= last;
+}