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

package/dist/src/run.js

@@ -1,6 +1,5 @@
 import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 import { DiscoveryError, renderDiagnostic } from "./discover.js";
-import { EMITTERS } from "./findings/emitters.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
 import { SetupError, setupLine } from "./setup-failure.js";
@@ -201,7 +200,6 @@ function invoke(verb, own, args, streams, openClient) {
                 });
                 return opened;
             },
-            emitters: EMITTERS,
         });
     }
     catch (error) {

package/dist/src/schema.js

@@ -216,7 +216,7 @@ export function malformed(label, path, detail) {
  * A refusal of a key the closed key list does not declare, naming the nearest key
  * it does.
  */
-export function unimplementedKey(label, path) {
+function unimplementedKey(label, path) {
     const nearest = nearestKey(path);
     let hint = "";
     if (nearest === path) {

package/dist/src/scope.js

@@ -2,8 +2,8 @@ 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";
+const ROLE_TARGET = "target";
+const ROLE_CONSUMER = "consumer";
 /**
  * A scope document above this length is refused rather than decoded. It names one
  * target and its consumers, so a larger file is not one.

package/dist/src/session.js

@@ -129,7 +129,12 @@ function viewOf(project, configFile, engine, log) {
             if ((symbol.flags & SymbolFlags.Alias) === 0) {
                 return undefined;
             }
-            const held = queries.immediateAliased(symbol);
+            // An alias the checker synthesizes declares nothing, the default a module that assigns
+            // its export gets under esModuleInterop, and the immediate step fails on it while the
+            // whole resolution answers.
+            const held = symbol.declarations.length === 0
+                ? queries.aliased(symbol)
+                : queries.immediateAliased(symbol);
             // An alias that resolves to nothing answers with the checker's own unknown
             // symbol, which declares nothing; a symbol that is no alias answers with
             // nothing at all.
@@ -185,7 +190,6 @@ export function ownedAs(project, own) {
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
-        configFile: project.configFile,
         syntactic: project.program.getSyntacticDiagnostics(),
         semantic: project.program.getSemanticDiagnostics(),
         configParsing: project.program.getConfigFileParsingDiagnostics(),

package/dist/src/source-files.js

@@ -48,6 +48,7 @@ export function sourceFilesOf(project, targetRoot) {
     return {
         byPath,
         byName,
+        outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
         named: (path) => {
             if (!path.includes(SUBPATH_WILDCARD)) {
                 for (const candidate of candidates(path)) {

package/dist/src/suppress-inline.js

@@ -95,7 +95,7 @@ export function tokenStart(text, from) {
  * syntax tree holds are skipped, so a `//` inside a string, a template or a regular
  * expression starts nothing.
  */
-export function lineComments(file) {
+function lineComments(file) {
     const text = file.text;
     const spans = [];
     const visit = (node) => {

package/dist/src/suppress.js

@@ -14,8 +14,6 @@ export const SUPPRESSION_WITHOUT_REASON = "DS1701";
 export const UNSCOPED_ENTRY = "DS1702";
 /** The code a suppression that withholds nothing is reported under. */
 export const STALE_SUPPRESSION = "DS1703";
-/** A target that carries no suppression. */
-export const NO_SUPPRESSIONS = { records: [], refusals: [] };
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
@@ -71,22 +69,27 @@ export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
 /**
- * The subject kinds that are a row of a document rather than a declaration of the program.
- * A record binds to a declaration, so nothing withholds a finding about one.
+ * The subject kinds that are a row of a document rather than a declaration of the program,
+ * each with the codes that report one. A record binds to a declaration, so nothing
+ * withholds a finding about one.
  */
-const ROW_SUBJECTS = new Set([
-    "file",
-    "dependency",
-    "module-directive",
-    "root",
-    "configured-declaration",
-    "suppression",
-    "edge",
+const ROW_SUBJECTS = new Map([
+    ["file", ["DS1501", "DS1502"]],
+    ["dependency", ["DS1601"]],
+    ["module-directive", ["DS1605"]],
+    ["root", ["DS1704"]],
+    ["configured-declaration", ["DS1706"]],
+    ["suppression", ["DS1701", "DS1702", "DS1703"]],
+    ["edge", ["DS1705"]],
 ]);
 /** Whether a finding's subject is a row of a document, which no record can withhold. */
 export function isRowSubject(kind) {
     return ROW_SUBJECTS.has(kind);
 }
+/** Whether a code reports a row of a document, so no record naming it can match. */
+export function isRowCode(code) {
+    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+}
 /**
  * The subject kinds that are a part of a declaration rather than a declaration: a part
  * has no reference of its own, so a finding about one names the declaration that holds
@@ -143,15 +146,12 @@ export function pairs(record, finding) {
 export function ledgerOf(records, would, dials) {
     const taken = new Set();
     const verdicts = [];
-    const claims = [];
     for (const record of records) {
         if (record.bound !== "" && dials.withholdsCode(record.code, record.bound)) {
             verdicts.push("dormant");
-            claims.push(undefined);
             continue;
         }
         const claimed = would.find((finding) => !taken.has(claimKey(finding)) && pairs(record, finding));
-        claims.push(claimed);
         if (claimed === undefined) {
             verdicts.push("stale");
             continue;
@@ -161,7 +161,6 @@ export function ledgerOf(records, would, dials) {
     }
     return {
         verdicts,
-        claims,
         withheld: (finding) => taken.has(claimKey(finding)) && !ROW_SUBJECTS.has(finding.symbol.kind),
     };
 }

package/dist/src/sweep.js

@@ -163,30 +163,42 @@ function reachable(graph, held, mode) {
 /**
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never
- * admitted, and neither is a marked or exempt test.
+ * reference the test makes, which a production sweep does not count. A test-support
+ * declaration that a test referencing a live target also references is a live target of
+ * every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(graph, dead, held) {
-    const admitted = graph.symbols.map(() => false);
-    graph.symbols.forEach((_symbol, at) => {
-        const testCode = graph.test[at] === true || graph.support[at] === true;
-        if (!testCode || graph.subject[at] !== true || held[at] === true) {
-            return;
-        }
+    const testCode = (at) => graph.test[at] === true || graph.support[at] === true;
+    const judged = graph.symbols.map((_symbol, at) => {
         let targets = 0;
         let live = 0;
-        for (const edge of graph.out[at] ?? []) {
-            const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
-            if (target || graph.subject[edge.to] !== true) {
-                continue;
+        if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
+            for (const edge of graph.out[at] ?? []) {
+                if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+                    continue;
+                }
+                targets += 1;
+                if (dead[edge.to] !== true) {
+                    live += 1;
+                }
             }
-            targets += 1;
-            if (dead[edge.to] !== true) {
-                live += 1;
+        }
+        return { targets, live };
+    });
+    const shared = new Set();
+    judged.forEach(({ live }, at) => {
+        if (live > 0) {
+            for (const edge of graph.out[at] ?? []) {
+                if (graph.support[edge.to] === true) {
+                    shared.add(edge.to);
+                }
             }
         }
-        if (targets > 0 && live === 0) {
+    });
+    const admitted = graph.symbols.map(() => false);
+    judged.forEach(({ targets, live }, at) => {
+        const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
+        if (targets > 0 && live === 0 && !sharing) {
             dead[at] = true;
             admitted[at] = true;
         }

package/dist/src/symbol-keys.js

@@ -0,0 +1,114 @@
+/**
+ * The members a unique symbol keys, used through element accesses. `value[key]`, where
+ * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
+ * whose computed name is that same constant, and a store through the access writes it.
+ * No name node resolves to such a member: the key's name resolves to the constant.
+ */
+import { isComputedPropertyName, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isAnswered } from "./query.js";
+/** The identifier an element access's argument names its key by, where it is a name. */
+export function keyNameOf(argument) {
+    let at = argument;
+    while (isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    if (isIdentifier(at)) {
+        return at;
+    }
+    return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+/**
+ * The last identifier of each computed member name the inventory holds, `mark` for
+ * `[mark]` and `iterator` for `[Symbol.iterator]`: an access whose key is spelled by no
+ * such identifier selects no member a unique symbol keys, and is not asked about.
+ */
+export function computedKeyNames(symbols) {
+    const names = new Set();
+    for (const symbol of symbols) {
+        const key = /\[([^\]]+)\]$/u.exec(symbol.name)?.[1];
+        const last = key?.split(".").pop()?.trim();
+        if (last !== undefined && /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(last)) {
+            names.add(last);
+        }
+    }
+    return names;
+}
+/** Whether a computed name's expression is literal text, which names a member by its text. */
+function isLiteralKey(expression) {
+    return (isStringLiteral(expression) ||
+        isNumericLiteral(expression) ||
+        isNoSubstitutionTemplateLiteral(expression));
+}
+/**
+ * The members each keyed access selects. The receivers' types are asked in one batch,
+ * each object type's properties once, and the key of every property declared under a
+ * computed name in one batch more; a property is selected where its key and the
+ * access's key are one symbol.
+ */
+export function keyedUses(project, chains, resolved, properties, cap) {
+    if (resolved.length === 0) {
+        return [];
+    }
+    const queries = project.queries;
+    const ownPaths = project.ownPaths();
+    const types = queries.typesAt(resolved.map((one) => one.access.access.expression), cap);
+    const parts = new Map();
+    const partsOf = (type) => {
+        const known = parts.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            const constituents = queries.constituents(type);
+            found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+        }
+        else if (type.isObjectType()) {
+            found = [type];
+        }
+        parts.set(type.id, found);
+        return found;
+    };
+    /** Each receiver's properties declared in the target under a computed name, with that name's expression. */
+    const candidates = new Map();
+    const keyNodes = [];
+    const candidatesOf = (type) => {
+        const known = candidates.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = [];
+        const read = properties.of(type);
+        for (const property of isAnswered(read.properties) ? read.properties : []) {
+            const handle = property.declarations.find((one) => ownPaths.has(one.path));
+            const node = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+            const name = node?.name;
+            if (name !== undefined && isComputedPropertyName(name) && !isLiteralKey(name.expression)) {
+                found.push({ property, key: name.expression });
+                keyNodes.push(name.expression);
+            }
+        }
+        candidates.set(type.id, found);
+        return found;
+    };
+    const perAccess = resolved.map((_one, index) => {
+        const type = types[index];
+        return type === undefined || !isAnswered(type) ? [] : partsOf(type).flatMap(candidatesOf);
+    });
+    const keyOf = new Map();
+    const asked = [...new Set(keyNodes)];
+    (asked.length === 0
+        ? []
+        : project.symbolsAt(asked.map((node) => project.handle(node)), cap)).forEach((symbol, index) => {
+        const node = asked[index];
+        if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+            keyOf.set(node, symbol.id);
+        }
+    });
+    return resolved.flatMap((one, index) => {
+        const ids = (perAccess[index] ?? [])
+            .filter((candidate) => keyOf.get(candidate.key) === one.symbol.id)
+            .flatMap((candidate) => chains.declarationsOf(candidate.property));
+        return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
+    });
+}

package/dist/src/test-joins.js

@@ -0,0 +1,101 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+import { sourcePaths } from "./file-facts.js";
+import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { writtenPath } from "./workspace-programs.js";
+const PREFERRED = "/tsconfig.json";
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a, b) {
+    const first = a.endsWith(PREFERRED) ? 0 : 1;
+    const second = b.endsWith(PREFERRED) ? 0 : 1;
+    return first - second || (a < b ? -1 : a > b ? 1 : 0);
+}
+/**
+ * Per configuration of `configFiles`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them. A configuration the compiler cannot read lists nothing and is joined
+ * by nothing.
+ */
+export function joinedTestFiles(engine, host, root, configFiles, patterns) {
+    const listed = new Set();
+    const byDir = new Map();
+    for (const configFile of configFiles) {
+        let fileNames;
+        try {
+            fileNames = engine.parseConfigFile(configFile).fileNames;
+        }
+        catch {
+            continue;
+        }
+        fileNames.forEach((name) => listed.add(name));
+        const dir = dirnamePath(configFile);
+        byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+    }
+    const joins = new Map();
+    for (const path of sourcePaths(host, root)) {
+        const file = joinPath(root, path);
+        if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+            continue;
+        }
+        for (let dir = dirnamePath(file);; dir = dirnamePath(dir)) {
+            const [nearest] = byDir.get(dir) ?? [];
+            if (nearest !== undefined) {
+                joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+                break;
+            }
+            if (host.kindOf(joinPath(dir, "package.json")) === "file" ||
+                dir === root ||
+                relativePath(root, dir) === undefined) {
+                break;
+            }
+        }
+    }
+    return joins;
+}
+/**
+ * How the snapshot reads each configuration a test file joins: the program `programs`
+ * describes with the files added to its root files, or a configuration only the snapshot
+ * holds that extends the one `programs` writes, or the configuration itself, and lists
+ * every file the configuration lists and the joined ones.
+ */
+export function withJoinedTests(engine, host, programs, joins) {
+    const found = new Map(programs);
+    for (const [configFile, files] of joins) {
+        const program = programs.get(configFile);
+        if (program?.kind === "program") {
+            found.set(configFile, {
+                kind: "program",
+                params: {
+                    ...program.params,
+                    rootFiles: [...(program.params.rootFiles ?? []), ...files],
+                },
+            });
+            continue;
+        }
+        let listed;
+        try {
+            listed =
+                program?.kind === "configuration"
+                    ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
+                    : engine.parseConfigFile(configFile).fileNames;
+        }
+        catch {
+            continue;
+        }
+        const value = program?.kind === "configuration"
+            ? { ...JSON.parse(program.text), files: [...listed, ...files] }
+            : { extends: configFile, files: [...listed, ...files] };
+        found.set(configFile, {
+            kind: "configuration",
+            file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
+            text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
+        });
+    }
+    return found;
+}

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 = "6.1.0";
+export const CONTRACT_VERSION = "7.0.0";

package/dist/src/workflow-steps.js

@@ -50,12 +50,8 @@ export function runCommands(text) {
     }
     return found;
 }
-/**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
- */
-export function workflowEntries(host, targetRoot, files) {
+/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
+export function workflowTokens(host, targetRoot) {
     const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
     const found = [];
     for (const path of workflowFiles(host, dir)) {
@@ -67,15 +63,25 @@ export function workflowEntries(host, targetRoot, files) {
             continue;
         }
         for (const command of runCommands(text)) {
-            for (const token of scriptTokens(command)) {
-                if (COMPUTED.test(token)) {
-                    continue;
-                }
-                const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-                if (file !== undefined) {
-                    found.push({ file, source: token });
-                }
-            }
+            found.push(...scriptTokens(command));
+        }
+    }
+    return found;
+}
+/**
+ * The own files the `run:` steps of every workflow file in the target root's
+ * `.github/workflows` name: a token equal to a file's path below the target root, with or
+ * without a leading `./`, whatever directory the step runs in.
+ */
+export function workflowEntries(host, targetRoot, files) {
+    const found = [];
+    for (const token of workflowTokens(host, targetRoot)) {
+        if (COMPUTED.test(token)) {
+            continue;
+        }
+        const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
+        if (file !== undefined) {
+            found.push({ file, source: token });
         }
     }
     return found;

package/dist/src/workspace-programs.js

@@ -48,7 +48,7 @@ function unstatable(reading) {
     return undefined;
 }
 /** The path beside `configFile` its written configuration takes, which no file has. */
-function writtenPath(host, configFile) {
+export function writtenPath(host, configFile) {
     const stem = configFile.replace(/\.json$/u, "");
     for (let counter = 0;; counter += 1) {
         const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
@@ -205,8 +205,6 @@ function scan(engine, program, reading, resolver) {
             reading.unresolved.push({
                 file: usage.file,
                 specifier,
-                member: answer.member,
-                subpath: answer.subpath,
                 reason: answer.reason,
             });
         }
@@ -309,7 +307,6 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
         readings: readings.map((reading) => ({
             configFile: reading.configFile,
             fileNames: reading.parsed.fileNames,
-            entries: reading.entries,
             unresolved: reading.unresolved,
             componentsUnread: unread.get(reading.configFile),
         })),

package/dist/src/workspace-resolution.js

@@ -259,7 +259,6 @@ export function workspaceResolver(host, workspace) {
                 return {
                     kind: "unresolved",
                     member: name,
-                    subpath,
                     reason: `${String(linked.dirs.length)} workspace packages are named ${name} (${linked.dirs.join(", ")}) and nothing links the importer to one of them; install the workspace, or declare the dependency with a range only one of them satisfies`,
                 };
             }
@@ -295,7 +294,6 @@ export function workspaceResolver(host, workspace) {
             return {
                 kind: "unresolved",
                 member: name,
-                subpath,
                 reason: built
                     ? `its manifest names ${named}, output no tsconfig*.json of the package maps back to source, and nothing installed links the importer to it; install the workspace, or point an exports condition the importing configuration's customConditions lists at its source`
                     : member.configurations.length === 0

package/dist/src/workspace.js

@@ -256,7 +256,6 @@ function configurationsOf(host, dir, parse) {
             ? []
             : [
                 {
-                    configFile,
                     fileNames: new Set(parsed.fileNames),
                     layout: layoutOf(configFile, parsed),
                 },
@@ -338,8 +337,6 @@ export function findWorkspace(host, targetRoot, parse) {
         return found;
     };
     return {
-        root: declared.root,
-        declaredIn: declared.file,
         members,
         named,
         memberOf: (path) => {

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.1.1-dev.1",
+  "version": "7.0.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -24,6 +24,7 @@
     "typecheck:tests": "tsc -p tsconfig.test.json",
     "test": "vitest --run",
     "test:starters": "vitest --run --config starters/vitest.config.ts",
+    "test:mutation": "stryker run",
     "lint": "eslint .",
     "lint:prettier": "prettier --check .",
     "lint:fix": "eslint . --fix && prettier --write ."