@cplieger/deadset-ts 3.4.0 → 3.6.0

package/dist/src/resolve.js

@@ -1,13 +1,19 @@
 import { ConfigError, defaultConfig, } from "./config.js";
-import { FIXED_SEVERITY_CODES } from "./kinds.js";
+import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.js";
 import { checkDocument, malformed, nestFlags, SCHEMA_ROOT, SEVERITY_SECTION, } from "./schema.js";
 /** Names the command-line flags in a refusal, where a document is named by its path. */
 const FLAGS_LABEL = "the command-line flags";
 /** The length of a severity key naming a whole family: the prefix and two digits. */
-const FAMILY_KEY_LENGTH = 4;
+export const FAMILY_KEY_LENGTH = 4;
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
 const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
+const ANALYZER_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/u;
+const PROVIDER_SOURCE = /^(go|npm):[^ \t\r\n]+$/u;
+const PROVIDER_VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/u;
+const PROVIDER_DIGEST = /^sha256:[0-9a-f]{64}$/u;
+/** The members only an acquirable provider entry carries. */
+const ACQUIRABLE_MEMBERS = ["source", "version", "digest"];
 /** The members only a platform build configuration carries. */
 const PLATFORM_MEMBERS = ["os", "arch", "tags"];
 /** The member only a project build configuration carries. */
@@ -223,8 +229,8 @@ function readDelimiters(analysis, label) {
     };
 }
 /**
- * A severity key that names no setting, because the Contract fixes the severity of
- * the kind or kinds it names.
+ * A severity key that names no setting: it names no live kind, or the Contract
+ * fixes the severity of the kind or kinds it names.
  */
 function unimplementedSeverityKey(label, path, reason) {
     return new ConfigError("unimplemented-key", path, `${label}: key ${JSON.stringify(path)} is not implemented: ${reason}`);
@@ -245,16 +251,19 @@ function spellCodes(codes) {
     }
     return `${codes.slice(0, -1).join(", ")} and ${String(codes[codes.length - 1])}`;
 }
