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

package/dist/src/liveness/sweep.js

@@ -6,7 +6,7 @@
  * first: a caller, an exemption or a live component file's markup, a suppression mark, and an
  * unanswered checker question; each Contract rule "live only through" one is a view up to it.
  */
-import { exemptionsOf, isUnansweredRecord } from "../exempt.js";
+import { exemptionsOf } from "../exemptions/lifecycle.js";
 import { edgeWithheldBy } from "../tests/file-class.js";
 import { componentsOf } from "./components.js";
 import { namesACaller, OUTSIDE } from "./graph.js";
@@ -367,7 +367,7 @@ function seedsOf(graph, policy) {
         if (record.whileLive !== undefined) {
             gate(record.whileLive, seed);
         }
-        else if (isUnansweredRecord(record)) {
+        else if (record.unanswered === true) {
             unanswered.push(seed);
         }
         else {

package/dist/src/query.js

@@ -7,6 +7,7 @@
  * form where it has one and otherwise as one batch, one round trip per capped run.
  */
 import { isIdentifier } from "@typescript/native/ast";
+import { IndexKind, } from "@typescript/native/sync";
 /**
  * The greatest number of locations one batched request asks about. A batch is
  * answered by an array of its own length, so an uncapped batch over a large file
@@ -118,6 +119,41 @@ function partQuestion(type) {
     }
     return undefined;
 }
+/** How deep {@link mappedParameters} reads, as a recursive mapped type makes a new one at each level. */
+const MAPPED_DEPTH = 4;
+/** The type parameters a mapped type is over, as {@link Queries.mappedParametersOf} names them. */
+function mappedParameters(checker, mapped) {
+    const own = new Set();
+    const found = new Map();
+    const seen = new Set();
+    const visit = (type, depth) => {
+        if (depth > MAPPED_DEPTH || seen.has(type.id)) {
+            return;
+        }
+        seen.add(type.id);
+        if (type.isMappedType()) {
+            own.add(type.getTypeParameter().id);
+        }
+        if (type.isTypeParameter() && !type.isThisType) {
+            found.set(type.id, type);
+        }
+        const aliased = type
+            .aliasTypeArguments;
+        const inner = [
+            ...(type.isUnionType() || type.isIntersectionType() ? type.getTypes() : []),
+            ...(type.isTypeReference() ? checker.getTypeArguments(type) : []),
+            ...(aliased === undefined || aliased.length === 0 ? [] : type.getAliasTypeArguments()),
+            ...(partQuestion(type)?.() ?? []),
+        ];
+        for (const part of inner) {
+            if (part !== undefined) {
+                visit(part, depth + 1);
+            }
+        }
+    };
+    visit(mapped, 0);
+    return [...found.values()].filter((parameter) => !own.has(parameter.id));
+}
 /**
  * The guarded questions over one project's checker. `configFile` names the project
  * in the log, `batch` sends many questions in one round trip, `log` is the run's,
@@ -244,6 +280,7 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         constraintOf: (type) => type.isTypeParameter()
             ? one("getConstraint", () => typeLocation(type), () => type.getConstraint())
             : undefined,
+        baseConstraintOf: (type) => one("getBaseConstraintOfType", () => typeLocation(type), () => checker.getBaseConstraintOfType(type)),
         indexedAccessOf: (type) => type.isIndexedAccessType()
             ? one("getObjectType", () => typeLocation(type), () => ({ object: type.getObjectType(), index: type.getIndexType() }))
             : undefined,
@@ -272,6 +309,17 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
             ? undefined
             : one("getTarget", () => `signature ${String(signature.id)}`, () => signature.getTarget()),
         typeAtPosition: (signature, index) => one("getTypeParameterAtPosition", () => `signature ${String(signature.id)} position ${String(index)}`, () => signature.getTypeParameterAtPosition(index)),
+        restTypeOf: (signature) => signature.hasRestParameter
+            ? one("getTypeOfSymbol", () => `signature ${String(signature.id)} rest parameter`, () => {
+                const rest = signature.getParameters().at(-1);
+                return rest === undefined ? undefined : checker.getTypeOfSymbol(rest);
+            })
+            : undefined,
+        numberIndexOf: (type) => one("getIndexTypeOfType", () => typeLocation(type), () => checker.getIndexTypeOfType(type, IndexKind.Number)),
+        mappedParametersOf: (type) => type.isMappedType()
+            ? one("getConstraintType", () => typeLocation(type), () => mappedParameters(checker, type))
+            : [],
+        propertyTypeOf: (type, name) => one("getTypeOfPropertyOfType", () => `${typeLocation(type)} property ${name}`, () => checker.getTypeOfPropertyOfType(type, name)),
         signatureOf: (declaration) => one("getSignatureFromDeclaration", () => nodeLocation(declaration), () => checker.getSignatureFromDeclaration(declaration)),
         returnTypeOf: (signature) => one("getReturnTypeOfSignature", () => `signature ${String(signature.id)}`, () => checker.getReturnTypeOfSignature(signature)),
         typeToString: (type) => one("typeToString", () => typeLocation(type), () => checker.typeToString(type)),

package/dist/src/roots/configured-declarations.js

@@ -6,7 +6,7 @@
  */
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { resolvedTargets } from "../calls.js";
+import { resolvedTargets } from "../alias-chain.js";
 import { declaredComponent } from "../inventory.js";
 import { must, Unanswerable } from "../query.js";
 import { nameComponent } from "../ref.js";

package/dist/src/verbs/print-retained.js

@@ -1,11 +1,33 @@
 import { EXIT_CLEAN } from "../contract/contract.generated.js";
 import { productionMode, runSweep } from "../analysis.js";
-import { retainedLines } from "../exempt.js";
 import { partialNotes } from "../partial.js";
+import { positionKey } from "../position.js";
 import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
 import { diagnose } from "../product.js";
+/**
+ * One line per held-back declaration, in site order: its reference and position, then
+ * each record's class, site and detail, all separated by tabs.
+ */
+function retainedLines(symbols, retained) {
+    const held = new Map();
+    for (const record of retained) {
+        held.set(record.id, [...(held.get(record.id) ?? []), record]);
+    }
+    return symbols.flatMap((symbol) => {
+        const records = held.get(symbol.id);
+        if (records === undefined) {
+            return [];
+        }
+        const fields = records.flatMap((record) => [
+            record.class,
+            positionKey(record.site),
+            record.detail,
+        ]);
+        return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
+    });
+}
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
  * built from, one per line, and nothing where no exemption held one back. One fact

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.20",
+  "version": "8.0.0-dev.22",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.20",
+  "version": "8.0.0-dev.22",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -32,7 +32,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "cplieger": {
-    "vitestShards": 2
+    "vitestShards": 3
   },
   "dependencies": {
     "@typescript/native": "npm:typescript@7.1.0-dev.20261103.1"

package/src/alias-chain.ts

@@ -1,7 +1,7 @@
 /**
  * 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 {
@@ -12,10 +12,11 @@ import {
   isImportSpecifier,
   isNamespaceExport,
   isNamespaceImport,
+  type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
 import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
-import { UNANSWERED, type Answer } from "./query.ts";
+import { must, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One declaration a chain reaches, and whether a step along an alias reached it. */
@@ -195,3 +196,38 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
     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<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+): ReadonlyMap<Node, TSSymbol> {
+  const followed = new Map<number, TSSymbol | undefined>();
+  const targets = new Map<Node, TSSymbol>();
+  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: TSSymbol | undefined = 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/src/analysis.ts

@@ -15,7 +15,6 @@ import {
   configuredRef,
   declarationsNamed,
 } from "./roots/configured-declarations.ts";
-import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { carriersOf, NO_CARRIERS, type Carriers } from "./exposure.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
@@ -26,32 +25,19 @@ import type { AppliedConvention } from "./entries/conventions.ts";
 import { readSources, type SourceFacts } from "./entries/sources.ts";
 import { readWorkflows, type Workflows } from "./entries/workflow-steps.ts";
 import { readEdgeSides } from "./edges.ts";
-import { enumGroup } from "./enum-group.ts";
 import { bindingsOf, distinctBindings, type BindingRecord } from "./bindings.ts";
-import { generatedFile, generatedFilesOf, type GeneratedFact } from "./generated-file.ts";
+import { generatedFilesOf, type GeneratedFact } from "./exemptions/generated-file.ts";
 import { inOperandNames } from "./findings/in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
-import {
-  evidenceRecords,
-  heldRecords,
-  disabledClasses,
-  exemptionsOf,
-  isUnansweredRecord,
-  writtenRecords,
-  type Detector,
-  type Detectors,
-} from "./exempt.ts";
-import type { TSExemptionClass } from "./exempt-classes.ts";
+import { DETECTORS, detection } from "./exemptions/detectors.ts";
+import { exemptionsOf, settle, type Detectors, type Exemption } from "./exemptions/lifecycle.ts";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.ts";
 import type { Finding } from "./finding.ts";
 import { findingsPass, recordedFindings, rowKey, type PassResult } from "./findings-pass.ts";
 import type { EmitterInput } from "./findings/emitter.ts";
 import { unmatchedRootFindings, type SelfCheckFacts } from "./findings/self-check.ts";
-import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
 import { implementations, mergeImplementations } from "./findings/implementations.ts";
-import { injectionContainer } from "./injection-container.ts";
-import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { type Inventory, type InventorySymbol } from "./inventory.ts";
 import { inventory } from "./inventory/enumerate.ts";
@@ -69,7 +55,6 @@ import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
 import { skippedUnits, type SkippedUnit } from "./type-errors.ts";
-import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, type Reference } from "./references.ts";
 import {
   rootSet,
@@ -79,7 +64,7 @@ import {
   type HeldScripts,
 } from "./roots/root-set.ts";
 import type { Scope } from "./scope.ts";
-import { decodedMembers, serializationContract, type Decoded } from "./serialization-contract.ts";
+import { decodedMembers, type Decoded } from "./exemptions/serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./tests/outside.ts";
 import type { UnseenLoad } from "./roots/unseen-loads.ts";
 import type { UnresolvedSpecifier } from "./load/specifiers.ts";
@@ -100,9 +85,7 @@ import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } f
 import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
 import { inlineDirectives, inlineSuppressions, type InlineDirective } from "./suppress-inline.ts";
 import { sweep, type Sweep, type SweepPolicy } from "./liveness/sweep.ts";
-import type { Exemption } from "./exempt.ts";
 import type { Mode } from "./tests/file-class.ts";
-import { readTemplates, templateField } from "./template-field.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, manifestAt } from "./fs/manifest.ts";
 import { runDirectories } from "./entries/run-directories.ts";
@@ -444,19 +427,6 @@ interface ComponentWarning {
   readonly reason: string;
 }
 
-/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-export const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
-  ["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],
-]);
-
 /** What the sweep of one run reads of each project, beside what a caller's stage adds. */
 interface SweptProject<Extra> {
   readonly configFile: string;
@@ -599,11 +569,8 @@ function readRun<Extra>(
   ) => Extra,
 ): ReadRun<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),
   );
