@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.3

package/dist/src/serialization-contract.js

@@ -6,7 +6,7 @@
  * the project handing such a parameter to a destination is one, to a fixpoint, and a
  * function invoked through `call`, `apply` or `bind` is the callee.
  */
-import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -173,9 +173,31 @@ function walkProject(project, held) {
     }
     return { sites, parameters };
 }
+/** The calls of `Object` that read every own property of their argument by name. */
+const ENUMERATIONS = new Set([
+    "keys",
+    "entries",
+    "values",
+    "getOwnPropertyNames",
+    "assign",
+]);
 /**
- * The parameters that keep nothing of the value they are given: one typed `unknown` or
- * `any`, and a rest parameter whose elements are, each by its symbol.
+ * Whether a parameter type keeps no member name of the value it is given: `unknown`, `any`,
+ * or an object type of a string index signature and no property.
+ */
+function keepsNoName(project, type) {
+    if ((type.flags & ERASED) !== 0) {
+        return true;
+    }
+    if ((type.flags & TypeFlags.Object) === 0 ||
+        must(project.queries.propertiesOf(type)).length > 0) {
+        return false;
+    }
+    return must(project.queries.indexInfosOf(type)).some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
+}
+/**
+ * The parameters that keep no member name of the value they are given, as `keepsNoName`
+ * reads it, and a rest parameter whose elements keep none, each by its symbol.
  */
 function erasedParameters(project, parameters) {
     const types = typesAt(project, parameters.map((parameter) => parameter.name));
@@ -185,10 +207,10 @@ function erasedParameters(project, parameters) {
             return false;
         }
         if (!parameter.rest) {
-            return (type.flags & ERASED) !== 0;
+            return keepsNoName(project, type);
         }
         const [element] = must(project.queries.typeArguments(type));
-        return element !== undefined && (element.flags & ERASED) !== 0;
+        return element !== undefined && keepsNoName(project, element);
     });
     const bySymbol = new Map();
     project