+/** Whether one severity key names a live kind: the code itself, or a family holding one. */
+function namesLiveKind(code) {
+    return LIVE_CODES.some((candidate) => code === candidate || (code.length === FAMILY_KEY_LENGTH && candidate.startsWith(code)));
+}
 /**
  * The severity object, one code at a time.
  *
- * A key is one issue-kind code or one two-digit family prefix, and a key naming a
- * kind whose severity the Contract fixes, or a family prefix whose range holds
- * one, is an unimplemented key rather than a setting.
+ * A key is one issue-kind code or one two-digit family prefix. A key naming no
+ * live kind, and a key naming a kind whose severity the Contract fixes or a family
+ * prefix whose range holds one, is an unimplemented key rather than a setting.
  *
- * Whether a key names a kind this analyzer reports is not decided here. This
- * analyzer reports no issue kind, so the question has one answer for every key
- * and asking it would refuse the whole object.
+ * Whether a key names a kind this analyzer reports is not decided here: a live
+ * kind of another language is a setting the analyzer of that language reads.
  */
 function readSeverity(document, label) {
     const object = section(document, SEVERITY_SECTION, SEVERITY_SECTION, label);
@@ -267,6 +276,11 @@ function readSeverity(document, label) {
         if (!SEVERITY_KEY.test(code)) {
             throw unimplementedSeverityKey(label, path, "a severity key is one issue-kind code or one two-digit family prefix");
         }
+        if (!namesLiveKind(code)) {
+            throw unimplementedSeverityKey(label, path, code.length === FAMILY_KEY_LENGTH
+                ? "the family this prefix names holds no live issue kind"
+                : "the code names no live issue kind");
+        }
         const fixed = fixedByContract(code);
         if (fixed.length > 0) {
             throw unimplementedSeverityKey(label, path, `the Contract fixes the severity of ${spellCodes(fixed)}, which this key names`);
@@ -384,6 +398,68 @@ function readLifecycleContracts(ts, label) {
     }
     return value.map((entry, index) => readLifecycleContract(entry, `${path}[${String(index)}]`, label));
 }
+/** One string member a provider entry requires, refused where it fails `pattern`. */
+function readMatching(entry, name, at, label, pattern) {
+    const path = `${at}.${name}`;
+    const value = requireMember(readString(entry, name, path, label), path, label);
+    if (!pattern.test(value)) {
+        throw malformed(label, path, `${JSON.stringify(value)} does not match ${pattern.source}`);
+    }
+    return value;
+}
+/**
+ * One provider entry, read as the one shape its members name: a member only an
+ * acquirable analyzer carries makes it acquirable, and then it carries all three.
+ */
+function readProvider(entry, at, label) {
+    if (!isRecord(entry)) {
+        throw malformed(label, at, "is not an object");
+    }
+    const name = readMatching(entry, "name", at, label, ANALYZER_NAME);
+    const languages = readStrings(entry, "languages", `${at}.languages`, label, 1, LANGUAGES);
+    if (languages === undefined) {
+        throw malformed(label, `${at}.languages`, "is required and names nothing");
+    }
+    const commandPath = `${at}.command`;
+    const command = requireMember(readString(entry, "command", commandPath, label), commandPath, label);
+    if (!ACQUIRABLE_MEMBERS.some((member) => Object.hasOwn(entry, member))) {
+        return { shape: "installed", name, languages, command };
+    }
+    return {
+        shape: "acquirable",
+        name,
+        languages,
+        command,
+        source: readMatching(entry, "source", at, label, PROVIDER_SOURCE),
+        version: readMatching(entry, "version", at, label, PROVIDER_VERSION),
+        digest: readMatching(entry, "digest", at, label, PROVIDER_DIGEST),
+    };
+}
+/**
+ * The provider list. Every file a run writes for an analyzer is keyed by the
+ * entry's name, so a list naming one name twice is refused at the later entry.
+ */
+function readProviders(providers, label) {
+    const path = "providers.analyzers";
+    const value = member(providers, "analyzers");
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw malformed(label, path, "is not an array");
+    }
+    const read = value.map((entry, index) => readProvider(entry, `${path}[${String(index)}]`, label));
+    const first = new Map();
+    read.forEach((entry, index) => {
+        const earlier = first.get(entry.name);
+        if (earlier !== undefined) {
+            throw malformed(label, `${path}[${String(index)}].name`, `${JSON.stringify(entry.name)} is already the name of ${path}[${String(earlier)}], ` +
+                "and every entry's name keys the files a run writes for it");
+        }
+        first.set(entry.name, index);
+    });
+    return read;
+}
 /**
  * Reads one already-parsed configuration document as the settings it supplies,
  * refusing every constraint the closed key list declares that a parse cannot
@@ -400,6 +476,7 @@ function readDoc(value, label) {
     const consumers = section(value, "consumers", "consumers", label);
     const roots = section(value, "roots", "roots", label);
     const reporters = section(value, "reporters", "reporters", label);
+    const providers = section(value, "providers", "providers", label);
     const ts = section(value, "ts", "ts", label);
     section(value, "go", "go", label);
     section(value, "provenance", "provenance", label);
@@ -427,6 +504,7 @@ function readDoc(value, label) {
         cascade: readEnum(reporters, "cascade", "reporters.cascade", label, CASCADES),
         maxFindings: readCount(reporters, "max_findings", "reporters.max_findings", label),
         failOn: readEnum(reporters, "fail_on", "reporters.fail_on", label, SEVERITIES),
+        providers: readProviders(providers, label),
         testFiles: readStrings(ts, "test_files", "ts.test_files", label, 1),
         entryFiles: readStrings(ts, "entry_files", "ts.entry_files", label, 0),
         injectionRegistrations: readDeclarations(ts, "injection_registrations", "ts.injection_registrations", label),
@@ -630,6 +708,9 @@ function settleAll(inputs) {
             maxFindings: at("reporters.max_findings", defaults.reporters.maxFindings, (doc) => doc.maxFindings),
             failOn: at("reporters.fail_on", defaults.reporters.failOn, (doc) => doc.failOn),
         },
+        providers: {
+            analyzers: at("providers.analyzers", defaults.providers.analyzers, (doc) => doc.providers),
+        },
         ts: {
             testFiles: at("ts.test_files", defaults.ts.testFiles, (doc) => doc.testFiles),
             entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),

package/dist/src/run.js

@@ -47,8 +47,14 @@ export const SETTING_OPTIONS = new Map([
 ]);
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS = new Set(["target", "config", "central", "scope"]);
-/** The setting options whose value is a number rather than a string. */
-const NUMBER_OPTIONS = new Set(["max-findings"]);
+/**
+ * The setting options whose value is an integer rather than a string. A value
+ * written other than as digits is passed on as the string it is, so resolution
+ * refuses it by its type rather than reading `1e2` as 100.
+ */
+const INTEGER_OPTIONS = new Set(["max-findings"]);
+/** An integer as an option writes it: an optional minus sign and digits alone. */
+const INTEGER_TEXT = /^-?[0-9]+$/u;
 /**
  * The first option whose name carries a source-edit token, because every verb
  * reports and never edits. The match is on the name alone, so an option whose
@@ -116,7 +122,7 @@ function inputsOf(host, options) {
         if (value === undefined) {
             continue;
         }
-        flat[path] = NUMBER_OPTIONS.has(name) ? Number(value) : value;
+        flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
         flagLabels.set(path, `--${name}`);
     }
     const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);

package/dist/src/schema.js

@@ -1,5 +1,6 @@
 import { ConfigError } from "./config.js";
 const leaf = { kind: "leaf" };
+const integer = { kind: "leaf", integer: true };
 /** A list of declarations, each entry in one of the three shapes the `ts` section states. */
 const declarations = {
     kind: "list",
@@ -44,10 +45,26 @@ export const SCHEMA_ROOT = {
                 formats: leaf,
                 sort: leaf,
                 cascade: leaf,
-                max_findings: leaf,
+                max_findings: integer,
                 fail_on: leaf,
             },
         },
+        providers: {
+            kind: "section",
+            members: {
+                analyzers: {
+                    kind: "list",
+                    members: {
+                        name: leaf,
+                        languages: leaf,
+                        command: leaf,
+                        source: leaf,
+                        version: leaf,
+                        digest: leaf,
+                    },
+                },
+            },
+        },
         go: { kind: "section", members: {} },
         ts: {
             kind: "section",
@@ -244,6 +261,21 @@ function skipScalar(cursor) {
         cursor.at += 1;
     }
 }
+/** A number the document writes as an optional minus sign and digits alone. */
+const INTEGER_TEXT = /^-?[0-9]+$/u;
+/** The start of a JSON number: a minus sign or a digit. */
+const NUMBER_START = /^[-0-9]/u;
+/**
+ * Refuses a number written with a fraction or an exponent where the key list
+ * declares an integer. A parse reads `100.0` and `1e2` as the integer 100, so only
+ * the text can tell them apart. A scalar that is no number is the decoder's to
+ * refuse by its type.
+ */
+function checkInteger(text, at, label) {
+    if (NUMBER_START.test(text) && !INTEGER_TEXT.test(text)) {
+        throw malformed(label, at, `${text} is written with a fraction or an exponent, and an integer is digits alone`);
+    }
+}
 function walkValue(cursor, at, node, label) {
     skipSpace(cursor);
     const ch = cursor.text.charCodeAt(cursor.at);
@@ -261,7 +293,11 @@ function walkValue(cursor, at, node, label) {
         readName(cursor, at, label);
         return;
     }
+    const start = cursor.at;
     skipScalar(cursor);
+    if (node.integer === true) {
+        checkInteger(cursor.text.slice(start, cursor.at), at, label);
+    }
 }
 function walkObject(cursor, at, node, label) {
     const seen = new Set();

package/dist/src/scope.js

@@ -1,4 +1,6 @@
+import { ConfigError } from "./config.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { checkDocument } from "./schema.js";
 /** The roles a scope document declares for a module. */
 export const ROLE_TARGET = "target";
 export const ROLE_CONSUMER = "consumer";
@@ -17,18 +19,37 @@ export class ScopeError extends Error {
         this.name = "ScopeError";
     }
 }
-const DECLARED_KEYS = new Set(["target", "workspace", "consumers"]);
-const MODULE_KEYS = new Set(["id", "role", "path"]);
+const MODULE = {
+    kind: "section",
+    members: { id: { kind: "leaf" }, role: { kind: "leaf" }, path: { kind: "leaf" } },
+};
+/** The closed key list of the scope document, compared as bytes. */
+const SCOPE_ROOT = {
+    kind: "section",
+    members: {
+        target: MODULE,
+        workspace: { kind: "leaf" },
+        consumers: { kind: "list", members: MODULE.members ?? {} },
+    },
+};
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * One string member, or undefined where the document omits it. A member the
+ * document writes is a string holding at least one character, so `null` and `""`
+ * are refused rather than read as absent.
+ */
 function stringMember(parent, name, at) {
     if (!Object.hasOwn(parent, name)) {
-        return "";
+        return undefined;
     }
     const value = parent[name];
     if (typeof value !== "string") {
-        throw new ScopeError(`scope: ${at}.${name} is not a string`);
+        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} is not a string`);
+    }
+    if (value === "") {
+        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} names nothing`);
     }
     return value;
 }
