@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.17

package/dist/src/overrides.js

@@ -24,121 +24,136 @@ function nameOf(entry) {
     }
     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, and each class makes to its members
- * that override a member of a class declared outside 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.
+ * The reads each base class member makes of its overrides, for the classes of the target that
+ * extend another class of the target, and each class makes of its members that override a
+ * member of a class declared outside the target. A member a nearer base already overrides is
+ * reached through that override. A private member is not overridden. Each read is placed at
+ * the override. A class whose base the checker leaves unanswered holds every member it could
+ * override.
  */
-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 outsideBases = new Map();
-    const own = project.ownPaths();
-    const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
-    classes.forEach(({ id }, index) => {
-        const symbol = symbols[index];
-        if (symbol !== undefined && symbol !== UNANSWERED) {
-            const inTarget = chains
-                .chainOf(symbol)
-                .map((target) => target.id)
-                .filter((target) => byId.get(target)?.kind === "class" && target !== id);
-            bases.set(id, inTarget);
-            const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
-            if (inTarget.length === 0 &&
-                declared !== UNANSWERED &&
-                (((declared.flags & SymbolFlags.Class) !== 0 &&
-                    // The target's augmentation of an outside class merges an interface into it,
-                    // so only a class declaration says where the class is.
-                    declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
-                    ((declared.flags & SymbolFlags.Interface) !== 0 &&
-                        declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
-                outsideBases.set(id, declared);
-            }
-        }
-    });
-    /** 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 = [];
-    const outsideNames = outsideMemberNames(project, bases, outsideBases);
-    for (const [classId, names] of outsideNames) {
-        for (const [component, member] of members.get(classId) ?? []) {
-            if (names.has(component)) {
-                found.push({
-                    from: classId,
-                    to: member.id,
-                    position: member.position,
-                    use: "read",
-                    resolution: "override",
-                    test: testFiles.has(member.position.path),
+export const overrides = {
+    start() {
+        const extending = [];
+        return {
+            visit(node, { file }) {
+                if (isClassDeclaration(node) || isClassExpression(node)) {
+                    const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
+                    const base = clause?.types[0];
+                    if (base !== undefined) {
+                        extending.push({ node, file, base: nameOf(base) });
+                    }
+                }
+            },
+            reads({ project, held, chains }) {
+                const found = [];
+                const classes = extending.flatMap((one) => {
+                    const id = held.declarations.get(nodeKey(one.file, one.node));
+                    return id === undefined ? [] : [{ ...one, id }];
                 });
-            }
-        }
-    }
-    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),
+                if (classes.length === 0) {
+                    return found;
+                }
+                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 outsideBases = new Map();
+                const fileOf = new Map(classes.map((one) => [one.id, one.file]));
+                const own = project.ownPaths();
+                const unanswered = new Set();
+                const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
+                classes.forEach(({ id }, index) => {
+                    const symbol = symbols[index];
+                    if (symbol === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (symbol === undefined) {
+                        return;
+                    }
+                    const inTarget = chains
+                        .chainOf(symbol)
+                        .map((target) => target.id)
+                        .filter((target) => byId.get(target)?.kind === "class" && target !== id);
+                    bases.set(id, inTarget);
+                    const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
+                    if (declared === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (inTarget.length === 0 &&
+                        (((declared.flags & SymbolFlags.Class) !== 0 &&
+                            // The target's augmentation of an outside class merges an interface into it,
+                            // so only a class declaration says where the class is.
+                            declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
+                            ((declared.flags & SymbolFlags.Interface) !== 0 &&
+                                declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
+                        outsideBases.set(id, declared);
+                    }
                 });
-            }
-        }
-    }
-    return found;
-}
+                /** 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 member = members.get(classId)?.get(component);
+                    if (member !== undefined) {
+                        return [member.id];
+                    }
+                    return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
+                };
+                const read = (classId, from, member) => {
+                    const file = fileOf.get(classId);
+                    if (file !== undefined) {
+                        found.push({
+                            kind: "named",
+                            from,
+                            to: member.id,
+                            file,
+                            at: member.position,
+                            use: "read",
+                            via: "override",
+                        });
+                    }
+                };
+                const outside = outsideMemberNames(project, bases, outsideBases);
+                for (const classId of [...unanswered, ...outside.unanswered]) {
+                    const ids = [...(members.get(classId)?.values() ?? [])].map((member) => member.id);
+                    found.push({ kind: "held", from: classId, ids });
+                }
+                for (const [classId, names] of outside.names) {
+                    for (const [component, member] of members.get(classId) ?? []) {
+                        if (names.has(component)) {
+                            read(classId, classId, member);
+                        }
+                    }
+                }
+                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))) {
+                            read(classId, base, member);
+                        }
+                    }
+                }
+                return found;
+            },
+        };
+    },
+};
 /**
  * Per class of the target with a class declared outside the target in its `extends`
  * chain, the member components that outside class's instances and constructor carry, a
@@ -146,10 +161,17 @@ export function overrideReferences(project, held, chains, testFiles) {
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
+    const unanswered = [];
     const error = errorType(project);
     for (const [classId, base] of outsideBases) {
         const instance = project.queries.declaredTypeOf(base);
         const statics = project.queries.typeOfSymbol(base);
+        if (instance === UNANSWERED ||
+            statics === UNANSWERED ||
+            project.queries.propertiesOf(instance) === UNANSWERED ||
+            (statics !== undefined && project.queries.propertiesOf(statics) === UNANSWERED)) {
+            unanswered.push(classId);
+        }
         const components = [
             ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
             ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
@@ -176,7 +198,7 @@ function outsideMemberNames(project, bases, outsideBases) {
             names.set(classId, found);
         }
     }
-    return names;
+    return { names, unanswered };
 }
 /** The global `Error` instance type's identifier, where the program's library declares one. */
 function errorType(project) {

package/dist/src/paths.js

@@ -8,6 +8,50 @@ const SEPARATOR = "/";
 export function isAbsolutePath(path) {
     return path.startsWith(SEPARATOR);
 }
+/** Whether a specifier starts a path relative to the file that writes it: `./` or `../`. */
+export function startsRelativePath(specifier) {
+    return specifier.startsWith("./") || specifier.startsWith("../");
+}
+/** Whether a specifier names a path relative to the file that writes it: `.`, `..`, `./` or `../` first. */
+export function isRelativeSpecifier(specifier) {
+    return specifier === "." || specifier === ".." || startsRelativePath(specifier);
+}
+/**
+ * Whether a module specifier names a path rather than a package, as the compiler reads one:
+ * a relative specifier or an absolute path.
+ */
+export function isPathSpecifier(specifier) {
+    return isRelativeSpecifier(specifier) || isAbsolutePath(specifier);
+}
+/**
+ * Whether a string starts with `./`, `../` or `/`, the specifiers a browser reads as a URL
+ * rather than a bare name, so a bare `.` or `..` stays a request:
+ * https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-url-like-module-specifier
+ */
+export function isExplicitPath(text) {
+    return startsRelativePath(text) || isAbsolutePath(text);
+}
+/**
+ * Whether a string starts with `.` or `/`, which no npm package name does, so a reader that
+ * takes any other string as a package's takes it as a path:
+ * https://docs.npmjs.com/cli/v11/configuring-npm/package-json#name
+ */
+export function cannotStartPackageName(text) {
+    return text.startsWith(".") || isAbsolutePath(text);
+}
+/** A URL scheme, `file:` and `node:` among them: https://url.spec.whatwg.org/#url-scheme-string */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
+/** Whether a string starts with a URL scheme. */
+export function hasURLScheme(text) {
+    return URL_SCHEME.test(text);
+}
+/**
+ * Whether a URL reference is a relative one that does not start with a solidus, the bare
+ * name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+export function isPathRelativeURL(reference) {
+    return reference !== "" && !reference.startsWith(SEPARATOR) && !hasURLScheme(reference);
+}
 /**
  * One path with `.` removed, `..` applied to the segment before it, and repeated
  * separators collapsed. A `..` that walks past the root of an absolute path is
@@ -88,17 +132,12 @@ export function extensionOf(path) {
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
-/**
- * A URL reference's scheme. A reference with none that does not start with a solidus is
- * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
- */
-const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 /**
  * The path a relative URL reference names against `dir`, its query and its fragment
  * removed, which name no part of the file; undefined where the reference is not relative.
  */
 export function relativeURLPath(dir, reference) {
-    if (reference === "" || reference.startsWith("/") || URL_SCHEME.test(reference)) {
+    if (!isPathRelativeURL(reference)) {
         return undefined;
     }
     const cut = reference.search(/[?#]/u);
@@ -112,7 +151,7 @@ export function relativeURLPath(dir, reference) {
  */
 export function queriedModulePath(specifier) {
     const query = specifier.indexOf("?");
-    if (query < 0 || !(specifier.startsWith("./") || specifier.startsWith("../"))) {
+    if (query < 0 || !startsRelativePath(specifier)) {
         return undefined;
     }
     const raw = specifier

package/dist/src/platform-calls.js

@@ -1,6 +1,6 @@
 /**
- * Which calls are the platform's `require` and which constructions its `URL` (roots.23,
- * references-ts.1), decided once over the bindings of the names a callee is written with: the
+ * Which calls are the platform's `require` or AMD's `define` and which constructions its `URL`
+ * (roots.23, references-ts.37, references-ts.1), decided once over the bindings of the names a callee is written with: the
  * checker's in a program, the file's own scopes in a module read outside every program.
  */
 import { isBindingElement, isCallExpression, isExportSpecifier, isIdentifier, isImportSpecifier, isPropertyAccessExpression, isStringLiteral, isVariableDeclaration, } from "@typescript/native/ast";

package/dist/src/platform-symbols.js

@@ -11,11 +11,10 @@ import { isAmbient } from "./inventory.js";
 import { callsPlatformBy, carriedNames } from "./platform-calls.js";
 import { unwrapped } from "./unwrap.js";
 /** The symbol one symbol names through its aliases, or the symbol itself where it is none. */
-function dealiased(project, symbol, asked) {
+function dealiased(project, symbol) {
     if ((symbol.flags & SymbolFlags.Alias) === 0) {
         return symbol;
     }
-    asked();
     return project.queries.aliased(symbol);
 }
 /** Each declaration of `symbol` in a file of the target, read in this project's program. */
@@ -50,7 +49,7 @@ function writesBody(node) {
  * prove it the target's own where one {@link writesBody}. A chain that ends at no
  * declaration, or that the checker leaves unanswered, reaches none.
  */
-function boundBy(project, symbol, asked) {
+function boundBy(project, symbol) {
     if (typeof symbol !== "object") {
         return undefined;
     }
@@ -66,28 +65,23 @@ function boundBy(project, symbol, asked) {
         if ((at.flags & SymbolFlags.Alias) === 0) {
             return { names, own, provenOwn: own.some(writesBody) };
         }
-        asked();
         const next = project.aliasStepOf(at);
         at = typeof next === "object" ? next : undefined;
     }
     return { names, own: [], provenOwn: false };
 }
 /** Each written name's binding, as this project's checker answers it. */
-function checkerBinding(project, asked) {
-    return (written) => {
-        asked();
-        return boundBy(project, project.symbolsAt([project.handle(written)])[0], asked);
-    };
+function checkerBinding(project) {
+    return (written) => boundBy(project, project.symbolsAt([project.handle(written)])[0]);
 }
 /**
  * Whether a call or construction through `callee`, the batch's answer for which is `symbol`,
- * is one of the platform's `require` or `URL` (roots.23, references-ts.1), as
- * {@link callsPlatformBy} decides it over this project's checker, each request it puts
- * counted by `asked`.
+ * is one of the platform's `require`, AMD's `define` or `URL` (roots.23, references-ts.37,
+ * references-ts.1), as {@link callsPlatformBy} decides it over this project's checker.
  */
-export function callsPlatform(project, name, callee, symbol, asked) {
-    const others = checkerBinding(project, asked);
-    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol, asked) : others(written));
+export function callsPlatform(project, name, callee, symbol) {
+    const others = checkerBinding(project);
+    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol) : others(written));
 }
 /**
  * Whether a worker's constructor or `navigator`, the batch's answer for which is `symbol`, is
@@ -122,16 +116,16 @@ function inThreadsModule(node) {
  * (references-ts.2): its symbol resolves to a declaration of `worker_threads`, or one of its
  * own declarations binds the module's `Worker`, or `holder`, the namespace it is read
  * through, binds the module, each binding read as {@link boundExports} reads one, which
- * decides where the module has no declaration. Each request it puts is counted by `asked`.
+ * decides where the module has no declaration.
  */
-export function startsThread(project, symbol, holder, asked) {
-    const bindingOf = checkerBinding(project, asked);
+export function startsThread(project, symbol, holder) {
+    const bindingOf = checkerBinding(project);
     const declared = (one, member) => typeof one === "object" &&
         ownDeclarations(project, one).some((node) => boundExports(node, (specifier) => THREADS.has(specifier), bindingOf).includes(member));
     if (declared(symbol, "Worker") || declared(holder, NAMESPACE)) {
         return true;
     }
-    const named = typeof symbol === "object" ? dealiased(project, symbol, asked) : undefined;
+    const named = typeof symbol === "object" ? dealiased(project, symbol) : undefined;
     return (typeof named === "object" &&
         named.declarations.some((handle) => {
             const node = project.declarationAt(handle)?.node;

package/dist/src/references/read-rule.js

@@ -0,0 +1 @@
+export {};

package/dist/src/references/read-rules.js

@@ -0,0 +1,48 @@
+import { elementAccess } from "../element-access.js";
+import { indexedAccess } from "../indexed-access.js";
+import { keyofComparisons } from "../keyof-comparisons.js";
+import { moduleDeclarations } from "../module-declarations.js";
+import { overrides } from "../overrides.js";
+import { isAnswered } from "../query.js";
+import { iteration } from "../symbol-keys.js";
+import { typeParameterReads } from "../type-parameter-reads.js";
+import { unimplementedCallees } from "../unimplemented-callees.js";
+/** The member kinds a hold of every member names. */
+const MEMBER_KINDS = new Set([
+    "method",
+    "class-member",
+    "interface-method",
+    "type-member",
+    "enum-member",
+]);
+/**
+ * Every read rule, each run over every side's walked files with the reference sources:
+ * a consumer's read of a target member is a reference as the target's own is.
+ */
+export const READ_RULES = [
+    overrides,
+    indexedAccess,
+    elementAccess,
+    keyofComparisons,
+    iteration,
+    typeParameterReads,
+    unimplementedCallees,
+    moduleDeclarations,
+];
+/** The declarations one hold names, with the declaration whose read it is. */
+export function heldBy(read, { project, held, chains }) {
+    const ids = [...(read.from === "" ? [] : [read.from]), ...(read.ids ?? [])];
+    for (const name of read.names ?? []) {
+        ids.push(...(held.byName.get(name) ?? []));
+    }
+    for (const type of read.types ?? []) {
+        const properties = project.queries.propertiesOf(type);
+        for (const property of isAnswered(properties) ? properties : []) {
+            ids.push(...chains.declarationsOf(property));
+        }
+    }
+    if (read.members === true) {
+        ids.push(...held.symbols.filter((one) => MEMBER_KINDS.has(one.kind)).map((one) => one.id));
+    }
+    return ids;
+}

package/dist/src/references/sink.js

@@ -0,0 +1,151 @@
+import { isBinaryExpression, isParenthesizedExpression, isPropertyAccessExpression, SyntaxKind, } from "@typescript/native/ast";
+import { bindingsOf } from "../import-bindings.js";
+import { byPosition, renderPosition } from "../position.js";
+import { bytewise } from "../text/compare.js";
+/**
+ * Where every reference of one pass is made: it renders the position against the side's
+ * root, takes the writing file's test class from the file classes, marks a use only a
+ * declaration's name answered `guessed` and an alias step's `alias`, tags a consumer's
+ * reference with the consumer, and orders the records.
+ */
+export class Sink {
+    #root;
+    #testFile;
+    #consumer;
+    #found = [];
+    #valued = new Map();
+    #held = new Set();
+    constructor(root, testFile, consumer) {
+        this.#root = root;
+        this.#testFile = testFile;
+        this.#consumer = consumer;
+    }
+    /** Whether a test file wrote one walked file's uses. */
+    isTest(file) {
+        return this.#testFile(file);
+    }
+    /** The position one node of a walked file renders at. */
+    position(file, at) {
+        return renderPosition(file, this.#root, at.getStart());
+    }
+    /**
+     * Records one use of each target, made by `from` at `at` in `file`. A write that stores
+     * `value` is remembered for the import bindings only its values use. A `production` use is
+     * production code's whoever writes it.
+     */
+    add(file, at, from, targets, use, via, value, production = false) {
+        const position = "column" in at ? at : this.position(file, at);
+        const test = !production && this.#testFile(file);
+        for (const one of targets) {
+            const target = typeof one === "string" ? { id: one } : one;
+            this.#found.push({
+                from,
+                to: target.id,
+                position,
+                use,
+                resolution: target.guessed === true ? "by-name" : target.stepped === true ? "alias" : via,
+                test,
+                ...(target.guessed === true ? { guessed: true } : {}),
+            });
+            if (use === "write" && value !== undefined) {
+                const valued = this.#valued.get(file) ?? [];
+                valued.push({ index: this.#found.length - 1, value });
+                this.#valued.set(file, valued);
+            }
+        }
+    }
+    /** Holds declarations an unanswered question could have made live, and the one whose read asked it. */
+    hold(ids) {
+        for (const id of ids) {
+            this.#held.add(id);
+        }
+    }
+    /** The records made so far, before {@link finish} orders them. */
+    get made() {
+        return this.#found;
+    }
+    /** Appends records another stage derived from these, rendered already. */
+    extend(references) {
+        this.#found.push(...references);
+    }
+    /**
+     * The records in position order, then the declaration named, the referencing declaration
+     * and the use, each write marked with the import bindings only its values use, and the
+     * held declarations. `usesOf` gives each walked file's name sites.
+     */
+    finish(usesOf) {
+        const found = this.#found;
+        for (const [file, writes] of this.#valued) {
+            for (const { index, names } of aloneIn(file, usesOf.get(file) ?? [], writes, found)) {
+                const reference = found[index];
+                if (reference !== undefined) {
+                    found[index] = { ...reference, alone: names };
+                }
+            }
+        }
+        found.sort((a, b) => byPosition(a.position, b.position) ||
+            bytewise(a.to, b.to) ||
+            bytewise(a.from, b.from) ||
+            bytewise(a.use, b.use));
+        const consumer = this.#consumer;
+        return {
+            references: consumer === undefined
+                ? found
+                : found.map((reference) => ({ ...reference, consumer: consumer.id })),
+            held: [...this.#held].sort(bytewise),
+        };
+    }
+}
+/** The value one assignment stores through the name it writes, where it is a plain assignment. */
+export function storedValue(name) {
+    let target = name;
+    if (isPropertyAccessExpression(name.parent) && name.parent.name === name) {
+        target = name.parent;
+    }
+    while (isParenthesizedExpression(target.parent)) {
+        target = target.parent;
+    }
+    const parent = target.parent;
+    return isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === target
+        ? parent.right
+        : undefined;
+}
+/**
+ * The import bindings of one file that only the values written into one declaration
+ * use, for each write into it. A binding is named by an identifier that spells its
+ * local name and is not the member a property access names.
+ */
+function aloneIn(file, uses, writes, found) {
+    const bindings = new Set(bindingsOf(file).map((binding) => binding.name.text));
+    if (bindings.size === 0) {
+        return [];
+    }
+    const occurrences = new Map();
+    for (const site of uses) {
+        const text = site.node.getText();
+        const parent = site.node.parent;
+        if (!bindings.has(text) || (isPropertyAccessExpression(parent) && parent.name === site.node)) {
+            continue;
+        }
+        if (!occurrences.get(text)?.includes(site.node)) {
+            occurrences.set(text, [...(occurrences.get(text) ?? []), site.node]);
+        }
+    }
+    const inside = (node, value) => node.pos >= value.pos && node.end <= value.end;
+    const result = [];
+    for (const write of writes) {
+        const to = found[write.index]?.to;
+        const sameTarget = writes.filter((one) => found[one.index]?.to === to);
+        const names = [...occurrences]
+            .filter(([, nodes]) => nodes.some((node) => inside(node, write.value)) &&
+            nodes.every((node) => sameTarget.some((one) => inside(node, one.value))))
+            .map(([name]) => name)
+            .sort(bytewise);
+        if (names.length > 0) {
+            result.push({ index: write.index, names });
+        }
+    }
+    return result;
+}