@cplieger/deadset-ts 5.1.0 → 5.1.1

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

@@ -4,7 +4,8 @@ import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.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";
@@ -200,6 +201,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
@@ -654,6 +668,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) {
@@ -796,6 +811,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;
@@ -924,6 +950,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) ||

package/dist/src/roots.js

@@ -7,6 +7,7 @@
  * decides; the published API only supposes a consumer, so a published export is live
  * under reachability and still a candidate under reference counting.
  */
+import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
@@ -131,7 +132,7 @@ export function roots(project, held, targetRoot, options) {
             publishes: entry.published &&
                 (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
         })),
-        ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+        ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
     ];
     for (const { entry, publishes } of entries) {
         if (options.publishedAPI && publishes) {
@@ -188,10 +189,11 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    if (options.publishedAPI) {
-        for (const id of publishedAPI(published, exportsOf, held)) {
-            add(id, "published-api", "");
-        }
+    const api = options.publishedAPI
+        ? publishedAPI(project, published, exportsOf, held, files.byPath)
+        : { ids: [], guessed: [] };
+    for (const id of api.ids) {
+        add(id, "published-api", "");
     }
     const unmatched = configured(held, options.patterns, add);
     const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
@@ -205,7 +207,7 @@ export function roots(project, held, targetRoot, options) {
         configFile: project.configFile,
         liveUnderReachability: ordered,
         unmatched,
-        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+        unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
     };
 }
 /**
@@ -255,52 +257,134 @@ function exportTables(project, held, wanted) {
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
 /**
- * Every declaration a consumer of the library can name: what the published files
- * export, and below each, the members a consumer reaches through it.
- *
- * The published files are the ones `exports` reaches where the manifest declares
- * one, because a package that declares `exports` has said exactly what a consumer may
- * import; where it declares none, they are the ones the members that preceded it
- * name. Below a published module or namespace the walk follows what its export table
- * names; below any other published declaration it follows every member a consumer
- * can write: a public one, and a protected one, which a consumer's subclass names. A
- * private member is not published, nor is anything below one, and a type parameter
- * is not published either, because a consumer supplies a type argument by position.
- *
- * A published file is not itself published. A consumer imports a module and names
- * what it exports; the file is a root because the manifest names it, which is a
- * different reason.
+ * Every declaration a consumer of the library can name: what the published files export
+ * and, below each, the members a consumer writes: a namespace's exported ones, any other
+ * declaration's public and protected ones, never a private one or a type parameter. A
+ * declaration a published one's type names is published too, exported or not. A type name
+ * the checker leaves unanswered publishes every declaration spelled as it is, and those are
+ * `guessed`. A published file is not itself published.
  */
-function publishedAPI(published, exportsOf, held) {
+function publishedAPI(project, published, exportsOf, held, byPath) {
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
     const children = childrenOf(held);
+    const nodes = declarationNodes(held, byPath);
+    const chains = aliasChains(project, held);
     const reached = new Set();
+    const guessed = new Set();
     const pending = [];
+    const reach = (id) => {
+        if (!reached.has(id) && byId.get(id)?.kind !== "file") {
+            reached.add(id);
+            pending.push(id);
+        }
+    };
     for (const file of published) {
         for (const id of exportsOf.get(file.fileName) ?? []) {
             if (byId.get(id)?.kind === "file") {
                 pending.push(id);
             }
-            else if (!reached.has(id)) {
-                reached.add(id);
-                pending.push(id);
+            else {
+                reach(id);
             }
         }
     }
-    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-        for (const member of children.get(next) ?? []) {
-            const reachable = exporting
-                ? member.exported
-                : member.visibility !== "private" && member.visibility !== "private-name";
-            if (member.kind === "type-parameter" || reached.has(member.id) || !reachable) {
-                continue;
+    while (pending.length > 0) {
+        const round = [];
+        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+            round.push(next);
+            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+            for (const member of children.get(next) ?? []) {
+                const reachable = exporting
+                    ? member.exported
+                    : member.visibility !== "private" && member.visibility !== "private-name";
+                if (member.kind !== "type-parameter" && reachable) {
+                    reach(member.id);
+                }
             }
-            reached.add(member.id);
-            pending.push(member.id);
         }
+        const named = round.flatMap((id) => {
+            const symbol = byId.get(id);
+            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+        });
+        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+            if (symbol === UNANSWERED) {
+                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+                    guessed.add(id);
+                    reach(id);
+                }
+            }
+            else if (symbol !== undefined) {
+                for (const target of chains.chainOf(symbol)) {
+                    reach(target.id);
+                }
+            }
+        });
     }
-    return [...reached];
+    return { ids: [...reached], guessed: [...guessed] };
+}
+/** The type names declarations of the inventory write, each file walked once, when first asked. */
+function declarationNodes(held, byPath) {
+    const walked = new Map();
+    const nodesIn = (path) => {
+        const known = walked.get(path);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = { byId: new Map(), nodes: new Set() };
+        const file = byPath.get(path);
+        if (file !== undefined) {
+            const visit = (node) => {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    found.nodes.add(node);
+                    if (!found.byId.has(id)) {
+                        found.byId.set(id, node);
+                    }
+                }
+                node.forEachChild(visit);
+            };
+            visit(file);
+        }
+        walked.set(path, found);
+        return found;
+    };
+    return {
+        typeNamesOf: (symbol) => {
+            const { byId, nodes } = nodesIn(symbol.position.path);
+            const declaration = byId.get(symbol.id);
+            return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+        },
+    };
+}
+/**
+ * The names of types one declaration's own syntax writes: in a type reference, a
+ * heritage clause or a type query. A function body is not read, and neither is a
+ * declaration nested in this one, which `nested` holds and which is read on its own.
+ */
+function typeNamesOf(declaration, nested) {
+    const found = [];
+    const visit = (node) => {
+        if (node !== declaration && nested.has(node)) {
+            return;
+        }
+        if (isTypeReferenceNode(node)) {
+            found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+        }
+        else if (isExpressionWithTypeArguments(node)) {
+            found.push(isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
+        }
+        else if (isTypeQueryNode(node)) {
+            found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
+        }
+        const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
+        node.forEachChild((child) => {
+            if (child !== body) {
+                visit(child);
+            }
+        });
+    };
+    visit(declaration);
+    return found;
 }
 /**
  * Keeps every declaration the configuration names and returns every string that

package/dist/src/session.js

@@ -225,10 +225,10 @@ function projectsOf(snapshot, built, written) {
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
  * built as that program, or opened from the configuration it writes, instead of as a project.
  * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. The snapshot is disposed after the last visit and the client released
- * after it, whether the visit completed or threw.
+ * under `"record"`. `last` runs after the last visit while the client still answers; the
+ * snapshot is disposed and the client released after it, whether the visit completed or threw.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map()) {
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined) {
     try {
         const built = [];
         const params = [];
@@ -262,6 +262,7 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
                 }
                 projects.push(visit(viewOf(project, configFile, engine, log)));
             }
+            last();
             return {
                 projects,
                 unopened: missing,

package/dist/src/template-field.js

@@ -87,12 +87,69 @@ function stringEnd(text, from) {
     }
     return at + 1;
 }
-/** The identifiers one action's inner text writes outside a quoted string, with their offsets in it. */
-function identifiersOf(inner) {
+/** The end of the `${` substitution whose expression starts at `from`, past its closing brace. */
+function substitutionEnd(text, from) {
+    let depth = 1;
+    let at = from;
+    while (at < text.length) {
+        const char = text[at];
+        if (char === '"' || char === "'") {
+            at = stringEnd(text, at);
+            continue;
+        }
+        if (char === "`") {
+            at = templateEnd(text, at, () => undefined);
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return at + 1;
+            }
+        }
+        at += 1;
+    }
+    return at;
+}
+/** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
+function templateEnd(text, from, substitution) {
+    let at = from + 1;
+    while (at < text.length && text[at] !== "`") {
+        if (text[at] === "\\") {
+            at += 2;
+            continue;
+        }
+        if (text[at] === "$" && text[at + 1] === "{") {
+            const start = at + 2;
+            const end = substitutionEnd(text, start);
+            substitution(text.slice(start, end - 1), start);
+            at = end;
+            continue;
+        }
+        at += 1;
+    }
+    return at + 1;
+}
+/**
+ * The identifiers one action's inner text writes outside a quoted string, with their offsets
+ * in it. In `script` text, a component's markup, a template literal's substitutions are code.
+ */
+function identifiersOf(inner, script = false) {
     const found = [];
     let at = 0;
     while (at < inner.length) {
         const char = inner[at] ?? "";
+        if (char === "`" && script) {
+            at = templateEnd(inner, at, (expression, offset) => {
+                for (const one of identifiersOf(expression, true)) {
+                    found.push({ name: one.name, offset: offset + one.offset });
+                }
+            });
+            continue;
+        }
         if (char === '"' || char === "'" || char === "`") {
             at = stringEnd(inner, at);
             continue;
@@ -142,7 +199,7 @@ function namesOf(text, delimiters) {
 }
 /** Every identifier the markup of one component file writes in an action. */
 function markupNamesOf(text) {
-    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text).map(({ name, offset }) => ({
+    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text, true).map(({ name, offset }) => ({
         name,
         offset: one.start + offset,
         action: one.action,

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",