@@ -202,6 +224,103 @@ function erasedParameters(project, parameters) {
     });
     return bySymbol;
 }
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunctionNode(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node));
+}
+/** The name a function nested in another is called by: its own, or the variable it initializes. */
+function nestedName(fn) {
+    if (isFunctionDeclaration(fn)) {
+        return fn.name?.text;
+    }
+    let at = fn.parent;
+    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+        at = at.parent;
+    }
+    return isVariableDeclaration(at) && isIdentifier(at.name) ? at.name.text : undefined;
+}
+/** The names one function's body writes as identifiers, other than the names its declarations bind. */
+function namesWritten(fn) {
+    const found = new Set();
+    const visit = (node) => {
+        const declares = (isFunctionDeclaration(node.parent) || isVariableDeclaration(node.parent)) &&
+            node.parent.name === node;
+        if (isIdentifier(node) && !declares) {
+            found.add(node.text);
+        }
+        node.forEachChild(visit);
+    };
+    fn.forEachChild(visit);
+    return found;
+}
+/**
+ * The erased parameters their own function enumerates: one an `Object.keys`, `entries`,
+ * `values`, `getOwnPropertyNames` or `assign` call takes, `Object` the standard library's,
+ * or a `for…in` statement walks, which reads every property of the value by its name. A
+ * nested function is read as the function's own only where its name is written in it, or
+ * it has none, a callback or a function called where it is written.
+ */
+function enumeratedParameters(project, erased) {
+    const asked = [];
+    for (const parameter of erased.values()) {
+        const fn = parameter.name.parent.parent;
+        const spelled = parameter.name.getText();
+        const written = namesWritten(fn);
+        const visit = (node) => {
+            if (isFunctionNode(node)) {
+                const name = nestedName(node);
+                if (name !== undefined && !written.has(name)) {
+                    return;
+                }
+            }
+            const read = [];
+            let object;
+            if (isCallExpression(node)) {
+                const callee = node.expression;
+                if (isPropertyAccessExpression(callee) &&
+                    isIdentifier(callee.expression) &&
+                    callee.expression.text === "Object" &&
+                    ENUMERATIONS.has(callee.name.text)) {
+                    object = callee.expression;
+                    // `Object.assign` reads its sources, every argument after the target.
+                    read.push(...node.arguments.slice(...(callee.name.text === "assign" ? [1] : [0, 1])));
+                }
+            }
+            else if (isForInStatement(node)) {
+                read.push(node.expression);
+            }
+            for (const value of read.map(evaluated)) {
+                if (isIdentifier(value) && value.text === spelled) {
+                    asked.push({ node: value, parameter, object });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        fn.forEachChild(visit);
+    }
+    const symbols = project.symbolsAt(asked.map((one) => project.handle(one.node))).map(must);
+    const objects = asked.flatMap((one) => (one.object === undefined ? [] : [one.object]));
+    const own = project.ownPaths();
+    const standard = new Set(project
+        .symbolsAt(objects.map((node) => project.handle(node)))
+        .map(must)
+        .flatMap((symbol, at) => symbol?.declarations.every((handle) => !own.has(handle.path)) === true ? [objects[at]] : []));
+    return [
+        ...new Set(asked.flatMap((one, at) => {
+            const symbol = symbols[at];
+            return symbol !== undefined &&
+                erased.get(symbol.id) === one.parameter &&
+                (one.object === undefined || standard.has(one.object))
+                ? [one.parameter]
+                : [];
+        })),
+    ];
+}
 /** Each place a call's argument passes one of the erased parameters it can see. */
 function handedOn(project, sites, erased, invocationOf) {
     const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
@@ -285,8 +404,8 @@ function implementedOwners(project, inAnalysis) {
  * callee is a serializer an entry names; at the arguments its resolved signature types
  * `unknown` or `any` where its callee is declared outside the analysis or only ambiently
  * with no implementation in it; and, where its callee is a function of the project, at each
- * parameter the function hands on to a destination, holding back the widest of what those
- * destinations hold back, which is settled by widening until no parameter moves.
+ * parameter the function enumerates or hands on to a destination, holding back the widest
+ * of what those hold back, settled by widening until no parameter moves.
  */
 function destinations(input, chains, walked) {
     const { project, held } = input;
@@ -478,6 +597,9 @@ function destinations(input, chains, walked) {
         }
         return undefined;
     };
+    for (const parameter of enumeratedParameters(project, erased)) {
+        forwards.set(keyOf(parameter), "properties");
+    }
     const forwarded = handedOn(project, walked.sites, erased, invocation);
     for (let moved = true; moved;) {
         moved = false;
@@ -551,6 +673,14 @@ function flowsOf(project, held, sites, to, stores) {
                 },
             ];
     });
+    const generic = typeParameterFlows(project, reach, sites, arguments_.flatMap((one) => {
+        const type = typeOf.get(one.value);
+        const parameters = type === undefined ? [] : typeParametersOf(project, type, 0);
+        const destination = parameters.length === 0 ? undefined : to.at(one.site.call, one.argument);
+        return destination === undefined
+            ? []
+            : parameters.map((parameter) => ({ parameter, to: destination }));
+    }));
     const left = stores.outside.flatMap((store) => {
         const reached = reach.reachedFrom(store.type);
         return reached.classes.size === 0 && reached.members.length === 0
@@ -565,7 +695,127 @@ function flowsOf(project, held, sites, to, stores) {
                 },
             ];
     });
-    return [...passed, ...left];
+    return [...passed, ...generic, ...left];
+}
+/** The type parameters one type names, through constituents and type arguments. */
+function typeParametersOf(project, type, depth) {
+    if (type.isTypeParameter()) {
+        return [type];
+    }
+    if (depth >= MENTION_DEPTH) {
+        return [];
+    }
+    const { queries } = project;
+    return [
+        ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+        ...must(queries.typeArguments(type)),
+    ].flatMap((one) => typeParametersOf(project, one, depth + 1));
+}
+/**
+ * The types an instantiated type puts where a declared type names `parameter`: matched
+ * through type arguments, and in a union every constituent the declared union does not
+ * itself name.
+ */
+function bound(project, declared, instantiated, parameter, depth) {
+    if (declared.id === parameter.id) {
+        return [instantiated];
+    }
+    if (depth >= MENTION_DEPTH) {
+        return [];
+    }
+    const { queries } = project;
+    if (declared.isUnionType()) {
+        const parts = must(queries.constituents(declared));
+        if (parts.some((part) => part.id === parameter.id)) {
+            const kept = new Set(parts.map((part) => part.id));
+            const given = instantiated.isUnionType()
+                ? must(queries.constituents(instantiated))
+                : [instantiated];
+            return given.filter((part) => !kept.has(part.id));
+        }
+    }
+    const declaredArguments = must(queries.typeArguments(declared));
+    const givenArguments = must(queries.typeArguments(instantiated));
+    return declaredArguments.length !== givenArguments.length
+        ? []
+        : declaredArguments.flatMap((one, at) => {
+            const given = givenArguments[at];
+            return given === undefined ? [] : bound(project, one, given, parameter, depth + 1);
+        });
+}
+/**
+ * The flows a type parameter of a function of the project carries where a value its type
+ * names reaches a destination: each call of the function passes its type argument there,
+ * written or inferred from the arguments, and a type argument that is a type parameter
+ * of the calling function is followed on to that function's calls, to a fixpoint.
+ */
+function typeParameterFlows(project, reach, sites, pending) {
+    const { queries } = project;
+    const byName = new Map();
+    for (const site of sites) {
+        const name = calleeName(site.call.expression)?.getText();
+        if (name !== undefined) {
+            byName.set(name, [...(byName.get(name) ?? []), site]);
+        }
+    }
+    const found = [];
+    const seen = new Set();
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const { parameter, to } = next;
+        if (seen.has(parameter.id)) {
+            continue;
+        }
+        seen.add(parameter.id);
+        const symbol = must(queries.symbolOfType(parameter));
+        const [handle] = symbol?.declarations ?? [];
+        const declaration = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+        const fn = declaration?.parent;
+        const index = fn === undefined || !isFunctionLikeDeclaration(fn)
+            ? -1
+            : (fn.typeParameters ?? []).findIndex((one) => one === declaration);
+        const name = fn === undefined
+            ? undefined
+            : isMethodDeclaration(fn) && isIdentifier(fn.name)
+                ? fn.name.text
+                : nestedName(fn);
+        if (symbol === undefined || fn === undefined || index < 0 || name === undefined) {
+            continue;
+        }
+        for (const site of byName.get(name) ?? []) {
+            const resolved = must(queries.resolvedSignature(site.call));
+            const declared = resolved === undefined ? undefined : must(queries.genericOf(resolved));
+            const called = declared?.declaration === undefined
+                ? undefined
+                : project.declarationAt(declared.declaration)?.node;
+            if (resolved === undefined || declared === undefined || called !== fn) {
+                continue;
+            }
+            const written = site.call.typeArguments?.[index];
+            const given = written === undefined
+                ? site.call.arguments.flatMap((_argument, at) => {
+                    const from = must(queries.parameterType(declared, at));
+                    const into = must(queries.parameterType(resolved, at));
+                    return from === undefined || into === undefined
+                        ? []
+                        : bound(project, from, into, parameter, 0);
+                })
+                : typesAt(project, [written]).filter((type) => type !== undefined);
+            for (const type of given) {
+                const reached = reach.reachedFrom(type);
+                if (reached.classes.size > 0 || reached.members.length > 0) {
+                    found.push({
+                        site: site.call,
+                        classes: reached.classes,
+                        members: reached.members,
+                        to,
+                        detail: `passed to ${to.callee} through the type parameter ${symbol.name}`,
+                    });
+                }
+                pending.push(...typeParametersOf(project, type, 0).map((one) => ({ parameter: one, to })));
+            }
+        }
+    }
+    return found;
 }
 /**
  * The serialization-contract detector: each data member and `toJSON` of each class,

package/dist/src/suppress.js

@@ -57,6 +57,7 @@ export const GO_REF_EXPRESSIONS = [
     `^go://${GO_PATH}#${GO_IDENT}$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})+$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})?\\[${GO_IDENT}\\]$`,
+    `^go://${GO_PATH}#(?:${GO_IDENT}(?:\\.${GO_IDENT})?)?\\(${GO_IDENT}\\)$`,
     `^go://${GO_PATH}#${GO_FILE}:file$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:require$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:replace$`,

package/dist/src/sweep.js

@@ -84,10 +84,10 @@ export function runnerCalls(symbol) {
  * That run's roots are the graph's own and, of each test file, its top level and every
  * function it exports, which a test runner may call, and every export of a manual mock,
  * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph, held) {
+export function reachedWithTheTests(graph, held, namespaces = true) {
     const tests = graph.symbols.flatMap((symbol, at) => {
         const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
         const called = exported && runnerCalls(symbol);
@@ -97,9 +97,7 @@ export function reachedWithTheTests(graph, held) {
             ? [{ at, kind: "test-runner" }]
             : [];
     });
-    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-        production: false,
-    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
 }
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
@@ -126,7 +124,7 @@ function flagged(graph, ids) {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, held, mode) {
+function reachable(graph, held, mode, namespaces = true) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
@@ -154,7 +152,7 @@ function reachable(graph, held, mode) {
                 if (!holding && mode.production && edge.test) {
                     continue;
                 }
-                enter(edge.to, !edge.evaluation);
+                enter(edge.to, namespaces && !edge.evaluation);
             }
         }
     };
@@ -169,7 +167,7 @@ function reachable(graph, held, mode) {
     }
     // A consumer's reference reaches what it names as one of the target's own does.
     for (const edge of callsOf(graph, mode)) {
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
     }
     walk(false);
     return reached;

package/dist/src/test-globals.js

@@ -0,0 +1,234 @@
+/**
+ * The globals a test runner injects into every file it runs, which no import names: a
+ * Vitest configuration whose `test.globals` is `true` gives each test and each file it
+ * loads `describe`, `it`, `expect` and `vi` (https://vitest.dev/config/globals). A program
+ * analyzed without the runner's declarations of them reads every use as an error, so a
+ * configuration under such a runner is read with them; and a file that calls one is
+ * written for the runner, as one that imports it is.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, joinPath } from "./paths.js";
+import { UNANSWERED } from "./query.js";
+import { writtenPath } from "./workspace-programs.js";
+/** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
+export const GLOBALS_RUNNER = "vitest";
+const GLOBALS_TYPES = "vitest/globals";
+/** The configuration files the runner reads its settings from, by name. */
+const RUNNER_CONFIG = /^(?:vitest|vite)\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+/** The globals `vitest/globals` declares that a test or a helper calls or reads a member of. */
+const GLOBAL_NAMES = new Set([
+    "afterAll",
+    "afterEach",
+    "assert",
+    "assertType",
+    "beforeAll",
+    "beforeEach",
+    "bench",
+    "describe",
+    "expect",
+    "expectTypeOf",
+    "it",
+    "onTestFailed",
+    "onTestFinished",
+    "suite",
+    "test",
+    "vi",
+    "vitest",
+]);
+/** The expression one wrapper that changes no value holds, and a call's first argument. */
+function configObject(node) {
+    let at = node;
+    while (at !== undefined) {
+        if (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+            at = at.expression;
+        }
+        else if (isCallExpression(at)) {
+            at = at.arguments[0];
+        }
+        else {
+            return at;
+        }
+    }
+    return undefined;
+}
+/** The value one object literal writes for one member as `name: value`. */
+function member(object, name) {
+    if (object === undefined || !isObjectLiteralExpression(object)) {
+        return undefined;
+    }
+    for (const property of object.properties) {
+        if (isPropertyAssignment(property) &&
+            isIdentifier(property.name) &&
+            property.name.text === name) {
+            return configObject(property.initializer);
+        }
+    }
+    return undefined;
+}
+/** Whether one runner configuration's default export sets `test.globals` to `true`. */
+function setsGlobals(file) {
+    for (const statement of file.statements) {
+        let exported;
+        if (isExportAssignment(statement)) {
+            exported = statement.expression;
+        }
+        else if (isExpressionStatement(statement) && isBinaryExpression(statement.expression)) {
+            const { left, operatorToken, right } = statement.expression;
+            if (operatorToken.kind === SyntaxKind.EqualsToken &&
+                isPropertyAccessExpression(left) &&
+                isIdentifier(left.expression) &&
+                left.expression.text === "module" &&
+                isIdentifier(left.name) &&
+                left.name.text === "exports") {
+                exported = right;
+            }
+        }
+        const object = exported === undefined ? undefined : configObject(exported);
+        const globals = member(member(object, "test"), "globals");
+        if (globals?.kind === SyntaxKind.TrueKeyword) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Whether the runner's configuration in one manifest's directory injects the globals. */
+function injectsGlobals(host, parse, dir) {
+    let names;
+    try {
+        names = host
+            .readDirectory(dir)
+            .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return false;
+    }
+    return names.some((name) => {
+        const path = joinPath(dir, name);
+        try {
+            return setsGlobals(parse(path, host.readFile(path)));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Whether a file declaring the globals is installed where the configuration resolves packages from. */
+function globalsInstalled(host, configFile) {
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
+            return true;
+        }
+        if (dirnamePath(dir) === dir) {
+            return false;
+        }
+    }
+}
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host, configFile) {
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+            return dir;
+        }
+        if (dirnamePath(dir) === dir) {
+            return undefined;
+        }
+    }
+}
+function typesOf(value) {
+    return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
+}
+/**
+ * How the snapshot reads each configuration of `configFiles` whose nearest manifest's
+ * runner configuration injects the globals and that can resolve their declarations: as
+ * `programs` reads it, else as itself, with the globals' declarations added to its `types`.
+ * A configuration the compiler cannot read is left for its project to refuse.
+ */
+export function withTestGlobals(engine, host, parse, configFiles, programs) {
+    const found = new Map(programs);
+    const injects = new Map();
+    for (const configFile of configFiles) {
+        const dir = manifestDir(host, configFile);
+        if (dir === undefined || !globalsInstalled(host, configFile)) {
+            continue;
+        }
+        if (!injects.has(dir)) {
+            injects.set(dir, injectsGlobals(host, parse, dir));
+        }
+        if (injects.get(dir) !== true) {
+            continue;
+        }
+        let base;
+        try {
+            base = typesOf(engine.parseConfigFile(configFile).options.types) ?? [];
+        }
+        catch {
+            continue;
+        }
+        const held = found.get(configFile);
+        if (held?.kind === "program") {
+            const listed = typesOf(held.params.compilerOptions.types) ?? base;
+            if (!listed.includes(GLOBALS_TYPES)) {
+                found.set(configFile, {
+                    kind: "program",
+                    params: {
+                        ...held.params,
+                        compilerOptions: { ...held.params.compilerOptions, types: [...listed, GLOBALS_TYPES] },
+                    },
+                });
+            }
+            continue;
+        }
+        let written = { extends: configFile };
+        if (held !== undefined) {
+            try {
+                written = JSON.parse(held.text);
+            }
+            catch {
+                continue;
+            }
+        }
+        const options = (written["compilerOptions"] ?? {});
+        const listed = typesOf(options["types"]) ?? base;
+        if (listed.includes(GLOBALS_TYPES)) {
+            continue;
+        }
+        found.set(configFile, {
+            kind: "configuration",
+            file: held?.file ?? writtenPath(host, configFile),
+            text: `${JSON.stringify({ ...written, compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] } }, null, 2)}\n`,
+        });
+    }
+    return found;
+}
+/**
+ * Whether one file names a global the runner injects, which is how a file written for the
+ * runner's globals reads: a call of one of the names or a read of a member of it that
+ * resolves to a declaration outside the project's own files, the runner's declaration
+ * file. A name the file binds, imported, declared or a parameter, resolves to its own.
+ */
+export function namesTestGlobals(project, file) {
+    const named = [];
+    const visit = (node) => {
+        const callee = isCallExpression(node)
+            ? node.expression
+            : isPropertyAccessExpression(node)
+                ? node.expression
+                : undefined;
+        if (callee !== undefined && isIdentifier(callee) && GLOBAL_NAMES.has(callee.text)) {
+            named.push(callee);
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    if (named.length === 0) {
+        return false;
+    }
+    const own = project.ownPaths();
+    return project
+        .symbolsAt(named.map((node) => project.handle(node)))
+        .some((symbol) => symbol === UNANSWERED ||
+        (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path))));
+}

package/dist/src/test-support.js

@@ -5,21 +5,18 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS } from "./convention-rows.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
 import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
  * The test runners and test libraries an import of which is test evidence: each runner a
