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

package/dist/src/sweep.js

@@ -84,10 +84,10 @@ export function runnerCalls(symbol) {
  * That run's roots are the graph's own and, of each test file, its top level and every
  * function it exports, which a test runner may call, and every export of a manual mock,
  * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph, held) {
+export function reachedWithTheTests(graph, held, namespaces = true) {
     const tests = graph.symbols.flatMap((symbol, at) => {
         const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
         const called = exported && runnerCalls(symbol);
@@ -97,9 +97,7 @@ export function reachedWithTheTests(graph, held) {
             ? [{ at, kind: "test-runner" }]
             : [];
     });
-    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-        production: false,
-    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
 }
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
@@ -126,7 +124,7 @@ function flagged(graph, ids) {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, held, mode) {
+function reachable(graph, held, mode, namespaces = true) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
@@ -154,7 +152,7 @@ function reachable(graph, held, mode) {
                 if (!holding && mode.production && edge.test) {
                     continue;
                 }
-                enter(edge.to, !edge.evaluation);
+                enter(edge.to, namespaces && !edge.evaluation);
             }
         }
     };
@@ -169,7 +167,7 @@ function reachable(graph, held, mode) {
     }
     // A consumer's reference reaches what it names as one of the target's own does.
     for (const edge of callsOf(graph, mode)) {
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
     }
     walk(false);
     return reached;

package/dist/src/test-globals.js

@@ -0,0 +1,234 @@
+/**
+ * The globals a test runner injects into every file it runs, which no import names: a
+ * Vitest configuration whose `test.globals` is `true` gives each test and each file it
+ * loads `describe`, `it`, `expect` and `vi` (https://vitest.dev/config/globals). A program
+ * analyzed without the runner's declarations of them reads every use as an error, so a
+ * configuration under such a runner is read with them; and a file that calls one is
+ * written for the runner, as one that imports it is.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, joinPath } from "./paths.js";
+import { UNANSWERED } from "./query.js";
+import { writtenPath } from "./workspace-programs.js";
+/** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
+export const GLOBALS_RUNNER = "vitest";
+const GLOBALS_TYPES = "vitest/globals";
+/** The configuration files the runner reads its settings from, by name. */
+const RUNNER_CONFIG = /^(?:vitest|vite)\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+/** The globals `vitest/globals` declares that a test or a helper calls or reads a member of. */
+const GLOBAL_NAMES = new Set([
+    "afterAll",
+    "afterEach",
+    "assert",
+    "assertType",
+    "beforeAll",
+    "beforeEach",
+    "bench",
+    "describe",
+    "expect",
+    "expectTypeOf",
+    "it",
+    "onTestFailed",
+    "onTestFinished",
+    "suite",
+    "test",
+    "vi",
+    "vitest",
+]);
+/** The expression one wrapper that changes no value holds, and a call's first argument. */
+function configObject(node) {
+    let at = node;
+    while (at !== undefined) {
+        if (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+            at = at.expression;
+        }
+        else if (isCallExpression(at)) {
+            at = at.arguments[0];
+        }
+        else {
+            return at;
+        }
+    }
+    return undefined;
+}
+/** The value one object literal writes for one member as `name: value`. */
+function member(object, name) {
+    if (object === undefined || !isObjectLiteralExpression(object)) {
+        return undefined;
+    }
+    for (const property of object.properties) {
+        if (isPropertyAssignment(property) &&
+            isIdentifier(property.name) &&
+            property.name.text === name) {
+            return configObject(property.initializer);
+        }
+    }
+    return undefined;
+}
+/** Whether one runner configuration's default export sets `test.globals` to `true`. */
+function setsGlobals(file) {
+    for (const statement of file.statements) {
+        let exported;
+        if (isExportAssignment(statement)) {
+            exported = statement.expression;
+        }
+        else if (isExpressionStatement(statement) && isBinaryExpression(statement.expression)) {
+            const { left, operatorToken, right } = statement.expression;
+            if (operatorToken.kind === SyntaxKind.EqualsToken &&
+                isPropertyAccessExpression(left) &&
+                isIdentifier(left.expression) &&
+                left.expression.text === "module" &&
+                isIdentifier(left.name) &&
+                left.name.text === "exports") {
+                exported = right;
+            }
+        }
+        const object = exported === undefined ? undefined : configObject(exported);
+        const globals = member(member(object, "test"), "globals");
+        if (globals?.kind === SyntaxKind.TrueKeyword) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Whether the runner's configuration in one manifest's directory injects the globals. */
+function injectsGlobals(host, parse, dir) {
+    let names;
+    try {
+        names = host
+            .readDirectory(dir)
+            .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return false;
+    }
+    return names.some((name) => {
+        const path = joinPath(dir, name);
+        try {
+            return setsGlobals(parse(path, host.readFile(path)));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Whether a file declaring the globals is installed where the configuration resolves packages from. */
+function globalsInstalled(host, configFile) {
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
+            return true;
+        }
+        if (dirnamePath(dir) === dir) {
+            return false;
+        }
+    }
+}
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host, configFile) {
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+            return dir;
+        }
+        if (dirnamePath(dir) === dir) {
+            return undefined;
+        }
+    }
+}
+function typesOf(value) {
+    return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
+}
+/**
+ * How the snapshot reads each configuration of `configFiles` whose nearest manifest's
+ * runner configuration injects the globals and that can resolve their declarations: as
+ * `programs` reads it, else as itself, with the globals' declarations added to its `types`.
+ * A configuration the compiler cannot read is left for its project to refuse.
+ */
+export function withTestGlobals(engine, host, parse, configFiles, programs) {
+    const found = new Map(programs);
+    const injects = new Map();
+    for (const configFile of configFiles) {
+        const dir = manifestDir(host, configFile);
+        if (dir === undefined || !globalsInstalled(host, configFile)) {
+            continue;
+        }
+        if (!injects.has(dir)) {
+            injects.set(dir, injectsGlobals(host, parse, dir));
+        }
+        if (injects.get(dir) !== true) {
+            continue;
+        }
+        let base;
+        try {
+            base = typesOf(engine.parseConfigFile(configFile).options.types) ?? [];
+        }
+        catch {
+            continue;
+        }
+        const held = found.get(configFile);
+        if (held?.kind === "program") {
+            const listed = typesOf(held.params.compilerOptions.types) ?? base;
+            if (!listed.includes(GLOBALS_TYPES)) {
+                found.set(configFile, {
+                    kind: "program",
+                    params: {
+                        ...held.params,
+                        compilerOptions: { ...held.params.compilerOptions, types: [...listed, GLOBALS_TYPES] },
+                    },
+                });
+            }
+            continue;
+        }
+        let written = { extends: configFile };
+        if (held !== undefined) {
+            try {
+                written = JSON.parse(held.text);
+            }
+            catch {
+                continue;
+            }
+        }
+        const options = (written["compilerOptions"] ?? {});
+        const listed = typesOf(options["types"]) ?? base;
+        if (listed.includes(GLOBALS_TYPES)) {
+            continue;
+        }
+        found.set(configFile, {
+            kind: "configuration",
+            file: held?.file ?? writtenPath(host, configFile),
+            text: `${JSON.stringify({ ...written, compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] } }, null, 2)}\n`,
+        });
+    }
+    return found;
+}
+/**
+ * Whether one file names a global the runner injects, which is how a file written for the
+ * runner's globals reads: a call of one of the names or a read of a member of it that
+ * resolves to a declaration outside the project's own files, the runner's declaration
+ * file. A name the file binds, imported, declared or a parameter, resolves to its own.
+ */
+export function namesTestGlobals(project, file) {
+    const named = [];
+    const visit = (node) => {
+        const callee = isCallExpression(node)
+            ? node.expression
+            : isPropertyAccessExpression(node)
+                ? node.expression
+                : undefined;
+        if (callee !== undefined && isIdentifier(callee) && GLOBAL_NAMES.has(callee.text)) {
+            named.push(callee);
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    if (named.length === 0) {
+        return false;
+    }
+    const own = project.ownPaths();
+    return project
+        .symbolsAt(named.map((node) => project.handle(node)))
+        .some((symbol) => symbol === UNANSWERED ||
+        (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path))));
+}

package/dist/src/type-errors.js

@@ -13,6 +13,12 @@ import { isAnswered } from "./query.js";
 import { findWorkspace } from "./workspace.js";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND = new Set([2307, 2792]);
+/**
+ * The compiler's codes for where the configuration places a file, which leave every type
+ * the file's statements carry as it is: an output that would overwrite an input (5055,
+ * 5056), a file outside `rootDir` (6059), one a composite project does not list (6307).
+ */
+const CONFIGURATION_LEVEL = new Set([5055, 5056, 6059, 6307]);
 const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
     "dependencies",
@@ -204,8 +210,8 @@ function messageOf(text, targetRoot) {
 }
 /**
  * Reads the errors one project's own files carry. A diagnostic marking unnecessary code
- * is no error here, and one in a file that is not the project's own is that file's
- * package's to answer for.
+ * or about where the configuration places a file is no error here, and one in a file that
+ * is not the project's own is that file's package's to answer for.
  */
 export function readErrors(project, errors, where) {
     let workspace = null;
@@ -223,7 +229,9 @@ export function readErrors(project, errors, where) {
     const skips = [];
     for (const { diagnostic, at } of errors) {
         const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
-        if (file === undefined || diagnostic.reportsUnnecessary === true) {
+        if (file === undefined ||
+            diagnostic.reportsUnnecessary === true ||
+            CONFIGURATION_LEVEL.has(diagnostic.code)) {
             continue;
         }
         const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;

package/dist/src/unseen-loads.js

@@ -0,0 +1,107 @@
+/**
+ * The loads of a project's production files whose target the analysis cannot resolve: an
+ * `import()` or `require()` call whose path is computed and starts with no relative literal
+ * naming a directory below the calling file's. The files such a load runs are roots the
+ * analysis does not see, so the configuration's roots are never complete.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+import { sourceFilesOf } from "./source-files.js";
+/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
+function unwrapped(node) {
+    let at = node;
+    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+export function leadingLiteral(node) {
+    const at = unwrapped(node);
+    if (isTemplateExpression(at)) {
+        return at.head.text;
+    }
+    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+        const left = unwrapped(at.left);
+        return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+            ? left.text
+            : leadingLiteral(at.left);
+    }
+    return undefined;
+}
+/**
+ * The directory below `dir` a computed load's leading literal names, which the entry
+ * rules root every file of, or none where it names a package, `dir` itself or a
+ * directory holding it, each of which would name files no rule roots.
+ */
+export function computedLoadDirectory(dir, prefix) {
+    if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+        return undefined;
+    }
+    const target = resolvePath(dir, prefix);
+    return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix) {
+    return (prefix !== undefined &&
+        prefix !== "" &&
+        !prefix.startsWith(".") &&
+        !prefix.startsWith("/") &&
+        !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix));
+}
+/**
+ * Every unresolved load the project's production files write, in file then source order.
+ * `testFiles` holds the test files by their path below the target root. A `require` call
+ * loads a module only where the name resolves to no declaration of the project's own
+ * files: one the project declares is its own function.
+ */
+export function unseenLoadsOf(project, configuration, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    const sites = [];
+    for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+        if (tests.has(path) || file.isDeclarationFile) {
+            continue;
+        }
+        const dir = dirnamePath(file.fileName);
+        const visit = (node) => {
+            if (isCallExpression(node)) {
+                const callee = node.expression;
+                const required = isIdentifier(callee) && callee.text === "require";
+                const [first] = node.arguments;
+                const argument = first === undefined ? undefined : unwrapped(first);
+                if ((callee.kind === SyntaxKind.ImportKeyword || required) &&
+                    argument !== undefined &&
+                    !isStringLiteral(argument) &&
+                    !isNoSubstitutionTemplateLiteral(argument)) {
+                    const prefix = leadingLiteral(argument);
+                    const seen = namesPackage(prefix) ||
+                        (prefix !== undefined && computedLoadDirectory(dir, prefix) !== undefined);
+                    if (!seen) {
+                        sites.push({
+                            position: renderPosition(file, targetRoot, node.getStart()),
+                            require: required ? callee : undefined,
+                        });
+                    }
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
+    const own = project.ownPaths();
+    const local = new Set();
+    project.symbolsAt(requires.map((node) => project.handle(node))).forEach((symbol, at) => {
+        const node = requires[at];
+        if (node !== undefined &&
+            symbol !== UNANSWERED &&
+            symbol?.declarations.some((handle) => own.has(handle.path)) === true) {
+            local.add(node);
+        }
+    });
+    return sites
+        .filter((site) => site.require === undefined || !local.has(site.require))
+        .map((site) => ({ configuration, position: site.position }));
+}

package/dist/src/verbs/analyze.js

@@ -3,7 +3,7 @@ import { ConfigError, kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
-import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
 import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
@@ -77,6 +77,24 @@ function unmappedNotes(entries, targetRoot) {
         };
     });
 }
+/**
+ * One note per load of a production file the run cannot resolve, each site once: a file
+ * it loads is a root the run does not see, so `ts.roots_complete` lifts no cap there.
+ */
+function unseenLoadNotes(loads) {
+    return [
+        ...new Map(loads.map((load) => {
+            const { path, line, column } = load.position;
+            const site = `${path}:${String(line)}:${String(column)}`;
+            const note = {
+                kind: "computed-load",
+                path: dirnamePath(path),
+                message: `${site} loads a module by a computed path the analysis cannot resolve, so the configurations compiling it report what no root reaches at probable at most, whatever ts.roots_complete says`,
+            };
+            return [site, note];
+        })).values(),
+    ];
+}
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped, targetRoot) {
     return dropped.map((one) => {
@@ -222,7 +240,11 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             typeErrorSkips: run.typeErrorSkips,
             unanswered: unansweredCounts(analysis),
             conventionsApplied: run.conventionsApplied,
-            notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+            listsComponents: config.reporters.cascade === "full",
+            notes: [
+                ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+                ...unseenLoadNotes(run.unseenLoads),
+            ],
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);
@@ -237,7 +259,6 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     try {
         host.writeDocument(documents.report, json(report));
         const options = {
-            failOn: config.reporters.failOn,
             readSource: (path) => host.readFile(joinPath(targetRoot, path)),
             template,
         };

package/dist/src/workflow-steps.js

@@ -74,24 +74,32 @@ export function runCommands(text, key = RUN_LINE) {
     return found;
 }
 /**
- * Every token the recipe lines of the target root's makefile hold, each with the directory
- * below the root it is read against: a recipe line is one that starts with a tab, joined
- * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
- * own, so a `cd` moves the directory of the later commands of its line alone.
+ * The commands of the recipe lines of the target root's makefile, each line's in order: a
+ * recipe line is one that starts with a tab, joined with the lines a trailing `\`
+ * continues it onto.
  */
-function recipeTokens(host, root) {
+function recipeLines(host, root) {
     const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
     const text = path === undefined ? undefined : readText(host, path);
     if (text === undefined) {
         return [];
     }
+    return text
+        .replace(/\\\r?\n/gu, " ")
+        .split(/\r?\n/u)
+        .filter((line) => line.startsWith("\t"))
+        .map((line) => withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS));
+}
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: make runs each line in a shell of its own, so a `cd`
+ * moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
     const found = [];
-    for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
-        if (!line.startsWith("\t")) {
-            continue;
-        }
+    for (const line of recipeLines(host, root)) {
         let dir = root;
-        for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS)) {
+        for (const command of line) {
             const tokens = scriptTokens(command);
             const [first, target, ...rest] = tokens;
             if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
@@ -131,13 +139,25 @@ function withoutComment(line) {
     return line;
 }
 /**
- * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
  * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
  * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
  * of a lefthook file and the makefile's recipe lines.
  */
+export function workflowCommands(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+}
+/** Every token the commands {@link workflowCommands} reads hold. */
 export function workflowTokens(host, targetRoot) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [
+        ...stepCommands(host, root).flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
+/** The commands of the workflow steps, git hooks and hook managers at one root. */
+function stepCommands(host, root) {
     const commands = [];
     for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
         commands.push(...runCommands(readText(host, path) ?? ""));
@@ -150,10 +170,7 @@ export function workflowTokens(host, targetRoot) {
     for (const [name, key] of HOOK_MANAGERS) {
         commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
     }
-    return [
-        ...commands.flatMap((command) => scriptTokens(command)),
-        ...recipeTokens(host, root).map(({ token }) => token),
-    ];
+    return commands;
 }
 /**
  * The own files the target root's workflow steps and git hooks name, as