@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/dist/src/position.js

@@ -1,4 +1,5 @@
 import { relativePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
 /**
  * A file the program holds whose path is not below the target root, which leaves
  * the analysis unable to name a declaration it found. It ends the run rather than
@@ -24,6 +25,47 @@ export function isComponentFile(file) {
 export function writtenLength(file) {
     return isComponentFile(file) ? file.originalText.length : file.text.length;
 }
+/** Whether one character ends a line, under the language's line terminators. */
+function endsLine(char) {
+    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
+}
+/** The offset where the line holding `from` ends. */
+export function lineEnd(text, from) {
+    let at = from;
+    while (at < text.length && !endsLine(text[at])) {
+        at += 1;
+    }
+    return at;
+}
+/**
+ * The offset of the first token at or after `from`: whitespace, comments and a leading
+ * hashbang are trivia.
+ */
+export function tokenStart(text, from) {
+    let at = from;
+    if (at === 0 && text.startsWith("#!")) {
+        at = lineEnd(text, 0);
+    }
+    for (;;) {
+        if (/\s/u.test(text[at] ?? "")) {
+            at += 1;
+        }
+        else if (text.startsWith("//", at)) {
+            at = lineEnd(text, at);
+        }
+        else if (text.startsWith("/*", at)) {
+            const close = text.indexOf("*/", at + 2);
+            at = close < 0 ? text.length : close + 2;
+        }
+        else {
+            return at;
+        }
+    }
+}
+/** The line, counted from one, of the first token at or after one offset of one file. */
+export function startLine(file, offset) {
+    return file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+}
 /**
  * The position of one offset of one file, rendered against the target root.
  *
@@ -58,7 +100,7 @@ export function positionKey(position) {
  */
 export function byPosition(a, b) {
     if (a.path !== b.path) {
-        return a.path < b.path ? -1 : 1;
+        return bytewise(a.path, b.path);
     }
     if (a.line !== b.line) {
         return a.line - b.line;

package/dist/src/print.js

@@ -1,83 +1,15 @@
-import { renderOrigin, } from "./config.js";
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return { symbol: entry.symbol };
-        case "module":
-            return { module: entry.module, name: entry.name };
-        case "global":
-            return { global: entry.global };
-    }
-}
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry) {
-    const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-    if (entry.shape === "installed") {
-        return installed;
-    }
-    return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin } from "./config.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
 export function printConfig(config, provenance) {
-    const document = {
-        contract_version: config.contractVersion,
-        target: { kind: config.targetKind },
-        analysis: {
-            languages: config.analysis.languages,
-            min_confidence: config.analysis.minConfidence,
-            generated_files: config.analysis.generatedFiles,
-            consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
-                ? { id: entry.id, project: entry.project }
-                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
-            matrix: { complete: config.analysis.matrixComplete },
-            template_dirs: config.analysis.templateDirs,
-            template_delimiters: {
-                left: config.analysis.templateDelimiters.left,
-                right: config.analysis.templateDelimiters.right,
-            },
-        },
-        consumers: { complete: config.consumersComplete },
-        roots: { patterns: config.rootPatterns },
-        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-        exemptions: { disabled: config.exemptionsDisabled },
-        reporters: {
-            formats: config.reporters.formats,
-            sort: config.reporters.sort,
-            cascade: config.reporters.cascade,
-            max_findings: config.reporters.maxFindings,
-            fail_on: config.reporters.failOn,
-        },
-        providers: { analyzers: config.providers.analyzers.map(providerOf) },
-        go: {},
-        ts: {
-            test_files: config.ts.testFiles,
-            entry_files: config.ts.entryFiles,
-            component_extensions: config.ts.componentExtensions,
-            disabled_conventions: config.ts.disabledConventions,
-            injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-            lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-                components: entry.components.map(declarationOf),
-                bases: entry.bases.map(declarationOf),
-                members: entry.members,
-            })),
-            serializers: config.ts.serializers.map(declarationOf),
-            roots_complete: config.ts.rootsComplete,
-        },
-        provenance: Object.fromEntries([...provenance]
-            .sort(([a], [b]) => (a < b ? -1 : 1))
-            .map(([path, origin]) => [path, renderOrigin(origin)])),
-    };
-    return `${JSON.stringify(document, undefined, 2)}\n`;
+    const origins = [...provenance]
+        .sort(([a], [b]) => bytewise(a, b))
+        .map(([path, origin]) => [path, renderOrigin(origin)]);
+    return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/dist/src/product.js

