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

package/dist/src/dependencies.js

@@ -29,11 +29,13 @@ const PROJECT_OWNER = "";
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
 export function configurationNeeds(packages) {
     return {
-        packages: new Set(packages),
         uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+        at: new Map([[ANYWHERE, new Set(packages)]]),
         unanswered: [],
     };
 }
+/** The key of {@link ProjectNeeds.at} for a use no file of the target governs. */
+const ANYWHERE = "";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -207,9 +209,10 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     }
     const packages = configurationPackages(host, project.configFile, project.program.getCompilerOptions(), programPackages);
     const uses = new Map();
-    const use = (owners, named) => {
+    const at = new Map();
+    const use = (owners, named, path) => {
         for (const one of named) {
-            packages.add(one);
+            at.set(path, (at.get(path) ?? new Set()).add(one));
             for (const owner of owners) {
                 let set = uses.get(owner);
                 if (set === undefined) {
@@ -220,10 +223,13 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     };
-    use([PROJECT_OWNER], packages);
+    use([PROJECT_OWNER], packages, project.configFile);
     const unanswered = [];
     for (const file of project.ownSourceFiles()) {
-        if (fileNeeds(project, held, file, programPackages, use)) {
+        const inFile = (owners, named) => {
+            use(owners, named, file.fileName);
+        };
+        if (fileNeeds(project, held, file, programPackages, inFile)) {
             unanswered.push(file.fileName);
         }
     }
@@ -241,22 +247,26 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     for (const { file } of configuration.modules) {
         const names = declaredAt(file.fileName);
         for (const { node, text } of moduleStrings(file)) {
-            use(ownersOf(file, held, node), dependenciesNamed(text, names));
+            use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
         }
     }
-    for (const document of configuration.documents) {
-        const names = declaredAt(document.path);
-        for (const text of document.strings) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { strings, manifestDirs } of configuration.documents) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const text of strings) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
+            }
         }
     }
-    for (const { file, manifestDir } of configuration.outside) {
-        const names = declaredAt(joinPath(manifestDir, "package.json"));
-        for (const { text } of moduleStrings(file)) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { file, manifestDirs } of configuration.outside) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const { text } of moduleStrings(file)) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
+            }
         }
     }
