@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.4

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

package/dist/src/entry-points.js

@@ -10,8 +10,8 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";

package/dist/src/enum-group.js

@@ -6,8 +6,8 @@
  * or `unknown` expression asserted to it, or bound to a variable or returned from a
  * function it annotates, where a number counts too. An enum's own value converts nothing.
  */
-import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { TypeFlags } from "@typescript/native/unstable/sync";
+import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { TypeFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";

package/dist/src/erased-stores.js

@@ -0,0 +1,317 @@
+/**
+ * The values the program stores in a slot of a container: a property, an index signature,
+ * an array element, and a variable. A serializer walking the container emits the value the
+ * slot holds, so it walks each stored value at its own static type, a subtype stored where
+ * the slot's type names a supertype, `object`, `unknown` or `any` included. A container is
+ * identified by the checker's type identity, so two containers of one type share what
+ * either stores. A store into an erased property of a type the analyzed program does not
+ * declare hands the value to the code that declares the type.
+ */
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags, TypeFlags } from "@typescript/native/sync";
+import { must } from "./query.js";
+/** The types that keep nothing of the value they are given. */
+const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** The array methods whose arguments become elements of the array they are called on. */
+const ELEMENT_STORES = new Set(["push", "unshift"]);
+/** The name an element access's literal index spells, or none. */
+function literalKey(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node) || isNumericLiteral(node)
+        ? node.text
+        : undefined;
+}
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/**
+ * Whether a variable declaration's type can differ from what is stored in it: it carries an
+ * annotation, or it has neither an annotation nor an initializer, so its type evolves.
+ */
+function declaresSlot(node) {
+    const held = node;
+    return held.type !== undefined || held.initializer === undefined;
+}
+/** The element of an array literal at one place, where no spread before it moves the places. */
+function elementAt(source, at) {
+    if (!isArrayLiteralExpression(source)) {
+        return undefined;
+    }
+    const before = source.elements.slice(0, at + 1);
+    return before.some((one) => isSpreadElement(one)) ? undefined : source.elements[at];
+}
+/** The name a property spells, and none for a computed one. */
+function propertyName(name) {
+    return isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)
+        ? name.text
+        : undefined;
+}
+/** The name one property of an object literal spells and the expression it holds, or none. */
+function propertyParts(property) {
+    if (isPropertyAssignment(property)) {
+        const name = propertyName(property.name);
+        return name === undefined ? undefined : { name, value: property.initializer };
+    }
+    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+        return { name: property.name.text, value: property.name };
+    }
+    return undefined;
+}
+/** The value an object literal gives one property, where it gives it by a plain or a shorthand property. */
+function propertyAt(source, name) {
+    if (!isObjectLiteralExpression(source)) {
+        return undefined;
+    }
+    for (const property of source.properties) {
+        const parts = propertyParts(property);
+        if (parts?.name === name) {
+            return parts.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Every target one destructuring pattern writes at any depth, each with the expression
+ * whose value it receives: the matching element or property of a literal on the right,
+ * else the right side with the path into it. A rest element copies, so it is no target
+ * here, and a default value is stored in its target too.
+ */
+function patternTargets(pattern, from, out) {
+    const target = unwrapped(pattern);
+    const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+    const into = (element, step, literal) => {
+        patternTargets(element, literal === undefined
+            ? { value: from.value, path: [...from.path, step] }
+            : { value: literal, path: [] }, out);
+    };
+    if (isArrayLiteralExpression(target)) {
+        target.elements.forEach((element, at) => {
+            if (!isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression) {
+                into(element, at, from.path.length === 0 ? elementAt(source, at) : undefined);
+            }
+        });
+        return;
+    }
+    if (isObjectLiteralExpression(target)) {
+        for (const property of target.properties) {
+            const parts = propertyParts(property);
+            if (parts !== undefined) {
+                into(parts.value, parts.name, from.path.length === 0 ? propertyAt(source, parts.name) : undefined);
+            }
+            if (parts !== undefined &&
+                isShorthandPropertyAssignment(property) &&
+                property.objectAssignmentInitializer !== undefined) {
+                out.push({ target: parts.value, value: property.objectAssignmentInitializer, path: [] });
+            }
+        }
+        return;
+    }
+    if (isBinaryExpression(target) && target.operatorToken.kind === SyntaxKind.EqualsToken) {
+        patternTargets(target.left, from, out);
+        out.push({ target: target.left, value: target.right, path: [] });
+        return;
+    }
+    out.push({ target, ...from });
+}
+/** Every store one project's own files write, and the stores into variables declared erased. */
+export function erasedStores(project) {
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const stores = [];
+    const assigned = [];
+    const slotVariables = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isObjectLiteralExpression(node)) {
+                for (const property of node.properties) {
+                    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+                        const { name } = property;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: name.text,
+                            value: name,
+                            path: [],
+                        });
+                    }
+                    else if (isPropertyAssignment(property) &&
+                        (isIdentifier(property.name) || isStringLiteral(property.name))) {
+                        const value = property.initializer;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: property.name.text,
+                            value,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isArrayLiteralExpression(node)) {
+                for (const element of node.elements) {
+                    if (!isSpreadElement(element)) {
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: undefined,
+                            value: element,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.EqualsToken) {
+                const targets = [];
+                patternTargets(node.left, { value: node.right, path: [] }, targets);
+                for (const { target, value, path } of targets) {
+                    if (isPropertyAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: target.name.text,
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isElementAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: literalKey(target.argumentExpression),
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isIdentifier(target)) {
+                        assigned.push({ target, value, path });
+                    }
+                }
+            }
+            else if (isCallExpression(node) &&
+                isPropertyAccessExpression(node.expression) &&
+                ELEMENT_STORES.has(node.expression.name.text)) {
+                for (const argument of node.arguments) {
+                    stores.push({
+                        container: node.expression.expression,
+                        contextual: false,
+                        name: undefined,
+                        value: argument,
+                        path: [],
+                    });
+                }
+            }
+            else if (isVariableDeclaration(node) && declaresSlot(node)) {
+                slotVariables.push(node);
+                if (node.initializer !== undefined) {
+                    assigned.push({ target: node, value: node.initializer, path: [] });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const contextual = stores.filter((one) => one.contextual);
+    const contexts = queries.contextualTypes(contextual.map((one) => one.container)).map(must);
+    const containerOf = new Map(contextual.map((one, at) => [one, contexts[at]]));
+    const typed = stores.filter((one) => !one.contextual);
+    queries
+        .typesAt(typed.map((one) => one.container))
+        .map(must)
+        .forEach((type, at) => {
+        const one = typed[at];
+        if (one !== undefined) {
+            containerOf.set(one, type);
+        }
+    });
+    const slotTypes = new Map();
+    /** The type a slot of one object type holds: a property's, else the string index's, else an element's. */
+    const slotOf = (type, name) => {
+        const key = `${String(type.id)}\u0000${name ?? ""}`;
+        if (slotTypes.has(key)) {
+            return slotTypes.get(key);
+        }
+        let found;
+        const property = name === undefined
+            ? undefined
+            : must(queries.propertiesOf(type)).find((one) => one.name === name);
+        if (property !== undefined) {
+            found =
+                (property.flags & SymbolFlags.Property) !== 0
+                    ? must(queries.typeOfSymbol(property))
+                    : undefined;
+        }
+        else if (type.isTypeReference() && must(queries.isArray(type))) {
+            found = must(queries.typeArguments(type))[0];
+        }
+        else {
+            found = must(queries.indexInfosOf(type))[0]?.valueType;
+        }
+        slotTypes.set(key, found);
+        return found;
+    };
+    const declaredOutside = (type) => {
+        const symbol = must(queries.symbolOfType(type));
+        return (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path)));
+    };
+    /** The type of the part of a stored value its path names, a step at a time. */
+    const partOf = (type, path) => path.reduce((at, step) => (at === undefined ? undefined : slotOf(at, String(step))), type);
+    const valueTypes = queries
+        .typesAt(stores.map((one) => one.value))
+        .map((type, at) => partOf(must(type), stores[at]?.path ?? []));
+    const inside = new Map();
+    const outside = [];
+    stores.forEach((store, at) => {
+        const container = containerOf.get(store);
+        const value = valueTypes[at];
+        if (container === undefined || value === undefined) {
+            return;
+        }
+        const parts = container.isUnionType() || container.isIntersectionType()
+            ? must(queries.constituents(container))
+            : [container];
+        for (const part of parts) {
+            if (!part.isObjectType()) {
+                continue;
+            }
+            const { name } = store;
+            const erased = name !== undefined && ((slotOf(part, name)?.flags ?? 0) & ERASED) !== 0;
+            if (erased && declaredOutside(part)) {
+                outside.push({ value: store.value, type: value, property: name });
+            }
+            else {
+                inside.set(part.id, [...(inside.get(part.id) ?? []), value]);
+            }
+        }
+    });
+    const targets = assigned.map((one) => isVariableDeclaration(one.target) ? one.target.name : one.target);
+    const symbols = queries.symbolsAt(targets).map(must);
+    const slots = new Set(slotVariables);
+    const declarationOf = (symbol) => {
+        const handle = symbol?.valueDeclaration ?? symbol?.declarations[0];
+        return handle === undefined ? undefined : project.declarationAt(handle)?.node;
+    };
+    const assignedTypes = queries
+        .typesAt(assigned.map((one) => one.value))
+        .map((type, at) => partOf(must(type), assigned[at]?.path ?? []));
+    const byVariable = new Map();
+    assigned.forEach((_one, at) => {
+        const declaration = declarationOf(symbols[at]);
+        const type = assignedTypes[at];
+        if (declaration !== undefined && slots.has(declaration) && type !== undefined) {
+            byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), type]);
+        }
+    });
+    return {
+        inside: (type) => inside.get(type.id) ?? [],
+        ofVariable: (node) => {
+            if (byVariable.size === 0 || !isIdentifier(node)) {
+                return undefined;
+            }
+            const [symbol] = queries.symbolsAt([node]).map(must);
+            const declaration = declarationOf(symbol);
+            return declaration === undefined ? undefined : byVariable.get(declaration);
+        },
+        outside,
+    };
+}