@cplieger/deadset-ts 8.0.0-dev.3 → 8.0.0-dev.4

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261010.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261014.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 

package/dist/src/analysis.js

@@ -20,7 +20,7 @@ import { enumGroup } from "./enum-group.js";
 import { generatedFile, generatedFilesOf } from "./generated-file.js";
 import { inOperandNames } from "./in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
@@ -41,7 +41,7 @@ import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.
 import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere, } from "./roots.js";
-import { serializationContract } from "./serialization-contract.js";
+import { decodedMembers, serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
 import { mergedGlobalInterfaces } from "./augmentations.js";
 import { unseenLoadsOf } from "./unseen-loads.js";
@@ -534,6 +534,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
             }))),
+            decoded: decodedMembers(project, projectRead.held, productionFiles(project, targetRoot, resolved.testFilePaths), consumers),
             extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
         };
     });
@@ -549,11 +550,24 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     // Test-support code is code only test code imports in any configuration of the run: a
     // configuration that holds no test file says nothing about what the tests import.
     const { support, testUsed } = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles), testEvidence(host, targetRoot, withOutside));
-    const settled = settledSatisfaction(withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
+    // A member a decode fills or a copy carries is written: a value decoded and sent again carries it on.
+    const written = new Set([
+        ...countedWrites([...withOutside.flatMap((one) => one.references), ...read.consumers.references], support, mode),
+        ...withOutside.flatMap((one) => [
+            ...one.decoded.filled,
+            ...one.decoded.parsed,
+            ...one.decoded.copied,
+        ]),
+    ]);
+    const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
+    const settled = settledSatisfaction(withOutside.map((one, index) => ({
+        evidence: evidence[index] ?? [],
+        held: one.projectRead.held,
+    })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
         const satisfied = settled[index];
-        const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
+        const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
@@ -591,7 +605,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                     .filter((reference) => reference.resolution === "by-name")
                     .map((reference) => reference.to),
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+                ...one.decoded.unanswered,
             ],
+            filledOutside: one.decoded.filled,
             typeErrorSkips: projectRead.typeErrorSkips,
             unmappedEntries: projectRead.rooted.unmappedEntries,
             skipped: projectRead.skipped,
@@ -681,6 +697,13 @@ function evidenceReferences(symbols, inTestFiles) {
             ];
     });
 }
+/**
+ * The declarations a write the mode counts stores into, a write a test-support file
+ * makes being a test's.
+ */
+function countedWrites(references, support, mode) {
+    return new Set(supportReferences(references, support).flatMap((reference) => reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : []));
+}
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
  * reference counting as a read: what the write-only kind would report but for a record.
@@ -765,6 +788,11 @@ function sweptOf(read, input) {
 export function runSweep(engine, host, scope, config, input, detectors = DETECTORS) {
     return sweptOf(readRun(engine, host, scope, config, input.mode, detectors, () => undefined), input);
 }
+/** The project's own files below the target root that are no test file. */
+function productionFiles(project, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    return [...sourceFilesOf(project, targetRoot).byPath].flatMap(([path, file]) => tests.has(path) ? [] : [file]);
+}
 /** Reads a run's projects with every per-project fact an emitter reads. */
 export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
@@ -782,7 +810,7 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         parts: projectParts(project, read.held, references, targetRoot),
         unseenLoads: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
     }));
-    // Whether a declaration carries the marker decides its code, so one whose marker went
+    // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
     const unread = run.projects.flatMap((one) => one.extra.deprecation.unanswered);
     return unread.length === 0
@@ -865,6 +893,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             },
             encapsulated: readManifest(host, targetRoot).declaresExports,
             edges: readEdgeSides(host, targetRoot),
+            filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
         },
         selfCheck,
         intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),

package/dist/src/augmentations.js

@@ -10,7 +10,7 @@ import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@ty
 import { nodeKey } from "./inventory.js";
 import { referenceKey } from "./matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