@@ -0,0 +1,13 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err, text) {
+    err.write(`${PRODUCT}: ${text}\n`);
+}
+/** The text one thrown value carries. */
+export function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/query.js

@@ -7,6 +7,7 @@
  * form where it has one and otherwise as one batch, one round trip per capped run.
  */
 import { isIdentifier } from "@typescript/native/ast";
+import { IndexKind, } from "@typescript/native/sync";
 /**
  * The greatest number of locations one batched request asks about. A batch is
  * answered by an array of its own length, so an uncapped batch over a large file
@@ -88,6 +89,71 @@ export function propertyTables(queries) {
         },
     };
 }
+/** How to read the types one type is spelled from, as {@link Queries.partsOf} names them. */
+function partQuestion(type) {
+    if (type.isTypeParameter()) {
+        return () => [type.getConstraint(), type.getDefault()];
+    }
+    if (type.isConditionalType()) {
+        return () => [
+            type.getCheckType(),
+            type.getExtendsType(),
+            type.getTrueType(),
+            type.getFalseType(),
+        ];
+    }
+    if (type.isMappedType()) {
+        return () => [type.getConstraintType(), type.getNameType(), type.getTemplateType()];
+    }
+    if (type.isIndexedAccessType()) {
+        return () => [type.getObjectType(), type.getIndexType()];
+    }
+    if (type.isIndexType() || type.isStringMappingType()) {
+        return () => [type.getTarget()];
+    }
+    if (type.isTemplateLiteralType()) {
+        return () => type.getTypes();
+    }
+    if (type.isSubstitutionType()) {
+        return () => [type.getBaseType(), type.getConstraint()];
+    }
+    return undefined;
+}
+/** How deep {@link mappedParameters} reads, as a recursive mapped type makes a new one at each level. */
+const MAPPED_DEPTH = 4;
+/** The type parameters a mapped type is over, as {@link Queries.mappedParametersOf} names them. */
+function mappedParameters(checker, mapped) {
+    const own = new Set();
+    const found = new Map();
+    const seen = new Set();
+    const visit = (type, depth) => {
+        if (depth > MAPPED_DEPTH || seen.has(type.id)) {
+            return;
+        }
+        seen.add(type.id);
+        if (type.isMappedType()) {
+            own.add(type.getTypeParameter().id);
+        }
+        if (type.isTypeParameter() && !type.isThisType) {
+            found.set(type.id, type);
+        }
+        const aliased = type
+            .aliasTypeArguments;
+        const inner = [
+            ...(type.isUnionType() || type.isIntersectionType() ? type.getTypes() : []),
+            ...(type.isTypeReference() ? checker.getTypeArguments(type) : []),
+            ...(aliased === undefined || aliased.length === 0 ? [] : type.getAliasTypeArguments()),
+            ...(partQuestion(type)?.() ?? []),
+        ];
+        for (const part of inner) {
+            if (part !== undefined) {
+                visit(part, depth + 1);
+            }
+        }
+    };
+    visit(mapped, 0);
+    return [...found.values()].filter((parameter) => !own.has(parameter.id));
+}
 /**
  * The guarded questions over one project's checker. `configFile` names the project
  * in the log, `batch` sends many questions in one round trip, `log` is the run's,
@@ -214,17 +280,46 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         constraintOf: (type) => type.isTypeParameter()
             ? one("getConstraint", () => typeLocation(type), () => type.getConstraint())
             : undefined,
+        baseConstraintOf: (type) => one("getBaseConstraintOfType", () => typeLocation(type), () => checker.getBaseConstraintOfType(type)),
         indexedAccessOf: (type) => type.isIndexedAccessType()
             ? one("getObjectType", () => typeLocation(type), () => ({ object: type.getObjectType(), index: type.getIndexType() }))
             : undefined,
+        partsOf: (type) => {
+            const parts = partQuestion(type);
+            return parts === undefined
+                ? []
+                : one("getParts", () => typeLocation(type), () => parts().filter((part) => part !== undefined));
+        },
+        signaturePartsOf: (signature) => one("getSignatureParts", () => `signature ${String(signature.id)}`, () => {
+            const self = signature.thisParameter === undefined ? undefined : signature.getThisParameter();
+            return [
+                ...((signature.typeParameters ?? []).length === 0 ? [] : signature.getTypeParameters()),
+                self === undefined ? undefined : checker.getTypeOfSymbol(self),
+                checker.getTypePredicateOfSignature(signature)?.type,
+            ].filter((part) => part !== undefined);
+        }),
         symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
+        aliasSymbolOf: (type) => one("getAliasSymbol", () => typeLocation(type), () => type.getAliasSymbol()),
+        aliasArgumentsOf: (type) => one("getAliasTypeArguments", () => typeLocation(type), () => type.getAliasTypeArguments()),
         signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
         resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),
+        resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) => each("getResolvedSignature", nodes, cap, nodeLocation, (node) => checker.getResolvedSignature.gen(node), (node) => checker.getResolvedSignature(node)),
         parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
         genericOf: (signature) => signature.target === undefined
             ? undefined
             : one("getTarget", () => `signature ${String(signature.id)}`, () => signature.getTarget()),
         typeAtPosition: (signature, index) => one("getTypeParameterAtPosition", () => `signature ${String(signature.id)} position ${String(index)}`, () => signature.getTypeParameterAtPosition(index)),
+        restTypeOf: (signature) => signature.hasRestParameter
+            ? one("getTypeOfSymbol", () => `signature ${String(signature.id)} rest parameter`, () => {
+                const rest = signature.getParameters().at(-1);
+                return rest === undefined ? undefined : checker.getTypeOfSymbol(rest);
+            })
+            : undefined,
+        numberIndexOf: (type) => one("getIndexTypeOfType", () => typeLocation(type), () => checker.getIndexTypeOfType(type, IndexKind.Number)),
+        mappedParametersOf: (type) => type.isMappedType()
+            ? one("getConstraintType", () => typeLocation(type), () => mappedParameters(checker, type))
+            : [],
+        propertyTypeOf: (type, name) => one("getTypeOfPropertyOfType", () => `${typeLocation(type)} property ${name}`, () => checker.getTypeOfPropertyOfType(type, name)),
         signatureOf: (declaration) => one("getSignatureFromDeclaration", () => nodeLocation(declaration), () => checker.getSignatureFromDeclaration(declaration)),
         returnTypeOf: (signature) => one("getReturnTypeOfSignature", () => `signature ${String(signature.id)}`, () => checker.getReturnTypeOfSignature(signature)),
         typeToString: (type) => one("typeToString", () => typeLocation(type), () => checker.typeToString(type)),

package/dist/src/ref.js

@@ -1,13 +1,9 @@
 /**
- * The stable symbol reference: the identifier that names one declaration across
- * runs, across reports, in an ignore entry, in a configured root and in a
- * cross-language edge. It is built from names and containers only, so an edit above
- * a declaration leaves it unchanged, and it is compared as bytes, so there is one
- * canonical spelling per declaration and this module is where that spelling is
- * written.
- *
- * The position key of {@link ./position.ts} is the other identifier and has the
- * other job: it locates a finding inside one run, and the two never mix.
+ * The stable symbol reference: the identifier that names one declaration across runs,
+ * reports, ignore entries, configured roots and cross-language edges. It is built from
+ * names and containers only, so an edit above a declaration leaves it unchanged, and it
+ * is compared as bytes, so this module writes the one canonical spelling. The position
+ * key of {@link ./position.ts} locates a finding inside one run; the two never mix.
  */
 /** The language prefix, which namespaces every reference this analyzer emits. */
 const PREFIX = "ts://";
