@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/type-errors.js

@@ -1,182 +1,37 @@
 /**
- * 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. `projectErrors` decides, before any of these, which
- * errors the compiler places in no file leave the project unloaded.
+ * What a type error in a project's own file does: the function, method or file-level statement
+ * holding it is skipped, which only ever withholds a finding.
  */
-import { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
-import { packageOfSpecifier } from "./dependencies.js";
+import { isClassDeclaration, isFunctionLikeDeclaration, isPropertyAccessExpression, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { relativePath } 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, a doc comment's included. */
-function literalAt(file, offset) {
-    let found;
+/**
+ * The unit a type error at one offset skips: the innermost function holding it, else 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) {
+        return undefined;
+    }
+    let innermost;
     const visit = (node) => {
-        if (offset < node.pos || offset >= node.end) {
+        if (offset < node.getStart() || offset >= node.end) {
             return;
         }
-        if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
-            found = node.text;
-        }
-        // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
-        for (const doc of node.jsDoc ?? []) {
-            visit(doc);
+        if (isFunctionLikeDeclaration(node)) {
+            innermost = node;
         }
         node.forEachChild(visit);
     };
-    file.forEachChild(visit);
-    return found;
-}
-/**
- * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
- * is the specifier, or `undefined` where the key does not match it.
- */
-function mappedBy(key, specifier) {
-    const star = key.indexOf("*");
-    if (star < 0) {
-        return key === specifier ? "" : undefined;
-    }
-    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)
-        ? specifier.slice(prefix.length, specifier.length - suffix.length)
-        : undefined;
-}
-/**
- * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
- */
-function substituted(target, star) {
-    const at = target.indexOf("*");
-    return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
-}
-/**
- * Whether a path names something on disk, as written or with any extension; under
- * `fileOnly`, only a file counts.
- */
-function provided(host, path, fileOnly) {
-    const counts = (at) => fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
-    if (counts(path)) {
-        return true;
-    }
-    const dir = dirnamePath(path);
-    const stem = `${path.slice(dir.length + 1)}.`;
-    try {
-        return host
-            .readDirectory(dir)
-            .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
-    }
-    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;
-                }
-            }
-        }
-        // The target root is not below itself, so the walk stops after reading its manifest.
-        if (relativePath(targetRoot, at) === undefined) {
-            return undefined;
-        }
-    }
-}
-/**
- * Whether a package is installed for an importer in `dir`: in the `node_modules` of
- * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
- */
-function installed(host, dir, name) {
-    for (let at = dir;; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
-            return true;
-        }
-        if (dirnamePath(at) === at) {
-            return false;
-        }
-    }
-}
-/**
- * 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), false)
-            ? undefined
-            : `which names no file of the target: ${fix}`;
-    }
-    if (specifier.startsWith("#")) {
-        return `which the manifest's imports map to no file: ${fix}`;
-    }
-    const mapped = context.paths.entries.flatMap(({ key, targets }) => {
-        const star = mappedBy(key, specifier);
-        return star === undefined
-            ? []
-            : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
-    });
-    const name = packageOfSpecifier(specifier);
-    // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
-    // of an installed package's import is the import's own, a subpath its exports omit:
-    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
-    if (name !== undefined && installed(host, dirnamePath(importer), name)) {
-        return undefined;
-    }
-    if (mapped.length > 0) {
-        return mapped.some((path) => provided(host, path, true))
-            ? undefined
-            : `which the compiler configuration's paths map to no file: ${fix}`;
-    }
-    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;
+    visit(statement);
+    if (innermost !== undefined || !isClassDeclaration(statement)) {
+        return innermost ?? statement;
     }
     return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -185,43 +40,13 @@ 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 = [];
-    for (const { diagnostic, at } of errors) {
-        const file = diagnostic.fileName === undefined ? undefined : 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 };
+/** The skip one type error at `offset` of an own file makes, the root spelled relative to itself. */
+export function skipAt(file, offset, line, text, targetRoot) {
+    const unit = unitAt(file, offset);
+    const path = relativePath(targetRoot, file.fileName) ?? file.fileName;
+    return unit === undefined
+        ? undefined
+        : { record: { path, line, message: messageOf(text, targetRoot) }, file, unit };
 }
 /** The lines each skip withholds, below the target root. */
 export function skippedUnits(skips, targetRoot) {
@@ -286,22 +111,3 @@ export function skippedRoots(project, held, skips) {
     }
     return [...kept];
 }
-/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
-export function pathsOf(engine, configFile) {
-    const base = dirnamePath(configFile);
-    try {
-        const { options } = engine.parseConfigFile(configFile);
-        const { paths } = options;
-        // The parse answers `pathsBasePath`, the directory of the configuration that writes
-        // `paths` (an extended one included), though the client's option type omits it:
-        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
-        const declaredAt = options.pathsBasePath;
-        return {
-            base: typeof declaredAt === "string" ? declaredAt : base,
-            entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
-        };
-    }
-    catch {
-        return { base, entries: [] };
-    }
-}