@@ -36,30 +57,46 @@ function readModule(value, at, role, documentDir) {
     if (!isRecord(value)) {
         throw new ScopeError(`scope: ${at} is not an object`);
     }
-    for (const name of Object.keys(value)) {
-        if (!MODULE_KEYS.has(name)) {
-            throw new ScopeError(`scope: ${at}.${name} is not a declared key`);
-        }
-    }
     const declared = stringMember(value, "role", at);
-    if (declared !== "" && declared !== role) {
+    if (declared !== undefined && declared !== role) {
         throw new ScopeError(`scope: ${at}.role is ${JSON.stringify(declared)}, want ${JSON.stringify(role)}`);
     }
     const path = stringMember(value, "path", at);
-    if (path === "") {
+    if (path === undefined) {
         throw new ScopeError(`scope: ${at}.path names nothing`);
     }
     return {
-        id: stringMember(value, "id", at),
+        id: stringMember(value, "id", at) ?? "",
         path: isAbsolutePath(path) ? path : joinPath(documentDir, path),
     };
 }
 /**
- * Decodes the scope document at `file`. Decoding is strict: an undeclared key is an
- * error, and a relative path inside the document resolves against the document's
- * own directory.
+ * Walks the document's text against the closed key list, refusing a key the list
+ * does not declare, compared as bytes, and a key one object writes twice, which a
+ * parse cannot report because it keeps the last value.
+ */
+function checkKeys(text, file) {
+    try {
+        checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            // The configuration's refusal names the nearest configuration key, which a
+            // scope document does not have.
+            throw new ScopeError(error.kind === "unimplemented-key"
+                ? `scope: ${file}: ${error.key} is not a declared key`
+                : error.message);
+        }
+        throw error;
+    }
+}
+/**
+ * Decodes the scope document at `file`. Decoding is strict: an undeclared key, a
+ * key written twice in one object, and a value of a type the document does not
+ * admit, `null` included, are errors, and a relative path inside the document
+ * resolves against the document's own directory.
  *
- * The `workspace` key the format declares is read and carries nothing here: it
+ * The `workspace` key the format declares is checked and carries nothing here: it
  * names the file a Go consumer resolves the target through, and a TypeScript
  * project resolves one through its own compiler configuration.
  */
@@ -85,11 +122,8 @@ export function readScope(host, file) {
     if (!isRecord(value)) {
         throw new ScopeError(`scope: ${file} is not one JSON object`);
     }
-    for (const name of Object.keys(value)) {
-        if (!DECLARED_KEYS.has(name)) {
-            throw new ScopeError(`scope: ${file}: ${name} is not a declared key`);
-        }
-    }
+    checkKeys(text, file);
+    stringMember(value, "workspace", "");
     const documentDir = dirnamePath(absolute);
     if (!Object.hasOwn(value, "target")) {
         throw new ScopeError(`scope: ${file} names no target`);

package/dist/src/serialization-contract.js

@@ -3,10 +3,12 @@
  * `JSON.stringify` or a call `ts.serializers` names, and those and `toJSON` and
  * `toString` where a value is passed to an `unknown` or `any` parameter of a function
  * outside the analysis. A function of the project handing such a parameter of its own
- * to a destination is one, holding back what that destination does, to a fixpoint.
+ * to a destination is one, holding back what that destination does, to a fixpoint. A
+ * function invoked through `Function.prototype.call`, `apply` or `bind` is the callee,
+ * given the arguments those methods pass it.
  */
-import { isArrowFunction, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
@@ -71,6 +73,55 @@ function evaluated(argument) {
     const value = isSpreadElement(argument) ? argument.expression : argument;
     return isParenthesizedExpression(value) ? evaluated(value.expression) : value;
 }
+/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
+const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
+/** The interfaces of the standard library that declare those methods for a function value. */
+const FUNCTION_INTERFACES = new Set([
+    "Function",
+    "CallableFunction",
+    "NewableFunction",
+]);
+function unparenthesized(expression) {
+    return isParenthesizedExpression(expression)
+        ? unparenthesized(expression.expression)
+        : expression;
+}
+/**
+ * The invocation a call writes through a method of `Function.prototype`, read from
+ * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
+ * binds `a`, and `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
+ * that is no array literal is the value of the first parameter, whose elements it
+ * carries. Whether the method is the prototype's is resolution's to say.
+ */
+function throughMethod(call) {
+    const expression = unparenthesized(call.expression);
+    if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
+        const [, ...rest] = call.arguments;
+        let passed = rest;
+        if (expression.name.text === "apply") {
+            const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
+        }
+        return {
+            method: expression.name,
+            invocation: { callee: expression.expression, arguments: passed, indirect: true },
+        };
+    }
+    if (isCallExpression(expression)) {
+        const bound = unparenthesized(expression.expression);
+        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
+            return {
+                method: bound.name,
+                invocation: {
+                    callee: bound.expression,
+                    arguments: [...expression.arguments.slice(1), ...call.arguments],
+                    indirect: true,
+                },
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Every call of the project's own files with the class `this` stands for there, and
  * every identifier-named parameter of every function, method and function-valued
@@ -146,9 +197,9 @@ function erasedParameters(project, parameters) {
     return bySymbol;
 }
 /** Each place a call's argument passes one of the erased parameters it can see. */
-function handedOn(project, sites, erased) {
+function handedOn(project, sites, erased, invocationOf) {
     const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
-    const candidates = sites.flatMap((site) => site.call.arguments.flatMap((argument, index) => valuesPassed(argument)
+    const candidates = sites.flatMap((site) => invocationOf(site.call).arguments.flatMap((argument, index) => valuesPassed(argument)
         .filter((value) => spellings.has(value.name.getText()))
         .map((value) => ({ site, argument: index, value }))));
     const plain = candidates.filter((one) => !one.value.shorthand);
@@ -175,11 +226,20 @@ function destinations(input, chains, walked) {
     const checker = project.checker;
     const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
-    const callees = resolvedTargets(project, walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []));
-    const calleeOf = (call) => {
-        const name = calleeName(call.expression);
-        return name === undefined ? undefined : callees.get(name);
-    };
+    const forms = new Map();
+    for (const site of walked.sites) {
+        const form = throughMethod(site.call);
+        if (form !== undefined) {
+            forms.set(site.call, form);
+        }
+    }
+    const callees = resolvedTargets(project, [
+        ...walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []),
+        ...[...forms.values()].flatMap((form) => {
+            const name = calleeName(form.invocation.callee);
+            return name === undefined ? [form.method] : [form.method, name];
+        }),
+    ]);
     const erased = erasedParameters(project, walked.parameters);
     const byFunction = new Map();
     for (const parameter of erased.values()) {
@@ -188,15 +248,42 @@ function destinations(input, chains, walked) {
     const outside = (target) => target.declarations.length > 0 &&
         target.declarations.every((handle) => !own.has(handle.path) &&
             !input.consumers.some((root) => handle.path === root || handle.path.startsWith(`${root}/`)));
+    const invocation = (call) => {
+        const form = forms.get(call);
+        const method = form === undefined ? undefined : callees.get(form.method);
+        // Only the standard library's function methods pass their arguments on: the
+        // program's own `call` and `Reflect.apply` invoke nothing here.
+        if (form !== undefined &&
+            method !== undefined &&
+            outside(method) &&
+            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            return form.invocation;
+        }
+        return { callee: call.expression, arguments: call.arguments, indirect: false };
+    };
+    const calleeOf = (call) => {
+        const name = calleeName(invocation(call).callee);
+        return name === undefined ? undefined : callees.get(name);
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
         if (indexes === undefined) {
-            const signature = checker.getResolvedSignature(call);
-            indexes = new Set(call.arguments.flatMap((_unused, index) => {
-                const type = signature === undefined ? undefined : checker.getParameterType(signature, index);
-                return type !== undefined && (type.flags & ERASED) !== 0 ? [index] : [];
-            }));
+            const invoked = invocation(call);
+            // Through a method of the prototype the resolved signature is the method's, so
+            // the parameters are read off the callee's own signatures, any one erasing.
+            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const signatures = invoked.indirect
+                ? type === undefined
+                    ? []
+                    : checker.getSignaturesOfType(type, SignatureKind.Call)
+                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
+                const parameter = checker.getParameterType(signature, index);
+                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+            })
+                ? [index]
+                : []));
             erasedArguments.set(call, indexes);
         }
         return indexes.has(argument);
@@ -215,7 +302,10 @@ function destinations(input, chains, walked) {
         const declared = chains.declarationsOf(target);
         if (declared.length === 0) {
             return outside(target) && erasedAt(call, argument)
-                ? { reach: "conversions", callee: call.expression.getText().replace(/\s+/gu, "") }
+                ? {
+                    reach: "conversions",
+                    callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
+                }
                 : undefined;
         }
         for (const fn of declared) {
@@ -227,7 +317,7 @@ function destinations(input, chains, walked) {
         }
         return undefined;
     };
-    const forwarded = handedOn(project, walked.sites, erased);
+    const forwarded = handedOn(project, walked.sites, erased, invocation);
     for (let moved = true; moved;) {
         moved = false;
         for (const one of forwarded) {
@@ -254,13 +344,13 @@ function destinations(input, chains, walked) {
         }
         return declared.some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
     };
-    return { at, mayReceive };
+    return { invocation, at, mayReceive };
 }
 /** Each argument of a call that can receive one whose value carries a class of the target. */
 function flowsOf(project, held, sites, to) {
     const reach = valueReach(project, held);
     const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
-        ? site.call.arguments.flatMap((argument, index) => {
+        ? to.invocation(site.call).arguments.flatMap((argument, index) => {
             const value = evaluated(argument);
             return holdsNoInstance(value) ? [] : [{ site, argument: index, value }];
         })

package/dist/src/stores.js

@@ -0,0 +1,32 @@
+/**
+ * What a run knows about the stores into its declarations and the reads of them, which
+ * a sweep does not keep: a sweep asks whether anything names a declaration, and a store
+ * names it as surely as a read does.
+ */
+import { isGetAccessorDeclaration, isSetAccessorDeclaration, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+/** The class members one project's own files declare by a getter or a setter. */
+export function accessorsOf(project, held) {
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    found.push(id);
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}
+/** The run's stores, from what each configuration contributed, the records and the mode. */
+export function storesOf(per, exempt, mode) {
+    return {
+        references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        accessors: new Set(per.flatMap((one) => one.accessors)),
+        exempt: new Set(exempt.map((record) => record.id)),
+    };
+}

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "3.1.0";
+export const CONTRACT_VERSION = "3.2.0";

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.4.0",
+  "version": "3.6.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",