@cplieger/deadset-ts 4.0.0 → 5.0.0

package/dist/src/type-errors.js

@@ -0,0 +1,252 @@
+/**
+ * What the errors a project's own files carry do to the run. An import of a module the
+ * project expects and nothing provides is a setup failure. Any other error in an own file
+ * is a type error: the function, method or file-level statement holding it is skipped,
+ * which only ever withholds a finding. An error the compiler places in no file is read as
+ * a project that cannot be analyzed.
+ */
+import { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { packageOfSpecifier } from "./dependencies.js";
+import { nodeKey } from "./inventory.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { isAnswered } from "./query.js";
+/** The compiler's codes for an import whose module it cannot find. */
+const MODULE_NOT_FOUND = new Set([2307, 2792]);
+const MANIFEST = "package.json";
+const MANIFEST_SECTIONS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+/** Whether a finding's position falls inside a skipped unit. */
+export function insideSkipped(skipped, position) {
+    return skipped.some((unit) => unit.path === position.path && unit.fromLine <= position.line && position.line <= unit.toLine);
+}
+/** The string literal holding one offset, innermost first. */
+function literalAt(file, offset) {
+    let found;
+    const visit = (node) => {
+        if (offset < node.pos || offset >= node.end) {
+            return;
+        }
+        if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
+            found = node.text;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
+function mappedBy(key, specifier) {
+    const star = key.indexOf("*");
+    if (star < 0) {
+        return key === specifier;
+    }
+    const prefix = key.slice(0, star);
+    const suffix = key.slice(star + 1);
+    return (specifier.length >= prefix.length + suffix.length &&
+        specifier.startsWith(prefix) &&
+        specifier.endsWith(suffix));
+}
+/** Whether a relative import's path names something on disk, as written or with any extension. */
+function provided(host, path) {
+    if (host.kindOf(path) !== "absent") {
+        return true;
+    }
+    const dir = dirnamePath(path);
+    const stem = `${path.slice(dir.length + 1)}.`;
+    try {
+        return host.readDirectory(dir).some((entry) => entry.name.startsWith(stem));
+    }
+    catch {
+        return false;
+    }
+}
+/** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
+function declaringManifest(host, dir, targetRoot, name) {
+    for (let at = dir;; at = dirnamePath(at)) {
+        const path = joinPath(at, MANIFEST);
+        let manifest;
+        try {
+            manifest = JSON.parse(host.readFile(path));
+        }
+        catch {
+            manifest = undefined;
+        }
+        if (typeof manifest === "object" && manifest !== null) {
+            const sections = manifest;
+            for (const section of MANIFEST_SECTIONS) {
+                const declared = sections[section];
+                if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
+                    return path;
+                }
+            }
+        }
+        if (at === targetRoot || relativePath(targetRoot, at) === undefined || dirnamePath(at) === at) {
+            return undefined;
+        }
+    }
+}
+/**
+ * Why one import that the compiler cannot resolve names a module the project expects,
+ * with the fix, or undefined where the module is one the project does not expect.
+ */
+function expectedModule(context, importer, specifier) {
+    const { host, targetRoot } = context;
+    const fix = "run the generator or the build that writes it";
+    if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
+        return provided(host, resolvePath(dirnamePath(importer), specifier))
+            ? undefined
+            : `which names no file of the target: ${fix}`;
+    }
+    if (specifier.startsWith("#")) {
+        return `which the manifest's imports map to no file: ${fix}`;
+    }
+    if (context.paths.some((key) => mappedBy(key, specifier))) {
+        return `which the compiler configuration's paths map to no file: ${fix}`;
+    }
+    const name = packageOfSpecifier(specifier);
+    const manifest = name === undefined
+        ? undefined
+        : declaringManifest(host, dirnamePath(importer), targetRoot, name);
+    if (manifest === undefined) {
+        return undefined;
+    }
+    const where = relativePath(targetRoot, manifest) ?? manifest;
+    return `a dependency ${where} declares that is not installed: run the package manager's install`;
+}
+/**
+ * The unit a type error at one offset skips: the class member holding it where a
+ * top-level class does, else the top-level statement.
+ */
+function unitAt(file, offset) {
+    const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
+    if (statement === undefined || !isClassDeclaration(statement)) {
+        return statement;
+    }
+    return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
+}
+/** The compiler's message on one line, the target root spelled relative to itself. */
+function messageOf(text, targetRoot) {
+    const line = text.split(`${targetRoot}/`).join("").split(/\s+/u).join(" ").trim();
+    return line === "" ? "a type error" : line;
+}
+/**
+ * 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.
+ */
+export function readErrors(project, errors, context) {
+    const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
+    const missing = [];
+    const skips = [];
+    const failing = [];
+    for (const located of errors) {
+        const { diagnostic, at } = located;
+        if (diagnostic.fileName === undefined) {
+            failing.push(located);
+            continue;
+        }
+        const file = files.get(diagnostic.fileName);
+        if (file === undefined || diagnostic.reportsUnnecessary === true) {
+            continue;
+        }
+        const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;
+        const line = at?.line ?? 1;
+        const specifier = MODULE_NOT_FOUND.has(diagnostic.code)
+            ? literalAt(file, diagnostic.pos)
+            : undefined;
+        const expected = specifier === undefined ? undefined : expectedModule(context, file.fileName, specifier);
+        if (specifier !== undefined && expected !== undefined) {
+            missing.push({
+                setupClass: "missing-module",
+                detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(specifier)}, ${expected}`,
+            });
+            continue;
+        }
+        const unit = unitAt(file, diagnostic.pos);
+        if (unit !== undefined) {
+            skips.push({
+                record: { path, line, message: messageOf(diagnostic.text, context.targetRoot) },
+                file,
+                unit,
+            });
+        }
+    }
+    return { missing, skips, failing };
+}
+/** The lines each skip withholds, below the target root. */
+export function skippedUnits(skips, targetRoot) {
+    return skips.map(({ file, unit }) => ({
+        path: relativePath(targetRoot, file.fileName) ?? file.fileName,
+        fromLine: file.getLineAndCharacterOfPosition(unit.getStart()).line + 1,
+        toLine: file.getLineAndCharacterOfPosition(unit.end).line + 1,
+    }));
+}
+/**
+ * The declarations the skips keep live: every one a skipped unit declares, and every
+ * member of the type of each operand on which the unit selects a member the checker
+ * could not resolve, because the selection could have named any of them.
+ */
+export function skippedRoots(project, held, skips) {
+    const kept = new Set();
+    const selections = [];
+    for (const { file, unit } of skips) {
+        const visit = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            if (id !== undefined) {
+                kept.add(id);
+            }
+            if (isPropertyAccessExpression(node)) {
+                selections.push(node);
+            }
+            node.forEachChild(visit);
+        };
+        visit(unit);
+    }
+    if (selections.length === 0) {
+        return [...kept];
+    }
+    const names = project.symbolsAt(selections.map((node) => project.handle(node.name)));
+    // A name the checker did not answer for may have named any member, as an unresolved one may.
+    const operands = selections.flatMap((node, at) => {
+        const name = names[at];
+        return name === undefined || !isAnswered(name) ? [node.expression] : [];
+    });
+    const own = project.ownPaths();
+    const keepMembers = (type) => {
+        const parts = type.isUnionType() ? project.queries.constituents(type) : [type];
+        for (const part of isAnswered(parts) ? parts : []) {
+            const properties = project.queries.propertiesOf(part);
+            for (const property of isAnswered(properties) ? properties : []) {
+                for (const handle of property.declarations) {
+                    const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+                    const id = node === undefined
+                        ? undefined
+                        : held.declarations.get(nodeKey(node.getSourceFile(), node));
+                    if (id !== undefined) {
+                        kept.add(id);
+                    }
+                }
+            }
+        }
+    };
+    for (const type of project.queries.typesAt(operands)) {
+        if (type !== undefined && isAnswered(type)) {
+            keepMembers(type);
+        }
+    }
+    return [...kept];
+}
+/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
+export function pathsOf(engine, configFile) {
+    try {
+        const paths = engine.parseConfigFile(configFile).options.paths;
+        return typeof paths === "object" && paths !== null ? Object.keys(paths) : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/src/type-query-alias.js

@@ -0,0 +1,92 @@
+/**
+ * The ambient globals a declaration file declares as an alias of a module's export:
+ * a variable whose type is `typeof import("<module>")["<name>"]` or
+ * `typeof import("<module>").<name>`. A use of the global is a use of the export,
+ * and the type query that says so is no use of its own.
+ */
+import { isIdentifier, isImportTypeNode, isIndexedAccessTypeNode, isLiteralTypeNode, isModuleBlock, isModuleDeclaration, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+/** Whether one type is `typeof import("<string>")`, with no type argument. */
+function typeOfImport(node) {
+    if (!isImportTypeNode(node) || !node.isTypeOf || node.typeArguments !== undefined) {
+        return false;
+    }
+    const argument = node.argument;
+    return isLiteralTypeNode(argument) && isStringLiteral(argument.literal);
+}
+/** The node naming the export one alias type selects, or undefined where the type is no alias. */
+function exportedBy(type) {
+    if (isIndexedAccessTypeNode(type)) {
+        const index = type.indexType;
+        const object = type.objectType;
+        if (typeOfImport(object) &&
+            isImportTypeNode(object) &&
+            object.qualifier === undefined &&
+            isLiteralTypeNode(index) &&
+            isStringLiteral(index.literal)) {
+            return index.literal;
+        }
+        return undefined;
+    }
+    if (typeOfImport(type) && isImportTypeNode(type) && type.qualifier !== undefined) {
+        return isIdentifier(type.qualifier) ? type.qualifier : undefined;
+    }
+    return undefined;
+}
+/** Whether one module declaration is a `declare global` block. */
+function isGlobalBlock(node) {
+    return (isModuleDeclaration(node) &&
+        node.keyword !== SyntaxKind.NamespaceKeyword &&
+        isIdentifier(node.name) &&
+        node.name.text === "global");
+}
+/** The aliases one list of statements declares as globals. */
+function aliasesIn(statements, containers) {
+    const found = [];
+    for (const statement of statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const type = declaration.type;
+            const exported = type === undefined ? undefined : exportedBy(type);
+            if (type === undefined ||
+                exported === undefined ||
+                !isIdentifier(declaration.name) ||
+                !(isIdentifier(exported) || isStringLiteral(exported))) {
+                continue;
+            }
+            found.push({ declaration, type, exported, name: exported.text, containers });
+        }
+    }
+    return found;
+}
+/**
+ * Every global one file declares as an alias of a module's export: at the top level of
+ * a declaration file that is no module, and in a `declare global` block written at the
+ * top level of a declaration file or of an ambient module it declares.
+ */
+export function typeQueryAliases(file) {
+    if (!file.isDeclarationFile) {
+        return [];
+    }
+    const found = file.externalModuleIndicator === undefined ? aliasesIn(file.statements, []) : [];
+    const blocks = (statements, outer) => {
+        for (const statement of statements) {
+            if (!isModuleDeclaration(statement) || statement.body === undefined) {
+                continue;
+            }
+            const body = statement.body;
+            if (!isModuleBlock(body)) {
+                continue;
+            }
+            if (isGlobalBlock(statement)) {
+                found.push(...aliasesIn(body.statements, [...outer, statement]));
+            }
+            else if (!isIdentifier(statement.name)) {
+                blocks(body.statements, [statement]);
+            }
+        }
+    };
+    blocks(file.statements, []);
+    return found;
+}

package/dist/src/verbs/analyze.js

@@ -1,4 +1,4 @@
-import { runAnalysis, runBaselineWrite } from "../analysis.js";
+import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js";
 import { ConfigError } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
@@ -160,22 +160,30 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let recorded;
     let verdict;
     let partial;
+    let warnings;
+    let unread;
     try {
         const root = runRelative(invoked, targetRoot);
         const mode = { production: true };
         let analysis;
         if (documents.baseline === undefined) {
-            analysis = runAnalysis(openClient(false), host, scoped, config, provenance, mode);
+            analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
             recorded = [];
         }
         else {
             const reason = rowReason(analyzerProvenance(version));
-            const write = runBaselineWrite(openClient(false), host, scoped, config, provenance, mode, reason);
+            const write = runBaselineWrite(openClient(config), host, scoped, config, provenance, mode, reason);
             analysis = write.first;
             recorded = write.rows;
         }
         const { result, run } = analysis;
-        partial = partialNotes({ notBuilt: run.notBuilt, unanswered: run.unanswered });
+        warnings = run.componentWarnings;
+        unread = run.componentsUnread.map(({ configFile, reason }) => `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`);
+        partial = partialNotes({
+            notBuilt: run.notBuilt,
+            unanswered: run.unanswered,
+            targetRoot: resolvePath(invoked, targetRoot),
+        });
         const built = buildReport({
             contractVersion: CONTRACT_VERSION,
             version,
@@ -191,6 +199,9 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             unavailable: [],
             result,
             testFileRules: run.testFileRules,
+            typeErrorSkips: run.typeErrorSkips,
+            unanswered: unansweredCounts(analysis),
+            conventionsApplied: run.conventionsApplied,
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);
@@ -226,6 +237,15 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     for (const note of partial) {
         err.write(`deadset-ts: ${note}\n`);
     }
+    for (const line of unread) {
+        err.write(`deadset-ts: ${line}\n`);
+    }
+    for (const warning of warnings) {
+        err.write(`deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`);
+    }
+    for (const skip of report.type_error_skips) {
+        err.write(`deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`);
+    }
     if (report.totals.pending > 0) {
         err.write(`deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`);
     }

package/dist/src/verbs/explain.js

@@ -4,6 +4,7 @@ import { ConfigError } from "../config.js";
 import { OUTSIDE, swept as judged } from "../graph.js";
 import { referenceKey } from "../matrix.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
@@ -303,13 +304,15 @@ function explanation(analysis, subject, cascade) {
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
     const { config, provenance } = resolve(inputs());
-    const analysis = runAnalysis(openClient(false), host, scope(), config, provenance, {
+    const scoped = scope();
+    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
         production: true,
     });
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
     const notes = partialNotes({
         notBuilt: analysis.run.notBuilt,
         unanswered: analysis.run.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     });
     if (subject === undefined) {
         err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);

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

@@ -1,66 +1,27 @@
-import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "../discover.js";
+import { runProjects } from "../analysis.js";
 import { partialNotes } from "../partial.js";
-import { relativePath, resolvePath } from "../paths.js";
-import { resolveMatrix } from "../resolve.js";
-import { diagnosticsOf, runSession } from "../session.js";
-import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
+import { resolvePath } from "../paths.js";
+import { resolveUnkinded } from "../resolve.js";
+import { EXIT_CLEAN } from "./verb.js";
 /**
- * Writes the name of every project one run analyzes, one per line, having read each
- * project's diagnostics first: the identifier the build matrix declares for it, or,
- * where discovery derived the project, its configuration file's path below the
- * target root. A derived project that does not load is not one the run analyzes, so it
- * is named on the error stream instead, as the analysis drops it.
+ * Writes the name of every project one run analyzes, one per line: the identifier the
+ * build matrix declares for it, or, where discovery derived the project, its
+ * configuration file's path below the target root. The projects are read as the
+ * analysis reads them, so a project the analysis drops is named on the error stream
+ * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
-    const matrix = resolveMatrix(inputs());
+    const config = resolveUnkinded(inputs());
     const scoped = scope();
-    const engine = openClient(false);
-    const discovered = discoverProjects(engine, host, scoped, matrix);
-    const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
-    const root = resolvePath(host.workingDirectory(), scoped.target.path);
-    const notBuilt = [...discovered.notBuilt];
-    const failures = [];
-    const session = runSession(engine, discovered.configFiles, (project) => {
-        const id = ids.get(project.configFile) ?? project.configFile;
-        const errors = projectErrors(diagnosticsOf(project));
-        const [unloaded] = errors.load;
-        if (unloaded !== undefined && isGuess(discovered, project.configFile)) {
-            const error = renderDiagnostic(unloaded, (path) => relativePath(root, path) ?? path);
-            notBuilt.push({ id, configFile: project.configFile, error: targetRelative(error, root) });
-            return undefined;
-        }
-        failures.push(...[...errors.load, ...errors.check].map((one) => renderDiagnostic(one)));
-        return id;
-    }, discovered.derived ? "record" : "refuse");
-    for (const configFile of session.unopened) {
-        if (!isGuess(discovered, configFile)) {
-            throw new DiscoveryError(`${configFile} opened no project`, []);
-        }
-        notBuilt.push({
-            id: ids.get(configFile) ?? configFile,
-            configFile,
-            error: "the compiler opened no project for the configuration",
-        });
-    }
-    if (failures.length > 0) {
-        for (const line of failures) {
-            err.write(`${line}\n`);
-        }
-        err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
-        return EXIT_FAILURE;
-    }
-    const projects = session.projects.filter((id) => id !== undefined);
-    if (projects.length === 0 && notBuilt.length > 0) {
-        for (const note of partialNotes({ notBuilt, unanswered: [] })) {
-            err.write(`deadset-ts: ${note}\n`);
-        }
-        err.write("deadset-ts: no configuration discovery derived could be built\n");
-        return EXIT_FAILURE;
-    }
-    for (const id of projects) {
+    const answer = runProjects(openClient(config), host, scoped, config);
+    for (const id of answer.configurations) {
         out.write(`${id}\n`);
     }
-    for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+    for (const note of partialNotes({
+        notBuilt: answer.notBuilt,
+        unanswered: answer.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return EXIT_CLEAN;

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

@@ -1,6 +1,7 @@
 import { runSweep } from "../analysis.js";
 import { retainedLines } from "../exempt.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN } from "./verb.js";
 /**
@@ -13,14 +14,18 @@ import { EXIT_CLEAN } from "./verb.js";
 export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config } = resolve(inputs());
     const scoped = scope();
-    const swept = runSweep(openClient(false), host, scoped, config, {
+    const swept = runSweep(openClient(config), host, scoped, config, {
         marked: [],
         mode: { production: true },
     });
     for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
         out.write(`${line}\n`);
     }
-    for (const note of partialNotes({ notBuilt: swept.notBuilt, unanswered: swept.unanswered })) {
+    for (const note of partialNotes({
+        notBuilt: swept.notBuilt,
+        unanswered: swept.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return EXIT_CLEAN;

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

@@ -1,5 +1,6 @@
 import { runRoots } from "../analysis.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
 /**
@@ -25,7 +26,7 @@ function rootLine(root, several) {
 export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config, provenance } = resolve(inputs());
     const scoped = scope();
-    const answer = runRoots(openClient(false), host, scoped, config, provenance);
+    const answer = runRoots(openClient(config), host, scoped, config, provenance);
     const several = answer.configurations.length > 1;
     for (const root of answer.roots) {
         out.write(`${rootLine(root, several)}\n`);
@@ -33,7 +34,11 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
     for (const finding of answer.findings) {
         err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
     }
-    for (const note of partialNotes({ notBuilt: answer.notBuilt, unanswered: answer.unanswered })) {
+    for (const note of partialNotes({
+        notBuilt: answer.notBuilt,
+        unanswered: answer.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;