package/dist/src/type-parameter-reads.js

@@ -0,0 +1,172 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { isAnswered } from "./query.js";
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic) {
+    const own = generic.name;
+    const holder = generic.parent?.name;
+    const name = own ?? holder;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access) {
+    const parent = access.parent;
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === access);
+}
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const reads = [];
+    const calls = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from, generic) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            const inside = generic ||
+                node.typeParameters !== undefined;
+            if (inside &&
+                isPropertyAccessExpression(node) &&
+                isIdentifier(node.name) &&
+                !assignedTo(node)) {
+                reads.push({ file, from: holder, access: node });
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                calls.push(node);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, false);
+        });
+    }
+    if (reads.length === 0) {
+        return [];
+    }
+    // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+    const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+    const byGeneric = new Map();
+    reads.forEach((read, at) => {
+        const type = receivers[at];
+        if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+            return;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declaration = symbol === undefined || !isAnswered(symbol)
+            ? undefined
+            : symbol.declarations
+                .map((handle) => project.declarationAt(handle)?.node)
+                .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+        const generic = declaration?.parent;
+        if (generic !== undefined) {
+            byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+        }
+    });
+    if (byGeneric.size === 0) {
+        return [];
+    }
+    /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+    const passedFor = (parameter, declared, instantiated, depth) => {
+        if (declared.id === parameter.id) {
+            return [instantiated];
+        }
+        if (depth >= MATCH_DEPTH) {
+            return [];
+        }
+        const a = queries.typeArguments(declared);
+        const b = queries.typeArguments(instantiated);
+        if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+            return [];
+        }
+        return a.flatMap((one, at) => {
+            const other = b[at];
+            return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+        });
+    };
+    // Only a call spelling a generic's name is resolved: one request each.
+    const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = call.expression;
+        const written = isIdentifier(callee)
+            ? callee.text
+            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                ? callee.name.text
+                : undefined;
+        if (written === undefined || !spelled.has(written)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+            continue;
+        }
+        const generic = project.declarationAt(resolved.declaration)?.node;
+        const pending = generic === undefined ? undefined : byGeneric.get(generic);
+        const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+        if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+            continue;
+        }
+        const count = (generic?.parameters ?? []).length;
+        for (const { read, parameter } of pending) {
+            const passed = [];
+            for (let at = 0; at < count; at += 1) {
+                const own = queries.parameterType(declared, at);
+                const given = queries.typeAtPosition(resolved, at);
+                if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+                    passed.push(...passedFor(parameter, own, given, 0));
+                }
+            }
+            const name = read.access.name.text;
+            const position = renderPosition(read.file, root, read.access.name.getStart());
+            for (const type of passed) {
+                const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                for (const part of isAnswered(parts) ? parts : []) {
+                    const owner = queries.symbolOfType(part);
+                    if (!isAnswered(owner) ||
+                        owner === undefined ||
+                        (owner.flags & SymbolFlags.Class) !== 0) {
+                        continue;
+                    }
+                    const properties = queries.propertiesOf(part);
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        if (property.name !== name) {
+                            continue;
+                        }
+                        for (const to of chains.declarationsOf(property)) {
+                            found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                                from: read.from,
+                                to,
+                                position,
+                                use: "read",
+                                resolution: "batch",
+                                test: testFiles.has(position.path),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...found.values()];
+}

package/dist/src/unseen-loads.js

@@ -0,0 +1,100 @@
+/**
+ * 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 { isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, 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";
+import { unwrapped } from "./unwrap.js";
+/** 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/unwrap.js

@@ -0,0 +1,23 @@
+import { isAsExpression, isNonNullExpression, isParenthesizedExpression, isSatisfiesExpression, } from "@typescript/native/ast";
+/** The expression inside every pair of parentheses around `node`. */
+export function parenthesesRemoved(node) {
+    let at = node;
+    while (isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/**
+ * The expression inside every wrapper around `node` that changes no value it evaluates to:
+ * parentheses, `as` and `satisfies` assertions and the non-null assertion.
+ */
+export function unwrapped(node) {
+    let at = node;
+    while (isParenthesizedExpression(at) ||
+        isAsExpression(at) ||
+        isSatisfiesExpression(at) ||
+        isNonNullExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}

package/dist/src/usage.js

@@ -0,0 +1,10 @@
+/**
+ * A refusal of the invocation: the fix is to the command line or to a document it
+ * names, so the run ends with the usage code before any analysis.
+ */
+export class UsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UsageError";
+    }
+}