-function isGlobalBlock(symbol, held, files) {
+export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
         files.has(symbol.parent) &&
         symbol.ref.endsWith("#global") &&

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:54d3de663b7867df0d50251bf79c3b3d1f023abd178fb477cf0bcd3a01ceb2e5",
+        digest: "sha256:e2a3ba92a5a6fe81174439a944333daf8d17e52fdacb8599fc50e3adb1569773",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -1,10 +1,11 @@
 /**
  * The uses contextual types make of the target's members, which no name node resolves to.
  * An object-literal property writes the member of its name on each constituent of the
- * literal's contextual type that declares one. A value reaching a position typed by another
- * object type reads each of its members that type declares, through array elements and
- * the parameters and results of functions and constructors too; a class instance there is
- * the interface-satisfaction class's evidence instead.
+ * literal's contextual type that declares one, and so does a property of a literal whose
+ * type is inferred, where a value of that type reaches such a position. A value reaching a
+ * position typed by another object type reads each of its members that type declares,
+ * through array elements and the parameters and results of functions and constructors
+ * too; a class instance there is the interface-satisfaction class's evidence instead.
  */
 import { isClassDeclaration, isClassExpression, isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/ast";
 import { SignatureKind } from "@typescript/native/sync";
@@ -164,6 +165,33 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const members = [...membersOf(part).values()];
         return members.length > 0 && members.every((member) => !member.own);
     };
+    const literalTypes = new Map();
+    /**
+     * Whether an object type is an object literal's own, inferred where no contextual type
+     * names it: every member a property an object literal of the target writes.
+     */
+    const literalTyped = (part) => {
+        let known = literalTypes.get(part.id);
+        if (known === undefined) {
+            const members = [...membersOf(part).values()];
+            known =
+                members.length > 0 &&
+                    members.every((member) => member.ids.length === 0 &&
+                        member.declarations.length > 0 &&
+                        member.declarations.every((handle) => literalProperty(handle) !== undefined));
+            literalTypes.set(part.id, known);
+        }
+        return known;
+    };
+    /** The name node of the object literal property one declaration handle names, if it is one. */
+    const literalProperty = (handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node !== undefined &&
+            (isPropertyAssignment(node) || isShorthandPropertyAssignment(node)) &&
+            isObjectLiteralExpression(node.parent)
+            ? node.name
+            : undefined;
+    };
     const elements = new Map();
     /** The element type of an array type, read once per type. */
     const elementOf = (type) => {
@@ -246,10 +274,13 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
         for (const one of sources) {
             if (carries(one)) {
-                into.push({ source: one, targets, outside: false });
+                into.push({ source: one, targets, sourceKind: "members" });
             }
             else if (outside(one)) {
-                into.push({ source: one, targets, outside: true });
+                into.push({ source: one, targets, sourceKind: "outside" });
+            }
+            else if (literalTyped(one)) {
+                into.push({ source: one, targets, sourceKind: "literal" });
             }
             const element = elementOf(one);
             const called = element === undefined ? callsOf(one) : [];
@@ -290,7 +321,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         seen.add(type.id);
         return partsOf(type).some((part) => {
-            if (carries(part) || outside(part)) {
+            if (carries(part) || outside(part) || literalTyped(part)) {
                 return true;
             }
             const element = elementOf(part);
@@ -307,6 +338,8 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
     const reads = [];
+    // A literal property writes a position's members once, however many values carry it there.
+    const carriedWrites = new Set();
     sourced.forEach(({ flow, type }, index) => {
         const position = positions[index];
         if (position === undefined || !isAnswered(position)) {
@@ -315,10 +348,24 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const checked = [];
         compared(type, position, checked, new Set());
         const ids = new Set();
-        for (const { source, targets, outside: held } of checked) {
+        for (const { source, targets, sourceKind } of checked) {
             const tables = targets.map(membersOf);
             const sourceMembers = membersOf(source);
-            if (held) {
+            if (sourceKind === "literal") {
+                for (const [name, member] of sourceMembers) {
+                    const written = [...new Set(tables.flatMap((table) => table.get(name)?.ids ?? []))];
+                    for (const at of written.length === 0 ? [] : member.declarations) {
+                        const node = literalProperty(at);
+                        const key = `${at.path}#${String(at.index)}>${written.join(",")}`;
+                        if (node !== undefined && !carriedWrites.has(key)) {
+                            carriedWrites.add(key);
+                            writes.push({ at: node, from: flow.from, ids: written });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (sourceKind === "outside") {
                 for (const table of tables) {
                     for (const [name, member] of table) {
                         if (sourceMembers.has(name)) {

package/dist/src/dependencies.js

@@ -14,7 +14,7 @@ import { scriptTokens } from "./manifest.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-import { workflowTokens } from "./workflow-steps.js";
+import { workflowCommands, workflowTokens } from "./workflow-steps.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -697,20 +697,27 @@ const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
 /** The commands one script string runs, split at the shell's list and pipeline operators. */
 const COMMAND_SEPARATORS = /&&|\|\||;|\||&/u;
 /**
- * The packages one manifest's scripts preload by a runtime flag's bare module specifier,
- * a flag counting only in a command whose program passes it to the runtime, and for Node
- * only before the script it runs, whose own arguments come after it.
+ * The command strings one manifest runs: each of its `scripts`, and the `exec` command of
+ * nodemon's configuration, in the manifest's `nodemonConfig` or the `nodemon.json` beside
+ * it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
  */
-function scriptPreloadsOf(manifest) {
+function manifestCommands(host, dir, manifest) {
     const scripts = manifest["scripts"];
+    const nodemon = [manifest["nodemonConfig"], readJSON(host, joinPath(dir, "nodemon.json"))?.value];
+    return [
+        ...(isRecord(scripts) ? Object.values(scripts) : []),
+        ...nodemon.map((config) => (isRecord(config) ? config["exec"] : undefined)),
+    ].filter((command) => typeof command === "string");
+}
+/**
+ * The packages `scripts` preload by a runtime flag's bare module specifier, a flag
+ * counting only in a command whose program passes it to the runtime, and for Node only
+ * before the script it runs, whose own arguments come after it.
+ */
+function preloadsOf(scripts) {
     const found = new Set();
-    if (!isRecord(scripts)) {
-        return found;
-    }
-    for (const script of Object.values(scripts)) {
-        if (typeof script !== "string") {
-            continue;
-        }
+    for (const script of scripts) {
         for (const command of script.split(COMMAND_SEPARATORS)) {
             const tokens = scriptTokens(command);
             let at = 0;
@@ -820,6 +827,7 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
     }
     const workflow = new Set(workflowTokens(host, targetRoot));
+    const workflowPreloads = preloadsOf(workflowCommands(host, targetRoot));
     const declared = [];
     const ran = new Set();
     const peers = new Map();
@@ -830,14 +838,14 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             continue;
         }
         const tokens = scriptTokensOf(read.value);
-        const preloads = scriptPreloadsOf(read.value);
+        const preloads = preloadsOf(manifestCommands(host, dir, read.value));
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
             const found = installedOf(host, dir, dependency.name);
             if (found === undefined && uninstalledHere.has(dir)) {
                 continue;
             }
             declared.push(dependency);
-            if (preloads.has(dependency.name)) {
+            if (preloads.has(dependency.name) || workflowPreloads.has(dependency.name)) {
                 ran.add(declarationKey(dependency));
             }
             if (found === undefined) {

package/dist/src/discover.js

@@ -1,6 +1,6 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
 import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
 import { writtenPath } from "./workspace-programs.js";
 /** Directory names discovery does not descend into. */
@@ -224,47 +224,6 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
-/**
- * The code of a configuration whose `extends` chain returns to a configuration it already
- * passed. The parse reports it and returns, and a snapshot opened from it never answers:
- * https://github.com/microsoft/TypeScript/issues/64754
- */
-const CIRCULAR_EXTENDS = 18000;
-/** The configuration files one parsed configuration's own `extends` names by path. */
-function extendedPaths(parsed, configFile) {
-    const { raw } = parsed;
-    const named = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
-    return (Array.isArray(named) ? named : [named])
-        .filter((one) => typeof one === "string")
-        .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
-        .map((one) => resolvePath(dirnamePath(configFile), one));
-}
-/**
- * The `extends` chain from `configFile` to the first configuration it reaches twice, each
- * link by path, or undefined where no chain written by path returns.
- */
-function extendsCycle(engine, configFile, parsed) {
-    const walk = (chain, at) => {
-        for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
-            if (chain.includes(next)) {
-                return [...chain, next];
-            }
-            let read;
-            try {
-                read = engine.parseConfigFile(next);
-            }
-            catch {
-                continue;
-            }
-            const cycle = walk([...chain, next], read);
-            if (cycle !== undefined) {
-                return cycle;
-            }
-        }
-        return undefined;
-    };
-    return walk([configFile], parsed);
-}
 /** The configuration files one parsed configuration's `references` name. */
 function referencesOf(parsed) {
     // The parse answers a directory reference as the directory; the compiler reads a
@@ -272,53 +231,26 @@ function referencesOf(parsed) {
     // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
     return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
 }
-/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
-function circularity(engine, configFile, parsed) {
-    const chain = extendsCycle(engine, configFile, parsed);
-    if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
-        return undefined;
-    }
-    return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
-}
 /**
- * Why a configuration the `references` reach, transitively, cannot be opened, where one's
- * `extends` chain is circular: the compiler opens every referenced project with the one
- * that references it.
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. A snapshot that opens two configurations whose `extends` chains reach one such
+ * cycle panics (`OwnerCache.AddOwner: entry not found`, typescript 7.1.0-dev.20261014.1),
+ * so the analysis refuses one before any snapshot is asked to open it.
  */
-function referencedCircularity(engine, references, visited) {
-    for (const reference of references) {
-        if (visited.has(reference)) {
-            continue;
-        }
-        visited.add(reference);
-        let parsed;
-        try {
-            parsed = engine.parseConfigFile(reference);
-        }
-        catch {
-            continue;
-        }
-        const reason = circularity(engine, reference, parsed) ??
-            referencedCircularity(engine, referencesOf(parsed), visited);
-        if (reason !== undefined) {
-            return reason;
-        }
-    }
-    return undefined;
-}
+const CIRCULAR_EXTENDS = 18000;
 /**
- * The configuration files one configuration's `references` name, or why the compiler
- * cannot read the configuration: it throws, or its `extends` chain or that of a
- * configuration it references is circular, which the analysis refuses before any
- * snapshot is asked to open it.
+ * The configurations one configuration file's `references` name, or why it cannot be read:
+ * the compiler throws, or its parse reports the `extends` chain circular.
  */
 function readConfiguration(engine, configFile) {
     try {
         const parsed = engine.parseConfigFile(configFile);
-        const references = referencesOf(parsed);
-        const reason = circularity(engine, configFile, parsed) ??
-            referencedCircularity(engine, references, new Set([configFile]));
-        return reason === undefined ? { references } : { reason };
+        const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
+        // The compiler leaves the message's `{0}` unfilled:
+        // https://github.com/microsoft/TypeScript/pull/64755
+        return circular === undefined
+            ? { references: referencesOf(parsed) }
+            : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
     }
     catch (error) {
         return { reason: error instanceof Error ? error.message : String(error) };

package/dist/src/exempt.js

@@ -106,11 +106,19 @@ export function evidenceRecords(input, detectors, disabled) {
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
                 ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
+                ...(evidence.whileWritten === undefined ? {} : { whileWritten: evidence.whileWritten }),
             });
         }
     }
     return found;
 }
+/**
+ * The records that hold given the declarations a write the mode counts stores into: one
+ * that holds only while written holds where its declaration is among them.
+ */
+export function writtenRecords(records, written) {
+    return records.flatMap(({ whileWritten, ...record }) => whileWritten === undefined || written.has(record.id) ? [record] : []);
+}
 /** The records that hold under one mode, beside the evidence a production mode found in a test file. */
 export function heldRecords(records, holding) {
     const found = [];

package/dist/src/findings/completion.js

@@ -87,10 +87,12 @@ function testedByIn(input) {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name is `possible`.
+ * consumer set. A member an `in` expression tests by name, and one a function outside the
+ * analysis fills, is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
+    const filled = input.boundary.filledOutside ?? new Set();
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -99,7 +101,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (tested.has(id)) {
+        if (tested.has(id) || filled.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";

package/dist/src/kinds.js

@@ -153,7 +153,7 @@ const ROWS = [
         code: "DS1301",
         name: "write-only-symbol",
         languages: ["go", "ts"],
-        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. In Go a read counts only from a declaration that is live under the finding's liveness relation, which is reference counting: a read from a declaration nothing references, whose own finding has the reachability class `certain`, is no read, so a declaration that only such declarations read is reported where a declaration something references writes it. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In Go, a conversion the compiler accepts between two struct types, or between two pointer types that are not named types and whose base types are struct types, reads every field of the two struct types where their struct type literals are distinct, recorded at the conversion, because the conversion is legal only while their fields are identical, ignoring tags, and so no field of either can be deleted alone. It reads in the same way every field of each pair of distinct struct type literals the identity of the two types compares in turn: through each field's type, and from there through the element, key, base, parameter and result types of the type literals it reaches, through the method signatures of an interface type literal, and through the type arguments of an instantiated generic type. A field reached there has no reference of its own, as grammar/symbol-ref.md states, so it is never a subject and those reads hold no finding back. It stops at a defined type, whose fields the conversion does not read, because a defined type is identical to itself whatever fields it declares. A pair whose two sides are one struct type literal, the two struct types themselves included, as where one type is declared from the other or the conversion is to the operand's own type, reads nothing, because a field deleted from that literal leaves both sides identical. Where the operand's type or the conversion's type is a type parameter, the struct type its constraint's core type is takes that side's place, and a type parameter operand reads in the same way the fields of each struct type argument an instantiation the program holds gives it, an instantiation made through another generic declaration's own type parameters included. A conversion to any other type, an interface type among them, reads no field under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. A TypeScript parameter property, a constructor parameter that carries a modifier, declares a member of its class that the constructor writes with its argument, so the member is judged under this rule, and under every rule that reads a class member, as a member the class body declares is. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. An object literal handed to a callee the target does not implement has its members read, as grammar/analysis.md states. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. In Go a read counts only from a declaration that is live under the finding's liveness relation, which is reference counting: a read from a declaration nothing references, whose own finding has the reachability class `certain`, is no read, so a declaration that only such declarations read is reported where a declaration something references writes it. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In Go, a conversion the compiler accepts between two struct types, or between two pointer types that are not named types and whose base types are struct types, reads every field of the two struct types where their struct type literals are distinct, recorded at the conversion, because the conversion is legal only while their fields are identical, ignoring tags, and so no field of either can be deleted alone. It reads in the same way every field of each pair of distinct struct type literals the identity of the two types compares in turn: through each field's type, and from there through the element, key, base, parameter and result types of the type literals it reaches, through the method signatures of an interface type literal, and through the type arguments of an instantiated generic type. A field reached there has no reference of its own, as grammar/symbol-ref.md states, so it is never a subject and those reads hold no finding back. It stops at a defined type, whose fields the conversion does not read, because a defined type is identical to itself whatever fields it declares. A pair whose two sides are one struct type literal, the two struct types themselves included, as where one type is declared from the other or the conversion is to the operand's own type, reads nothing, because a field deleted from that literal leaves both sides identical. Where the operand's type or the conversion's type is a type parameter, the struct type its constraint's core type is takes that side's place, and a type parameter operand reads in the same way the fields of each struct type argument an instantiation the program holds gives it, an instantiation made through another generic declaration's own type parameters included. A conversion to any other type, an interface type among them, reads no field under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. A TypeScript parameter property, a constructor parameter that carries a modifier, declares a member of its class that the constructor writes with its argument, so the member is judged under this rule, and under every rule that reads a class member, as a member the class body declares is. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A literal whose type the compiler infers, as one a callback returns to a generic call, writes in the same way the member of each property's name that each object type a value of the literal's type reaches declares, through array elements, type arguments and the parameters and results of functions, so `ids.map((id) => ({ id }))` returned as `Row[]` writes `Row.id`. An object literal handed to a callee the target does not implement has its members read, as grammar/analysis.md states. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",

package/dist/src/query.js

@@ -220,6 +220,7 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
         signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
         resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),
+        resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) => each("getResolvedSignature", nodes, cap, nodeLocation, (node) => checker.getResolvedSignature.gen(node), (node) => checker.getResolvedSignature(node)),
         parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
         genericOf: (signature) => signature.target === undefined
             ? undefined

package/dist/src/reporters/annotations.js

@@ -1,4 +1,3 @@
-import { fails } from "../config.js";
 import { coalesced } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 /** The escapes a workflow command's message needs, so a line break does not end the command. */
@@ -19,6 +18,12 @@ function escapeProperty(value) {
 function kindName(code) {
     return KINDS.get(code)?.name ?? code;
 }
+/** The command each finding severity is annotated with, whatever the failing severity. */
+const LEVELS = {
+    deny: "error",
+    warn: "warning",
+    allow: "notice",
+};
 function command(level, at, endLine, title, message) {
     return `::${level} file=${escapeProperty(at.path)},line=${String(at.line)},col=${String(at.column)},endLine=${String(endLine)},title=${escapeProperty(title)}::${escapeData(message)}`;
 }
@@ -26,16 +31,15 @@ function command(level, at, endLine, title, message) {
 const SKIP_TITLE = "type error skipped";
 const SKIP_MESSAGE = "the analysis did not evaluate the function or statement holding this type error: ";
 /**
- * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind, then one warning per
- * type-error skip naming its file and line. A finding at or above the failing severity is
- * an error and one below it a warning; a stale suppression is an error, because its kind
- * is fixed on at the failing severity.
+ * The annotations `contract/grammar/annotations.md` states: one per finding, at the
+ * command its severity names, and one error per stale suppression, each naming its file,
+ * line, column and last line and titled by its code and kind; then one warning per
+ * type-error skip naming its file and line, and one per note naming its directory.
  */
-export function annotations(report, options) {
+export function annotations(report) {
     return coalesced((function* lines() {
         for (const found of report.findings) {
-            yield `${command(fails(found.severity, options.failOn) ? "error" : "warning", found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message)}\n`;
+            yield `${command(LEVELS[found.severity], found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message)}\n`;
         }
         for (const stale of report.stale_suppressions) {
             yield `${command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message)}\n`;
@@ -43,5 +47,8 @@ export function annotations(report, options) {
         for (const skip of report.type_error_skips) {
             yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
         }
+        for (const note of report.notes) {
+            yield `::warning file=${escapeProperty(note.path)},title=${escapeProperty(note.kind)}::${escapeData(note.message)}\n`;
+        }
     })());
 }