-    return { packages, uses, unanswered };
+    return { uses, at, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
@@ -492,8 +502,10 @@ function installedOf(host, root, name) {
         const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
         if (read !== undefined && isRecord(read.value)) {
             const bin = read.value["bin"];
+            const peers = read.value["peerDependencies"];
             // A string `bin` names one command, the package's name without its scope.
             return {
+                peers: isRecord(peers) ? Object.keys(peers) : [],
                 commands: typeof bin === "string"
                     ? bin === ""
                         ? []
@@ -554,20 +566,49 @@ function scriptTokensOf(manifest) {
 function isInside(path, dir) {
     return dir === "" || path.startsWith(`${dir}/`);
 }
+/** The directory below the target root a declared dependency's manifest is in, `""` being the root. */
+function manifestDir(dependency) {
+    const dir = dirnamePath(dependency.position.path);
+    return dir === "." ? "" : dir;
+}
+/**
+ * Adds to `needed` each declared dependency that the installed manifest of a needed or
+ * run declared dependency names as a peer, until no further one joins: the declaration of
+ * that name in the needing dependency's manifest or in a manifest above it, where the
+ * installed peer is resolved from. `peers` holds each declaration's installed peers by
+ * {@link declarationKey}.
+ */
+function addNeededPeers(declared, peers, needed, ran) {
+    const pending = declared.filter((dependency) => needed.has(declarationKey(dependency)) || ran.has(declarationKey(dependency)));
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const below = manifestDir(next);
+        for (const peer of peers.get(declarationKey(next)) ?? []) {
+            for (const dependency of declared) {
+                const key = declarationKey(dependency);
+                if (dependency.name === peer &&
+                    !needed.has(key) &&
+                    (below === manifestDir(dependency) || isInside(below, manifestDir(dependency)))) {
+                    needed.add(key);
+                    pending.push(dependency);
+                }
+            }
+        }
+    }
+}
 /**
- * The run's dependency evidence: the target's manifest and each workspace member's in
- * `members` below the target root, read with the position of every dependency each
- * declares, what the projects and the commands its scripts and workflow steps run need,
- * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
- * in configurations the run could not build. A manifest the program cannot read declares
- * nothing.
+ * The run's dependency evidence over the target's manifest and those of `members` and
+ * `nested` packages below the root: each declared dependency's position, what the projects,
+ * scripts and workflow steps need, and each deletion candidate's last uses. A member in
+ * `unbuilt` holds source only in configurations the run could not build. An unreadable
+ * manifest declares nothing, nor does a nested package's uninstalled dependency, because
+ * no run requires a nested package to be installed.
  */
-export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = []) {
+export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const scopeOf = packageScope(host, targetRoot);
     const manifests = new Map([[root, MANIFEST]]);
     const unbuilt = new Set();
-    for (const dir of [...members, ...unbuiltMembers]) {
+    for (const dir of [...members, ...unbuiltMembers, ...nested]) {
         const below = relativePath(root, dir);
         if (below !== undefined && !manifests.has(dir)) {
             manifests.set(dir, `${below}/${MANIFEST}`);
@@ -582,6 +623,8 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     const workflow = new Set(workflowTokens(host, targetRoot));
     const declared = [];
     const ran = new Set();
+    const peers = new Map();
+    const uninstalledHere = new Set(nested);
     for (const [dir, path] of manifests) {
         const read = readJSON(host, joinPath(dir, MANIFEST));
         if (read === undefined || !isRecord(read.value)) {
@@ -589,12 +632,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
         const tokens = scriptTokensOf(read.value);
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
-            declared.push(dependency);
             const found = installedOf(host, dir, dependency.name);
+            if (found === undefined && uninstalledHere.has(dir)) {
+                continue;
+            }
+            declared.push(dependency);
             if (found === undefined) {
                 continue;
             }
-            const runs = (command) => tokens.has(command) || (dir === root && workflow.has(command));
+            peers.set(declarationKey(dependency), found.peers);
+            const runs = (command) => tokens.has(command) || workflow.has(command);
             if (found.commands.some(runs)) {
                 ran.add(declarationKey(dependency));
             }
@@ -603,25 +650,36 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     // A declaration several projects compile is one user, and a use any project makes is
     // a use, so the uses are merged by declaration before anything is counted.
     const needed = new Set();
+    const byName = new Map();
+    for (const dependency of declared) {
+        byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
+    }
     const uses = new Map();
     for (const project of perProject) {
         // A specifier the checker left unanswered may resolve to any dependency a manifest at
         // or above its file declares, and what the configuration needs is never deleted.
         const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
-        const unknown = declared
-            .filter((dependency) => {
-            const dir = dirnamePath(dependency.position.path);
-            return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
-        })
-            .map((dependency) => dependency.name);
+        const unknownDeclared = declared.filter((dependency) => unanswered.some((file) => isInside(file, manifestDir(dependency))));
+        unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+        const unknown = unknownDeclared.map((dependency) => dependency.name);
         const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
         for (const [id, used] of [...project.uses, ...held]) {
             const merged = uses.get(id) ?? new Set();
             used.forEach((one) => merged.add(one));
             uses.set(id, merged);
         }
-        [...project.packages, ...unknown].forEach((one) => needed.add(one));
+        for (const [path, named] of project.at) {
+            const below = path === ANYWHERE ? undefined : relativePath(root, path);
+            for (const one of named) {
+                for (const dependency of byName.get(one) ?? []) {
+                    if (below === undefined || isInside(below, manifestDir(dependency))) {
+                        needed.add(declarationKey(dependency));
+                    }
+                }
+            }
+        }
     }
+    addNeededPeers(declared, peers, needed, ran);
     const users = new Map();
     for (const used of uses.values()) {
         used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));

package/dist/src/discover.js

@@ -23,7 +23,7 @@ export class DiscoveryError extends Error {
 /** The category an error diagnostic carries, which the protocol sends as a number. */
 const ERROR_CATEGORY = DiagnosticCategory.Error;
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic) {
+function isError(diagnostic) {
     return diagnostic.category === ERROR_CATEGORY;
 }
 /**

package/dist/src/edges.js

@@ -25,7 +25,7 @@ const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and a
 const ID_WANT = "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
 const REFERENCE_WANT = "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
     constructor(at, text, want) {
         super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
         this.name = "EdgesError";

package/dist/src/element-access.js

@@ -0,0 +1,341 @@
+/**
+ * The members an element access reads by the literal type of its index: `o[k]` with `k`
+ * typed `"a" | "b"` reads `a` and `b` of the type of `o`, an index typed `keyof T` reads
+ * every member of `T`, and an index typed as a type parameter reads what its constraint does. Where the index is a parameter of a function every call of which the
+ * target holds, the members are read at each call, by the type of the argument it passes.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isCallExpression, isElementAccessExpression, isForInStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+/** The assignment operators that read their target before they write it. */
+const COMPOUND = new Set([
+    SyntaxKind.PlusEqualsToken,
+    SyntaxKind.MinusEqualsToken,
+    SyntaxKind.AsteriskEqualsToken,
+    SyntaxKind.AsteriskAsteriskEqualsToken,
+    SyntaxKind.SlashEqualsToken,
+    SyntaxKind.PercentEqualsToken,
+    SyntaxKind.LessThanLessThanEqualsToken,
+    SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    SyntaxKind.AmpersandEqualsToken,
+    SyntaxKind.BarEqualsToken,
+    SyntaxKind.CaretEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/** How an expression is used where it is written: read, written, or both. */
+function useOf(node) {
+    let at = node;
+    while (isParenthesizedExpression(at.parent)) {
+        at = at.parent;
+    }
+    const parent = at.parent;
+    if (isBinaryExpression(parent) && parent.left === at) {
+        if (parent.operatorToken.kind === SyntaxKind.EqualsToken) {
+            return "write";
+        }
+        if (COMPOUND.has(parent.operatorToken.kind)) {
+            return "both";
+        }
+    }
+    if ((isPrefixUnaryExpression(parent) || isPostfixUnaryExpression(parent)) &&
+        (parent.operator === SyntaxKind.PlusPlusToken || parent.operator === SyntaxKind.MinusMinusToken)) {
+        return "both";
+    }
+    return "read";
+}
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/** Whether an index is a literal the checker resolves to a member by its own text. */
+function isLiteralIndex(node) {
+    const at = unwrapped(node);
+    return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at);
+}
+/**
+ * The function `node` is, where every call of it is written in its own file under its own
+ * name: a function declaration or a `const` initialized with an arrow function or a function
+ * expression, neither exported. A method may be dispatched to through a base class or an
+ * interface, so it is none.
+ */
+function callableOf(node) {
+    const exported = (holder) => (holder.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword || modifier.kind === SyntaxKind.DefaultKeyword);
+    if (isFunctionDeclaration(node)) {
+        return node.name === undefined || exported(node)
+            ? undefined
+            : { name: node.name, parameters: node.parameters, body: node.body };
+    }
+    if (!isArrowFunction(node) && !isFunctionExpression(node)) {
+        return undefined;
+    }
+    const declaration = node.parent;
+    const list = declaration.parent;
+    if (!isVariableDeclaration(declaration) ||
+        declaration.initializer !== node ||
+        !isIdentifier(declaration.name) ||
+        !isVariableDeclarationList(list) ||
+        (list.flags & NodeFlags.Const) === 0 ||
+        !isVariableStatement(list.parent) ||
+        exported(list.parent)) {
+        return undefined;
+    }
+    return { name: declaration.name, parameters: node.parameters, body: node.body };
+}
+/** The innermost function enclosing a node, or none. */
+function enclosingFunction(node) {
+    for (let at = node.parent; at !== undefined; at = at.parent) {
+        if (isFunctionDeclaration(at) ||
+            isArrowFunction(at) ||
+            isFunctionExpression(at) ||
+            at.kind === SyntaxKind.MethodDeclaration ||
+            at.kind === SyntaxKind.Constructor ||
+            at.kind === SyntaxKind.GetAccessor ||
+            at.kind === SyntaxKind.SetAccessor) {
+            return at;
+        }
+    }
+    return undefined;
+}
+/** Whether an assignment target, a destructuring pattern at any depth included, assigns a name. */
+function targetAssigns(target, name) {
+    if (isParenthesizedExpression(target)) {
+        return targetAssigns(target.expression, name);
+    }
+    if (isIdentifier(target)) {
+        return target.text === name;
+    }
+    if (isArrayLiteralExpression(target)) {
+        return target.elements.some((element) => targetAssigns(element, name));
+    }
+    if (isObjectLiteralExpression(target)) {
+        return target.properties.some((property) => isPropertyAssignment(property)
+            ? targetAssigns(property.initializer, name)
+            : isShorthandPropertyAssignment(property)
+                ? isIdentifier(property.name) && property.name.text === name
+                : isSpreadAssignment(property) && targetAssigns(property.expression, name));
+    }
+    if (isSpreadElement(target)) {
+        return targetAssigns(target.expression, name);
+    }
+    // A pattern element with a default value, `[k = "a"] = …`, assigns its left side.
+    return (isBinaryExpression(target) &&
+        target.operatorToken.kind === SyntaxKind.EqualsToken &&
+        targetAssigns(target.left, name));
+}
+/**
+ * Whether a body assigns a name: by an assignment, a destructuring one included, an
+ * increment or a decrement, or as the target of a `for…in` or `for…of` loop.
+ */
+function assigns(body, name) {
+    let found = false;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        const target = isBinaryExpression(node) &&
+            (node.operatorToken.kind === SyntaxKind.EqualsToken || COMPOUND.has(node.operatorToken.kind))
+            ? node.left
+            : (isPrefixUnaryExpression(node) || isPostfixUnaryExpression(node)) &&
+                (node.operator === SyntaxKind.PlusPlusToken ||
+                    node.operator === SyntaxKind.MinusMinusToken)
+                ? node.operand
+                : (isForInStatement(node) || isForOfStatement(node)) &&
+                    node.initializer.kind !== SyntaxKind.VariableDeclarationList
+                    ? node.initializer
+                    : undefined;
+        found = target !== undefined && targetAssigns(target, name);
+        node.forEachChild(visit);
+    };
+    if (body !== undefined) {
+        visit(body);
+    }
+    return found;
+}
+/**
+ * The references the element accesses of one project's own files make to the members their
+ * index's literal type names, each made by the declaration holding the access or the call.
+ */
+export function elementAccessReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const candidates = [];
+    const calls = new Map();
+    const names = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
+                candidates.push({ file, from: holder, access: node, use: useOf(node) });
+            }
+            if (isCallExpression(node)) {
+                calls.set(node, { file, from: holder });
+            }
+            if (isIdentifier(node)) {
+                names.push(node);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    if (candidates.length === 0) {
+        return [];
+    }
+    // A parameter index is decided at the calls only where the function is a callable every
+    // use of which is a call, so the symbols of the parameters and of every name are read.
+    const parameterOf = new Map();
+    const byCallable = new Map();
+    for (const candidate of candidates) {
+        const index = unwrapped(candidate.access.argumentExpression);
+        const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
+        const callable = fn === undefined ? undefined : callableOf(fn);
+        if (callable === undefined || !isIdentifier(index)) {
+            continue;
+        }
+        const at = callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text);
+        if (at < 0 || assigns(callable.body, index.text)) {
+            continue;
+        }
+        parameterOf.set(candidate, { callable, at });
+        byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
+    }
+    const callableNames = [...byCallable.keys()];
+    const spelled = new Set(callableNames.map((name) => name.text));
+    const sameName = names.filter((name) => spelled.has(name.text));
+    const symbols = queries.symbolsAt([...callableNames, ...sameName]);
+    const symbolOf = new Map();
+    [...callableNames, ...sameName].forEach((node, at) => {
+        const symbol = symbols[at];
+        if (symbol !== UNANSWERED && symbol !== undefined) {
+            symbolOf.set(node, symbol);
+        }
+    });
+    const callsOf = new Map();
+    for (const name of callableNames) {
+        const symbol = symbolOf.get(name);
+        let found = symbol === undefined ? undefined : [];
+        for (const use of sameName) {
+            if (found === undefined) {
+                break;
+            }
+            if (use === name || symbolOf.get(use) !== symbol) {
+                continue;
+            }
+            const parent = use.parent;
+            found =
+                isCallExpression(parent) && parent.expression === use ? [...found, parent] : undefined;
+        }
+        callsOf.set(name, found);
+    }
+    const lookups = [];
+    for (const candidate of candidates) {
+        const deferred = parameterOf.get(candidate);
+        const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
+        if (deferred === undefined || sites === undefined) {
+            lookups.push({
+                file: candidate.file,
+                from: candidate.from,
+                at: candidate.access.argumentExpression,
+                object: candidate.access.expression,
+                index: candidate.access.argumentExpression,
+                use: candidate.use,
+            });
+            continue;
+        }
+        // An object that is a parameter too is read as the argument each call passes there.
+        const object = unwrapped(candidate.access.expression);
+        const objectAt = isIdentifier(object)
+            ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
+            : -1;
+        for (const call of sites) {
+            const parameter = deferred.callable.parameters[deferred.at];
+            const index = call.arguments[deferred.at] ?? parameter?.initializer;
+            const site = calls.get(call);
+            if (index === undefined || site === undefined) {
+                continue;
+            }
+            lookups.push({
+                file: site.file,
+                from: site.from,
+                at: call,
+                object: (objectAt < 0 ? undefined : call.arguments[objectAt]) ?? candidate.access.expression,
+                index,
+                use: candidate.use,
+            });
+        }
+    }
+    const nodes = lookups.flatMap((one) => [one.index, one.object]);
+    const types = queries.typesAt(nodes);
+    const typeOf = (node, at) => {
+        const type = types[at];
+        return nodes[at] === node && type !== UNANSWERED ? type : undefined;
+    };
+    // A type parameter's body serves every instantiation, so it reads what its constraint admits.
+    const keysOf = (type) => {
+        if (!type.isTypeParameter()) {
+            return type;
+        }
+        const constraint = queries.constraintOf(type);
+        return constraint === UNANSWERED || constraint === undefined ? type : constraint;
+    };
+    const partsOf = (type) => {
+        const parts = queries.constituents(type);
+        return parts === UNANSWERED ? [type] : parts;
+    };
+    const found = [];
+    lookups.forEach((lookup, at) => {
+        const indexType = typeOf(lookup.index, 2 * at);
+        const objectType = typeOf(lookup.object, 2 * at + 1);
+        const literals = indexType === undefined ? undefined : literalNames(partsOf(keysOf(indexType)));
+        if (objectType === undefined || literals === undefined) {
+            return;
+        }
+        const position = renderPosition(lookup.file, root, lookup.at.getStart());
+        for (const part of partsOf(objectType)) {
+            const properties = queries.propertiesOf(part);
+            for (const property of properties === UNANSWERED ? [] : properties) {
+                if (!literals.has(property.escapedName)) {
+                    continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                    for (const use of lookup.use === "both" ? ["read", "write"] : [lookup.use]) {
+                        found.push({
+                            from: lookup.from,
+                            to,
+                            position,
+                            use,
+                            resolution: "keyed",
+                            test: testFiles.has(position.path),
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return found;
+}
+/** The names a union of literal types spells, or none where a constituent is no string or number literal. */
+function literalNames(parts) {
+    const names = new Set();
+    for (const part of parts) {
+        if (part.isStringLiteralType()) {
+            names.add(part.value);
+        }
+        else if (part.isNumberLiteralType()) {
+            names.add(String(part.value));
+        }
+        else {
+            return undefined;
+        }
+    }
+    return names;
+}