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

package/dist/src/type-errors.js

@@ -1,177 +1,15 @@
 /**
- * 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, isFunctionLikeDeclaration, 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";
-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]);
-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;
-    const visit = (node) => {
-        if (offset < node.pos || 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);
-        }
-        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);
-    // No run requires a nested package that is no workspace member to be installed.
-    if (manifest === undefined ||
-        (dirnamePath(manifest) !== targetRoot && !context.member(manifest))) {
-        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 innermost function holding it, else the
  * class member holding it where a top-level class does, else the top-level statement.
@@ -202,53 +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, where) {
-    let workspace = null;
-    const context = {
-        ...where,
-        member: (manifest) => {
-            if (workspace === null) {
-                workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
-            }
-            return workspace?.memberOf(manifest) !== undefined;
-        },
-    };
-    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) {
@@ -313,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

@@ -5,11 +5,9 @@
  * 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 { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isSourceFile, 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";
+import { isAnswered, UNANSWERED } 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. */
@@ -26,147 +24,188 @@ function assignedTo(access) {
         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;
+/** Whether one node is written inside a declaration that declares type parameters, itself included. */
+function inGeneric(node) {
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (at.typeParameters !== undefined) {
+            return true;
         }
-        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));
+    return false;
+}
+/**
+ * The reads the reads through type-parameter-typed values of a side's files make of the
+ * members of the types its calls pass, each made by the declaration holding the read. A
+ * question the checker leaves unanswered holds every member the read's name spells.
+ */
+export const typeParameterReads = {
+    start() {
+        const reads = [];
+        const calls = [];
+        return {
+            visit(node, { file, from }) {
+                if (isPropertyAccessExpression(node) &&
+                    isIdentifier(node.name) &&
+                    !assignedTo(node) &&
+                    inGeneric(node)) {
+                    reads.push({ file, from, access: node });
                 }
-            }
-            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) {
+                if (isCallExpression(node) || isNewExpression(node)) {
+                    calls.push(node);
+                }
+            },
+            reads({ project, chains }) {
+                const out = [];
+                if (reads.length === 0) {
+                    return out;
+                }
+                const queries = project.queries;
+                const hold = (read) => {
+                    out.push({ kind: "held", from: read.from, names: [read.access.name.text] });
+                };
+                // 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 === UNANSWERED) {
+                        hold(read);
+                        return;
+                    }
+                    if (type?.isTypeParameter() !== true) {
+                        return;
+                    }
+                    const symbol = queries.symbolOfType(type);
+                    if (symbol === UNANSWERED) {
+                        hold(read);
+                        return;
+                    }
+                    const declaration = symbol === undefined
+                        ? 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 out;
+                }
+                /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+                const passedFor = (read, 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)) {
+                        hold(read);
+                        return [];
+                    }
+                    if (a.length !== b.length) {
+                        return [];
+                    }
+                    return a.flatMap((one, at) => {
+                        const other = b[at];
+                        return other === undefined ? [] : passedFor(read, parameter, one, other, depth + 1);
+                    });
+                };
+                // Only a call spelling a generic's name is resolved: one request each.
+                const bySpelling = new Map();
+                for (const [generic, pending] of byGeneric) {
+                    const name = nameOf(generic);
+                    if (name !== undefined) {
+                        bySpelling.set(name, [
+                            ...(bySpelling.get(name) ?? []),
+                            ...pending.map((one) => one.read),
+                        ]);
+                    }
+                }
+                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;
+                    const spelledBy = written === undefined ? undefined : bySpelling.get(written);
+                    if (spelledBy === undefined) {
+                        continue;
+                    }
+                    const resolved = queries.resolvedSignature(call);
+                    if (resolved === UNANSWERED) {
+                        spelledBy.forEach(hold);
                         continue;
                     }
-                    const properties = queries.propertiesOf(part);
-                    for (const property of isAnswered(properties) ? properties : []) {
-                        if (property.name !== name) {
-                            continue;
+                    if (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 (declared === UNANSWERED) {
+                        pending?.forEach((one) => {
+                            hold(one.read);
+                        });
+                        continue;
+                    }
+                    if (pending === undefined || declared === undefined) {
+                        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 === UNANSWERED || given === UNANSWERED) {
+                                hold(read);
+                            }
+                            else if (own !== undefined) {
+                                passed.push(...passedFor(read, parameter, own, given, 0));
+                            }
                         }
-                        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),
-                            });
+                        const name = read.access.name.text;
+                        for (const type of passed) {
+                            const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                            for (const part of isAnswered(parts) ? parts : [type]) {
+                                const owner = queries.symbolOfType(part);
+                                const properties = queries.propertiesOf(part);
+                                if (owner === UNANSWERED || properties === UNANSWERED) {
+                                    hold(read);
+                                    continue;
+                                }
+                                if (owner === undefined || (owner.flags & SymbolFlags.Class) !== 0) {
+                                    continue;
+                                }
+                                for (const property of 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)}`, {
+                                            kind: "named",
+                                            from: read.from,
+                                            to,
+                                            file: read.file,
+                                            at: read.access.name,
+                                            use: "read",
+                                            via: "batch",
+                                        });
+                                    }
+                                }
+                            }
                         }
                     }
                 }
-            }
-        }
-    }
-    return [...found.values()];
-}
+                return [...out, ...found.values()];
+            },
+        };
+    },
+};