@cplieger/deadset-ts 5.1.0 → 5.2.0

package/dist/src/outside-tests.js

@@ -0,0 +1,139 @@
+/**
+ * The test files no compiler configuration of a run holds. The runner executes them all
+ * the same, so each module one names is a test reference: the own file a relative
+ * specifier names, and the declarations that file exports under the names read from it.
+ * Such a file is read without a program, so what its body references beyond the modules
+ * it names is not known.
+ */
+import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
+import { emittedFrom } from "./emit-map.js";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
+import { renderPosition } from "./position.js";
+import { nameComponent } from "./ref.js";
+/** The paths below the target root one relative specifier may name, written path first. */
+function candidates(dir, specifier) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+        return [];
+    }
+    const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);
+    return [
+        path,
+        ...emittedFrom(path, { sourceDirs: [] }),
+        ...RESOLVED_EXTENSIONS.map((extension) => path + extension),
+        ...RESOLVED_EXTENSIONS.map((extension) => `${path}/index${extension}`),
+    ];
+}
+/** The text of a specifier written as literal text, or undefined for any other expression. */
+function literalText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node))
+        ? node.text
+        : undefined;
+}
+/**
+ * Every module one file names: an import declaration, a re-export, and an `import()` call
+ * of literal text anywhere in the file. A namespace form, a star re-export, a bare import
+ * and an `import()` evaluate the module.
+ */
+function modulesNamed(file) {
+    const found = [];
+    const name = (specifier, names, evaluates) => {
+        const text = literalText(specifier);
+        if (text !== undefined) {
+            found.push({ specifier, text, names, evaluates });
+        }
+    };
+    for (const statement of file.statements) {
+        if (isImportDeclaration(statement)) {
+            const clause = statement.importClause;
+            const bindings = clause?.namedBindings;
+            name(statement.moduleSpecifier, [
+                ...(clause?.name === undefined ? [] : ["default"]),
+                ...(bindings === undefined || isNamespaceImport(bindings)
+                    ? []
+                    : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
+            ], bindings === undefined ? clause?.name === undefined : isNamespaceImport(bindings));
+        }
+        else if (isExportDeclaration(statement) && statement.moduleSpecifier !== undefined) {
+            const clause = statement.exportClause;
+            const star = clause === undefined || isNamespaceExport(clause);
+            name(statement.moduleSpecifier, star ? [] : clause.elements.map((one) => (one.propertyName ?? one.name).text), star);
+        }
+    }
+    const visit = (node) => {
+        if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+            const [argument] = node.arguments;
+            if (argument !== undefined) {
+                name(argument, [], true);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Each of the given paths below the target root, parsed; one that cannot be read is skipped. */
+export function testFilesAt(host, targetRoot, paths, parse) {
+    return paths.flatMap((path) => {
+        const fileName = joinPath(targetRoot, path);
+        let text;
+        try {
+            text = host.readFile(fileName);
+        }
+        catch {
+            return [];
+        }
+        return [{ path, file: parse(fileName, text) }];
+    });
+}
+/**
+ * The references the given test files make to one project's own files through the
+ * modules they name ({@link modulesNamed}). A name read from a module references each
+ * top-level declaration the file exports under it; an evaluating form references the
+ * file. A query after the path names the file as {@link queriedModulePath} reads it.
+ */
+export function outsideTestReferences(tests, held, targetRoot) {
+    const fileAt = new Map(held.symbols
+        .filter((symbol) => symbol.kind === "file")
+        .map((symbol) => [symbol.position.path, symbol.id]));
+    // Keyed on the reference's fragment, which spells the export name where the display
+    // name of a default export is its declared name.
+    const exported = new Map();
+    for (const symbol of held.symbols) {
+        if (symbol.exported) {
+            const fragment = symbol.ref.slice(symbol.ref.lastIndexOf("#") + 1).replace(/:alias$/u, "");
+            const key = `${symbol.parent}\u0000${fragment}`;
+            exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
+        }
+    }
+    const found = [];
+    for (const { path, file } of tests) {
+        const from = `${path}#`;
+        const dir = dirnamePath(path) === "." ? "" : dirnamePath(path);
+        for (const named of modulesNamed(file)) {
+            const written = named.text.includes("?") ? queriedModulePath(named.text) : named.text;
+            if (written === undefined) {
+                continue;
+            }
+            const fileId = candidates(dir, written)
+                .map((one) => fileAt.get(one))
+                .find((one) => one !== undefined);
+            if (fileId === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, named.specifier.getStart());
+            const read = (to, use) => {
+                found.push({ from, to, position, use, resolution: "syntax", test: true, unheld: true });
+            };
+            if (named.evaluates) {
+                read(fileId, "evaluation");
+            }
+            for (const name of named.names) {
+                for (const id of exported.get(`${fileId}\u0000${nameComponent(name)}`) ?? []) {
+                    read(id, "read");
+                }
+            }
+        }
+    }
+    return found;
+}

package/dist/src/overrides.js

@@ -0,0 +1,104 @@
+/**
+ * The overrides of the target's class members. A call through the base class, `this`
+ * in the base's own body or a value typed as the base, names the base's member and
+ * runs the override of whichever subclass the value is, so the base member's
+ * declaration references every override as a use of it.
+ */
+import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { memberComponent } from "./class-members.js";
+import { nodeKey } from "./inventory.js";
+import { UNANSWERED } from "./query.js";
+/** The member kinds a subclass overrides. */
+const OVERRIDABLE = new Set(["method", "class-member"]);
+/** The node naming the class one `extends` entry names. */
+function nameOf(entry) {
+    if (isExpressionWithTypeArguments(entry)) {
+        return isPropertyAccessExpression(entry.expression) ? entry.expression.name : entry.expression;
+    }
+    return isQualifiedName(entry.typeName) ? entry.typeName.right : entry.typeName;
+}
+/** Each class of the target whose `extends` clause names a class, with the name node. */
+function extending(project, held) {
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                const id = held.declarations.get(nodeKey(file, node));
+                const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
+                const base = clause?.types[0];
+                if (id !== undefined && base !== undefined) {
+                    found.push({ id, base: nameOf(base) });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}
+/**
+ * The references each base class member makes to its overrides, for the classes of one
+ * project that extend another class of the target. A member a nearer base already
+ * overrides is reached through that override. A private member is not overridden.
+ * Each reference is placed at the override and made by its file.
+ */
+export function overrideReferences(project, held, chains, testFiles) {
+    const classes = extending(project, held);
+    if (classes.length === 0) {
+        return [];
+    }
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    const members = new Map();
+    for (const symbol of held.symbols) {
+        const component = memberComponent(symbol, byId);
+        if (component === undefined ||
+            !OVERRIDABLE.has(symbol.kind) ||
+            symbol.visibility === "private" ||
+            symbol.visibility === "private-name") {
+            continue;
+        }
+        const own = members.get(symbol.parent) ?? new Map();
+        own.set(component, symbol);
+        members.set(symbol.parent, own);
+    }
+    const bases = new Map();
+    const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
+    classes.forEach(({ id }, index) => {
+        const symbol = symbols[index];
+        if (symbol !== undefined && symbol !== UNANSWERED) {
+            bases.set(id, chains
+                .chainOf(symbol)
+                .map((target) => target.id)
+                .filter((target) => byId.get(target)?.kind === "class" && target !== id));
+        }
+    });
+    /** The nearest member of one component the class or a class it extends declares. */
+    const declaredAbove = (classId, component, seen) => {
+        if (seen.has(classId)) {
+            return [];
+        }
+        seen.add(classId);
+        const own = members.get(classId)?.get(component);
+        if (own !== undefined) {
+            return [own.id];
+        }
+        return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
+    };
+    const found = [];
+    for (const [classId, baseIds] of bases) {
+        for (const [component, member] of members.get(classId) ?? []) {
+            const seen = new Set([classId]);
+            for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
+                found.push({
+                    from: base,
+                    to: member.id,
+                    position: member.position,
+                    use: "read",
+                    resolution: "override",
+                    test: testFiles.has(member.position.path),
+                });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/paths.js

@@ -65,6 +65,23 @@ export function dirnamePath(path) {
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
+/**
+ * The relative path before the query of a relative module specifier such as
+ * `./worker.ts?worker`, the module a bundler loads; undefined for a specifier with no
+ * query, one that is not relative, and one whose query has a `raw` parameter, which
+ * reads the file as text and so evaluates nothing.
+ */
+export function queriedModulePath(specifier) {
+    const query = specifier.indexOf("?");
+    if (query < 0 || !(specifier.startsWith("./") || specifier.startsWith("../"))) {
+        return undefined;
+    }
+    const raw = specifier
+        .slice(query + 1)
+        .split("&")
+        .some((parameter) => parameter.split("=")[0] === "raw");
+    return raw ? undefined : specifier.slice(0, query);
+}
 /**
  * One path as it reads below a root, or undefined when it is not below the root.
  * Both are normalized first, so a root written with a trailing separator or a `.`

package/dist/src/references.js

@@ -1,10 +1,13 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
+import { specifierCandidates } from "./configuration-files.js";
+import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
-import { relativePath } from "./paths.js";
+import { overrideReferences } from "./overrides.js";
+import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
 import { typeQueryAliases } from "./type-query-alias.js";
@@ -168,6 +171,44 @@ function markStores(node, writes, reads) {
         }
     }
 }
+/** Whether one node is `import.meta.url`. */
+function isImportMetaURL(node) {
+    const at = unparenthesized(node);
+    return (isPropertyAccessExpression(at) &&
+        isMetaProperty(at.expression) &&
+        at.expression.keywordToken === SyntaxKind.ImportKeyword &&
+        at.name.text === "url");
+}
+/** The module URL one node builds, where it builds one. */
+function moduleURLOf(node) {
+    const relative = (argument) => {
+        const at = argument === undefined ? undefined : unparenthesized(argument);
+        return at !== undefined &&
+            (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
+            /^\.\.?\//u.test(at.text)
+            ? at.text
+            : undefined;
+    };
+    if (isNewExpression(node) && isIdentifier(node.expression) && node.expression.text === "URL") {
+        const [reference, base] = node.arguments ?? [];
+        const specifier = relative(reference);
+        return specifier !== undefined && base !== undefined && isImportMetaURL(base)
+            ? { specifier, constructor: node.expression, at: node }
+            : undefined;
+    }
+    if (isCallExpression(node)) {
+        const callee = unparenthesized(node.expression);
+        const specifier = relative(node.arguments[0]);
+        if (specifier !== undefined &&
+            isPropertyAccessExpression(callee) &&
+            isMetaProperty(callee.expression) &&
+            callee.expression.keywordToken === SyntaxKind.ImportKeyword &&
+            callee.name.text === "resolve") {
+            return { specifier, constructor: undefined, at: node };
+        }
+    }
+    return undefined;
+}
 /** Whether one node is a string literal or a template literal with no substitution. */
 function isLiteralText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -200,6 +241,19 @@ function evaluatedBy(node) {
     }
     return undefined;
 }
+/**
+ * The own file a module specifier with a query evaluates ({@link queriedModulePath}): the
+ * checker resolves the whole specifier to whatever module declaration matches it.
+ */
+function queriedFile(file, specifier, fileIdByName) {
+    if (!isStringLiteral(specifier) && !isNoSubstitutionTemplateLiteral(specifier)) {
+        return undefined;
+    }
+    const path = queriedModulePath(specifier.text);
+    return path === undefined
+        ? undefined
+        : fileIdByName.get(resolvePath(dirnamePath(file.fileName), path));
+}
 /**
  * The re-exports one node writes, if it is an export declaration. A specifier and a
  * namespace export are declarations whose names are where they are written, so no use is
@@ -272,7 +326,10 @@ function sitesOf(file, declarations, fileId, unread) {
     const reads = [];
     const links = [];
     const evaluations = [];
+    const wholes = [];
+    const urls = [];
     const decorated = [];
+    const namespaces = namespaceUses(file);
     const literals = [];
     const flows = [];
     const writes = new Set();
@@ -301,6 +358,13 @@ function sitesOf(file, declarations, fileId, unread) {
         if (unread.has(node)) {
             return;
         }
+        const namespace = namespaces.get(node);
+        if (namespace?.kind === "whole") {
+            wholes.push({ specifier: namespace.specifier, at: node, from: enclosing });
+        }
+        else if (namespace?.kind === "indexed") {
+            found.push({ node: namespace.literal, shorthand: undefined, from: enclosing, use: "read" });
+        }
         if (isName(node)) {
             if (!declared.has(node.pos)) {
                 const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
@@ -330,6 +394,10 @@ function sitesOf(file, declarations, fileId, unread) {
         if (evaluated !== undefined) {
             evaluations.push({ node: evaluated, from: enclosing });
         }
+        const url = moduleURLOf(node);
+        if (url !== undefined) {
+            urls.push(url);
+        }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -344,7 +412,7 @@ function sitesOf(file, declarations, fileId, unread) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, literals, flows, reads, links, evaluations, decorated };
+    return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
 }
 /** The declaration kinds of a property an object literal declares. */
 const LITERAL_PROPERTY_KINDS = new Set([
@@ -569,6 +637,30 @@ export function references(project, held, targetRoot, options) {
         }
         return topLevel.get(fileId) ?? [];
     };
+    const exportsCache = new Map();
+    /**
+     * Every declaration one module exports, each re-export walked along its chain. A module
+     * the checker left unanswered may be any file, so it reads every file's exports.
+     */
+    const exportsRead = (module) => {
+        if (module === UNANSWERED) {
+            return [...fileIds].flatMap((id) => declaredIn(id)
+                .filter((symbol) => symbol.exported)
+                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })));
+        }
+        const known = exportsCache.get(module.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const table = project.queries.exportsOfModule(module);
+        const read = table === UNANSWERED
+            ? chains.declarationsOf(module).flatMap((id) => declaredIn(id)
+                .filter((symbol) => symbol.exported)
+                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })))
+            : table.flatMap((exported) => chains.chainOf(exported));
+        exportsCache.set(module.id, read);
+        return read;
+    };
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
     /**
@@ -654,6 +746,7 @@ export function references(project, held, targetRoot, options) {
         const fileId = declaredAt(file) ?? "";
         return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
     });
+    const fileIdByName = new Map(walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]));
     const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
     const writtenBy = new Map();
     for (const write of contextual.writes) {
@@ -731,7 +824,7 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
-    for (const { file, fileId, uses, reads, links, evaluations, decorated } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } of walked) {
         const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
@@ -759,6 +852,8 @@ export function references(project, held, targetRoot, options) {
                 ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
                 ...links.map((link) => link.node),
                 ...evaluations.map((evaluation) => evaluation.node),
+                ...wholes.map((whole) => whole.specifier),
+                ...urls.flatMap((url) => url.constructor ?? []),
                 ...bindings.map((binding) => binding.node),
             ]),
         ];
@@ -796,6 +891,17 @@ export function references(project, held, targetRoot, options) {
             }
         }
         for (const evaluation of evaluations) {
+            const queried = queriedFile(file, evaluation.node, fileIdByName);
+            if (queried !== undefined) {
+                found.push({
+                    from: evaluation.from,
+                    to: queried,
+                    position: renderPosition(file, root, evaluation.node.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
             const module = answered.get(evaluation.node);
             if (module === undefined) {
                 continue;
@@ -816,6 +922,43 @@ export function references(project, held, targetRoot, options) {
                 }
             }
         }
+        for (const url of urls) {
+            const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+            if (typeof constructor === "object" &&
+                constructor.declarations.some((handle) => ownPaths.has(handle.path))) {
+                continue;
+            }
+            const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
+                .map((path) => fileIdByName.get(path))
+                .find((id) => id !== undefined);
+            if (loaded !== undefined) {
+                found.push({
+                    from: fileId,
+                    to: loaded,
+                    position: renderPosition(file, root, url.at.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
+        }
+        for (const whole of wholes) {
+            const module = answered.get(whole.specifier);
+            if (module === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, root, whole.at.getStart());
+            for (const target of exportsRead(module)) {
+                found.push({
+                    from: whole.from,
+                    to: target.id,
+                    position,
+                    use: "read",
+                    resolution: target.guessed ? "by-name" : "batch",
+                    test,
+                });
+            }
+        }
         if (markup) {
             for (const symbol of declaredIn(fileId)) {
                 found.push({
@@ -924,6 +1067,9 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    if (consumer === undefined) {
+        found.push(...overrideReferences(project, held, chains, new Set(tests)));
+    }
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||