@@ -616,21 +583,7 @@ function readRun<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()
@@ -724,30 +677,29 @@ function readRun<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,
+      testFiles: new Set([...one.testFiles, ...support]),
     })),
-    [...withOutside.flatMap((one) => one.references), ...read.result.references],
+    {
+      references: [...withOutside.flatMap((one) => one.references), ...read.result.references],
+      written,
+      mode,
+    },
   );
   const answers = withOutside.map((one, index): SweptProject<Extra> => {
     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: 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 }),
@@ -769,7 +721,7 @@ function readRun<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,
@@ -822,39 +774,6 @@ function readRun<Extra>(
   };
 }
 
-/**
- * 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: readonly InventorySymbol[],
-  inTestFiles: readonly Exemption[],
-): readonly Reference[] {
-  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/src/bindings.ts

@@ -29,7 +29,7 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { GENERATORS } from "./contract/contract.generated.ts";
-import type { GeneratedFact } from "./generated-file.ts";
+import type { GeneratedFact } from "./exemptions/generated-file.ts";
 import { componentOf, nameNodeOf } from "./inventory.ts";
 import { nameComponent, spell } from "./ref.ts";
 import { bytewise } from "./text/compare.ts";

package/src/conformance-record.ts

@@ -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: [],
 } as const;

package/src/contract/contract.generated.ts

@@ -4,7 +4,7 @@ export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"] as const;
 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;
 
@@ -313,7 +313,7 @@ export const KIND_ROWS = [
     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.",
+      "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",
@@ -421,7 +421,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" },
@@ -437,7 +437,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" },
@@ -1444,6 +1444,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/src/dependencies.ts

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