- * convention row reads test files for, the platform's own runner, and the libraries below.
+ * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
     ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
-    "node:test",
-    "@playwright/test",
+    ...TEST_LIBRARIES,
 ]);
-/** The scopes every package of which is a test library. */
-const TEST_SCOPES = ["@testing-library/"];
 /**
  * The Node.js built-in modules a bare specifier names, which are no package. The set is
  * closed: Node.js adds a new built-in under the `node:` scheme alone
@@ -73,7 +70,7 @@ const NODE_BUILTINS = new Set([
 function namesTestPackage(specifier) {
     const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
     return (name !== undefined &&
-        (TEST_PACKAGES.has(name) || TEST_SCOPES.some((scope) => name.startsWith(scope))));
+        (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope))));
 }
 /**
  * Whether a file carries test evidence: an import of a test runner or a test library, or
@@ -106,9 +103,9 @@ function evidenceReader(tests, evidence) {
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
  * each carrying test evidence of its own, whose every user outside the set is a test
- * file. A root has a caller outside the reference graph: a runtime, a tool, a
- * configuration, or a consumer of a library's published API. `testFiles` are the files
- * the test-file rules classified.
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(symbols, references, roots, testFiles, evidence) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
@@ -162,7 +159,7 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
     const carries = evidenceReader(tests, evidence);
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
-    return support;
+    return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 /** The references with every one a test-support file makes counted as a test reference. */
 export function supportReferences(references, support) {