@cplieger/deadset-ts 5.0.0 → 5.1.1

package/dist/src/manifest.js

@@ -1,11 +1,10 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts.
- *
- * One call reads one manifest, the one in the directory it is given.
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
-import { isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The manifest's own name. */
 const MANIFEST = "package.json";
 /** The three members that name an entry point beside `exports` and `bin`. */
@@ -144,3 +143,29 @@ export function readManifest(host, targetRoot) {
         declaresExports: manifest["exports"] !== undefined,
     };
 }
+/**
+ * The entry points every package manifest between the target root and each compiler
+ * configuration names: each directory holding a `package.json` that a configuration sits
+ * in or below, the target root and `known` excluded, whose manifests the run reads
+ * otherwise. Each entry is spelled under its manifest's path below the target root, and
+ * is published by its own manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(host, targetRoot, configFiles, known) {
+    const dirs = new Set();
+    for (const configFile of configFiles) {
+        for (let dir = dirnamePath(resolvePath(targetRoot, configFile)); dir !== targetRoot && relativePath(targetRoot, dir) !== undefined; dir = dirnamePath(dir)) {
+            if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+                dirs.add(dir);
+            }
+        }
+    }
+    return [...dirs].sort().flatMap((dir) => {
+        const manifest = readManifest(host, dir);
+        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+        return manifest.entries.map((entry) => ({
+            ...entry,
+            member: `${where} ${entry.member}`,
+            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+        }));
+    });
+}

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/query.js

@@ -73,6 +73,21 @@ function symbolLocation(symbol) {
 function typeLocation(type) {
     return `type ${String(type.id)}`;
 }
+/** The property tables over one project's questions. */
+export function propertyTables(queries) {
+    const held = new Map();
+    return {
+        of: (type) => {
+            const known = held.get(type.id);
+            if (known !== undefined) {
+                return { properties: known, asked: false };
+            }
+            const properties = queries.propertiesOf(type);
+            held.set(type.id, properties);
+            return { properties, asked: true };
+        },
+    };
+}
 /**
  * The guarded questions over one project's checker. `configFile` names the project
  * in the log, `batch` sends many questions in one round trip, `log` is the run's,