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

package/dist/src/query.js

@@ -88,6 +88,36 @@ 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;
+}
 /**
  * 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,
@@ -217,7 +247,23 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         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)),

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;
+}