@@ -30,16 +26,10 @@ const TS_FILE = String.raw `${TS_DIRS}[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc
 const SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_FILE}`;
 const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_DIRS}package\\.json`;
 /**
- * One expression per form the grammar defines, each anchored and each the whole of
- * a reference. Several forms share one expression because they differ in what the
- * symbol is rather than in how the reference is spelled, so the list is the set of
- * spellings and not the set of subjects. A reference is valid when it matches one.
- *
- * They are written here rather than read from the Contract at run time: the Contract
- * is data a reader outside this program consults, and a product that read it while
- * running would need it installed beside itself. A test compares this list against
- * the release this analyzer is written against, so a grammar that grows a form
- * arrives here as a failing test.
+ * One anchored expression per spelling the grammar defines; a reference is valid when it
+ * matches one. They are written here rather than read from the Contract at run time, so
+ * the product needs no Contract installed beside it; a test compares this list against
+ * the release this analyzer implements, so a grammar that grows a form fails it.
  */
 export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
@@ -48,6 +38,7 @@ export const REF_EXPRESSIONS = [
     `^${SCOPE}#${TS_HEAD}:import$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
+    `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+\\.${TS_QUOTED}:case$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
     `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
     `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
@@ -101,7 +92,8 @@ export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;
     return `${head}${nameComponent(name)}:alias`;
 }
-function spell(component) {
+/** The canonical spelling of one component: a name, or a computed key. */
+export function spell(component) {
     return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
 /**

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,237 @@
+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 = [];
+    #declaredAt;
+    #valued = new Map();
+    #named = new Map();
+    #held = new Set();
+    constructor(root, testFile, consumer, declaredAt) {
+        this.#root = root;
+        this.#testFile = testFile;
+        this.#consumer = consumer;
+        this.#declaredAt = declaredAt;
+    }
+    /** 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 (this.#consumer === undefined && !("column" in at)) {
+                const named = this.#named.get(file) ?? [];
+                named.push({ index: this.#found.length - 1, at, annotated: this.#annotates(at, from) });
+                this.#named.set(file, named);
+            }
+            if (use === "write" && value !== undefined) {
+                const valued = this.#valued.get(file) ?? [];
+                valued.push({ index: this.#found.length - 1, value });
+                this.#valued.set(file, valued);
+            }
+        }
+    }
+    /**
+     * Whether a name sits in the annotation of `from`'s own declaration. An annotation holds
+     * no block, so the walk stops at the first declaration or block above the name.
+     */
+    #annotates(name, from) {
+        if (name.kind === SyntaxKind.SourceFile) {
+            return false;
+        }
+        let child = name;
+        let parent = name.parent;
+        while (parent.kind !== SyntaxKind.Block && parent.kind !== SyntaxKind.SourceFile) {
+            const id = this.#declaredAt(parent);
+            if (id !== undefined) {
+                return id === from && parent.type === child;
+            }
+            child = parent;
+            parent = parent.parent;
+        }
+        return false;
+    }
+    /** 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 };
+                }
+            }
+        }
+        for (const [file, named] of this.#named) {
+            for (const { index, carriers } of carriersIn(named, this.#valued.get(file) ?? [], found)) {
+                const reference = found[index];
+                if (reference !== undefined) {
+                    found[index] = { ...reference, carriers };
+                }
+            }
+        }
+        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;
+}
+/**
+ * The carriers of each named record of one file: `from` where its own annotation holds the
+ * name, then the target of each write whose stored value holds it and that names another
+ * declaration, the innermost value first. Values nest or are disjoint.
+ */
+function carriersIn(named, writes, found) {
+    const byStart = [...named].sort((a, b) => a.at.pos - b.at.pos);
+    const holding = new Map();
+    for (const write of writes) {
+        let low = 0;
+        let high = byStart.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if ((byStart[middle]?.at.pos ?? 0) < write.value.pos) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        for (let at = low; at < byStart.length; at += 1) {
+            const one = byStart[at];
+            if (one === undefined || one.at.pos >= write.value.end) {
+                break;
+            }
+            if (one.at.end <= write.value.end) {
+                holding.set(one.index, [...(holding.get(one.index) ?? []), write]);
+            }
+        }
+    }
+    const result = [];
+    for (const one of named) {
+        const reference = found[one.index];
+        if (reference === undefined) {
+            continue;
+        }
+        const carriers = one.annotated ? [reference.from] : [];
+        const values = [...(holding.get(one.index) ?? [])].sort((a, b) => a.value.end - a.value.pos - (b.value.end - b.value.pos));
+        for (const write of values) {
+            const to = found[write.index]?.to;
+            if (to !== undefined && to !== reference.to && !carriers.includes(to)) {
+                carriers.push(to);
+            }
+        }
+        if (carriers.length > 0) {
+            result.push({ index: one.index, carriers });
+        }
+    }
+    return result;
+}