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

package/dist/src/exemptions/calls.js

@@ -0,0 +1,338 @@
+/**
+ * The calls and decorators of one project that the configured classes read: what each
+ * call invokes, a call through a method of `Function.prototype` included, and which of the
+ * target's classes a call passes or a decorator is attached to. A class is passed by each
+ * value an argument can carry ({@link carriedValues}), named directly or through
+ * variables, and a decorator written as a call is a call.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isBindingElement, isCallExpression, isDecorator, isFunctionDeclaration, isFunctionExpression, isIdentifier, isMethodDeclaration, isParameterDeclaration, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, } from "@typescript/native/ast";
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
+import { resolvedTargets } from "../alias-chain.js";
+import { carriedValues, nameOf } from "../index/values.js";
+import { must } from "../query.js";
+import { parenthesesRemoved, unwrapped } from "../unwrap.js";
+/** The callee one decorator names: its expression, or the callee of the call it writes. */
+export function decoratorCallee(decorator) {
+    const expression = decorator.expression;
+    return nameOf(isCallExpression(expression) ? expression.expression : expression);
+}
+/** How one decorator is spelled in a record: its expression, without a call's arguments. */
+export function spelledDecorator(decorator) {
+    const expression = decorator.expression;
+    const named = isCallExpression(expression) ? expression.expression : expression;
+    return `@${named.getText().replace(/\s+/gu, "")}`;
+}
+/** The decorators written on one declaration. */
+export function decoratorsOf(node) {
+    return (node.modifiers ?? []).filter(isDecorator);
+}
+/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
+const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
+/** The interfaces of the standard library that declare those methods for a function value. */
+const FUNCTION_INTERFACES = new Set([
+    "Function",
+    "CallableFunction",
+    "NewableFunction",
+]);
+/**
+ * The invocation a call writes through a method of `Function.prototype`, read from
+ * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
+ * passes `a` though nothing calls the bound function there, because the bound function
+ * carries `a` to wherever it is called and that call is not followed, and
+ * `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
+ * that is no array literal is the value of the first parameter, whose elements it
+ * carries. Whether the method is the prototype's is resolution's to say.
+ */
+function throughMethod(call) {
+    const expression = parenthesesRemoved(call.expression);
+    if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
+        const [, ...rest] = call.arguments;
+        let passed = rest;
+        let listed = false;
+        if (expression.name.text === "apply") {
+            const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
+            listed = list !== undefined && !isArrayLiteralExpression(list);
+            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
+        }
+        return {
+            method: expression.name,
+            invocation: { callee: expression.expression, arguments: passed, indirect: true, listed },
+        };
+    }
+    if (isCallExpression(expression)) {
+        const bound = parenthesesRemoved(expression.expression);
+        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
+            return {
+                method: bound.name,
+                invocation: {
+                    callee: bound.expression,
+                    arguments: [...expression.arguments.slice(1), ...call.arguments],
+                    indirect: true,
+                    listed: false,
+                },
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * What each of a project's calls invokes. A call through `call`, `apply` or `bind`
+ * invokes the function the method is read from only where the method is the standard
+ * library's: the program's own `call` and `Reflect.apply` pass nothing on.
+ */
+export function invocations(project, calls) {
+    const forms = new Map();
+    for (const call of calls) {
+        const form = throughMethod(call);
+        if (form !== undefined) {
+            forms.set(call, form);
+        }
+    }
+    const callees = resolvedTargets(project, [
+        ...calls.flatMap((call) => nameOf(call.expression) ?? []),
+        ...[...forms.values()].flatMap((form) => {
+            const name = nameOf(form.invocation.callee);
+            return name === undefined ? [form.method] : [form.method, name];
+        }),
+    ]);
+    const standard = (method) => method.declarations.some((handle) => project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true) && FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "");
+    const of = (call) => {
+        const form = forms.get(call);
+        const method = form === undefined ? undefined : callees.get(form.method);
+        return form !== undefined && method !== undefined && standard(method)
+            ? form.invocation
+            : { callee: call.expression, arguments: call.arguments, indirect: false, listed: false };
+    };
+    return {
+        of,
+        callee: (call) => {
+            const name = nameOf(of(call).callee);
+            return name === undefined ? undefined : callees.get(name);
+        },
+    };
+}
+/** The declaration a shorthand property's value resolves to, an import followed to what it names. */
+function shorthandTarget(project, node) {
+    const value = must(project.shorthandValueAt(project.handle(node)));
+    if (value === undefined || (value.flags & SymbolFlags.Alias) === 0) {
+        return value;
+    }
+    const aliased = must(project.queries.aliased(value));
+    return aliased.declarations.length === 0 ? undefined : aliased;
+}
+/**
+ * What one carried value holds: the declaration its name resolves to, and the classes and
+ * functions the checker's type at it holds ({@link constructedAt}). `known` holds names
+ * already resolved in a batch.
+ */
+function heldBy(project, value, known) {
+    const { name } = value;
+    if (name === undefined) {
+        return { named: undefined, typed: constructedAt(project, value.site) };
+    }
+    if (value.shorthand) {
+        return { named: shorthandTarget(project, name), typed: [] };
+    }
+    return {
+        named: known?.get(name) ?? resolvedTargets(project, [name]).get(name),
+        typed: constructedAt(project, value.site),
+    };
+}
+/** The classes of the target each call passes, by the call, as {@link classesCarried} reads its invocation's arguments. */
+export function classesPassed(project, held, chains, sites, calls) {
+    const carried = classesCarried(project, held, chains, sites, calls.map((call) => sites.invocations.of(call).arguments));
+    return new Map(calls.map((call, at) => [call, carried[at] ?? []]));
+}
+/**
+ * The classes of the target each group of written values carries: each class a value
+ * can carry holds as a constructor, as the checker types it. A name whose type erases
+ * the class is followed through what its declaration binds ({@link boundTo}) and, for a
+ * parameter, through what each call of its function passes at its place, so a class
+ * handed to a wrapper is passed. A class is used at each value that carries it. A class
+ * of another program is carried by nothing.
+ */
+export function classesCarried(project, held, chains, sites, groups) {
+    const { invocations: invoked } = sites;
+    const passed = groups.map((written) => written.flatMap(carriedValues));
+    const targets = resolvedTargets(project, passed.flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))));
+    const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
+    let calling;
+    const callsOfFunction = (symbol) => {
+        calling ??= callsByDeclaration(project, sites.calls.map((one) => one.call), invoked);
+        return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
+    };
+    const classesOf = (value, seen) => {
+        const { named, typed } = heldBy(project, value, targets);
+        return [
+            ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
+            ...(named === undefined ? [] : reached(named, seen)),
+        ];
+    };
+    const reached = (symbol, seen) => {
+        const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
+        if (ids.length > 0 || seen.has(symbol.id)) {
+            return ids;
+        }
+        seen.add(symbol.id);
+        const through = (written) => carriedValues(written).flatMap((value) => classesOf(value, seen));
+        return symbol.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined) {
+                return [];
+            }
+            if (isParameterDeclaration(node)) {
+                return argumentsAt(project, node, callsOfFunction, invoked).flatMap(through);
+            }
+            const bound = boundTo(project, node);
+            return [
+                ...(bound.written === undefined ? [] : through(bound.written)),
+                ...bound.symbols.flatMap((next) => reached(next, seen)),
+            ];
+        });
+    };
+    return passed.map((values) => {
+        const uses = new Map();
+        for (const value of values) {
+            for (const id of classesOf(value, new Set())) {
+                uses.set(`${id}\u0000${String(value.site.pos)}`, { id, site: value.site });
+            }
+        }
+        return [...uses.values()];
+    });
+}
+/**
+ * The symbols of the classes and functions the checker's type at one expression holds as
+ * values, each member of a union: the static side of a class or a function is an
+ * anonymous type its declaration's symbol names, which an instance's type is not.
+ */
+function constructedAt(project, written) {
+    return heldIn(project, must(project.queries.typeAt(unwrapped(written))));
+}
+/** The classes and functions one type holds as values, as {@link constructedAt} reads them. */
+function heldIn(project, type) {
+    const { queries } = project;
+    return (type === undefined ? [] : must(queries.constituents(type))).flatMap((part) => {
+        if (!part.isObjectType() || (part.objectFlags & ObjectFlags.Anonymous) === 0) {
+            return [];
+        }
+        return must(queries.symbolOfType(part)) ?? [];
+    });
+}
+/**
+ * What a variable, a property or a destructured binding binds its name to: a variable's
+ * or a property's initializer, the value a shorthand property names, or the property of
+ * the destructured value a binding element reads.
+ */
+function boundTo(project, node) {
+    if (isShorthandPropertyAssignment(node)) {
+        const value = shorthandTarget(project, node);
+        return { symbols: value === undefined ? [] : [value] };
+    }
+    if (isBindingElement(node)) {
+        const key = node.propertyName ?? node.name;
+        if (key === undefined || !isIdentifier(key)) {
+            return { symbols: [] };
+        }
+        const source = must(project.queries.typeAt(node.parent));
+        const property = source === undefined
+            ? undefined
+            : must(project.queries.propertiesOf(source)).find((one) => one.name === key.text);
+        return { symbols: property === undefined ? [] : [property] };
+    }
+    const written = initializerOf(node);
+    return written === undefined ? { symbols: [] } : { written, symbols: [] };
+}
+/** The value a variable or a property declaration binds its name to, where it writes one. */
+function initializerOf(node) {
+    return isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)
+        ? node.initializer
+        : undefined;
+}
+/** The key of one declaration a symbol names, the same for each symbol the checker makes of it. */
+function keyOf(handle) {
+    return `${handle.path}#${String(handle.index)}`;
+}
+/**
+ * Every call of the project by the declarations its invoked function can be: the function
+ * or the method it names, or else each function the checker's type at it holds, wherever
+ * that value came from. A name is also followed through what its binding copies
+ * ({@link boundTo}), which is how a call reaches a function an annotation erases.
+ * Only the target's own declarations are keys, as only its own functions are asked for.
+ */
+function callsByDeclaration(project, calls, invoked) {
+    const own = project.ownPaths();
+    const named = new Map();
+    const keysOf = (symbol, seen) => {
+        const known = named.get(symbol.id);
+        if (known !== undefined || seen.has(symbol.id)) {
+            return known ?? [];
+        }
+        seen.add(symbol.id);
+        const keys = symbol.declarations
+            .filter((handle) => own.has(handle.path))
+            .flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
+            const copied = [
+                ...bound.symbols,
+                ...(bound.written === undefined ? [] : carriedValues(bound.written)).flatMap((value) => {
+                    const { named: next, typed } = heldBy(project, value);
+                    return [...typed, ...(next === undefined ? [] : [next])];
+                }),
+            ];
+            return [keyOf(handle), ...copied.flatMap((next) => keysOf(next, seen))];
+        });
+        named.set(symbol.id, keys);
+        return keys;
+    };
+    const declared = (call) => ((invoked.callee(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+    const typed = calls.filter((call) => !declared(call));
+    const types = new Map(project.queries
+        .typesAt(typed.map((call) => unwrapped(invoked.of(call).callee)))
+        .map((type, index) => [typed[index], must(type)]));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = invoked.callee(call);
+        const held = [
+            ...(callee === undefined ? [] : [callee]),
+            ...(types.has(call) ? heldIn(project, types.get(call)) : []),
+        ];
+        for (const key of new Set(held.flatMap((symbol) => keysOf(symbol, new Set())))) {
+            found.set(key, [...(found.get(key) ?? []), call]);
+        }
+    }
+    return found;
+}
+/**
+ * What each call of the function a parameter belongs to passes at the parameter's place,
+ * every argument from there on for a rest parameter, as the call's invocation binds them.
+ * The function is the one the checker's type at its own declaration names, so a function
+ * with no name of its own is called too. A `this` parameter takes no place, and an
+ * argument at or after a spread argument passes at every place the spread's length can
+ * move it to.
+ */
+function argumentsAt(project, parameter, callsOfFunction, invoked) {
+    const owner = parameter.parent;
+    if (!isFunctionDeclaration(owner) &&
+        !isMethodDeclaration(owner) &&
+        !isArrowFunction(owner) &&
+        !isFunctionExpression(owner)) {
+        return [];
+    }
+    const calls = new Set(constructedAt(project, owner).flatMap(callsOfFunction));
+    const [first] = owner.parameters;
+    const erased = first !== undefined && isIdentifier(first.name) && first.name.text === "this";
+    const place = owner.parameters.indexOf(parameter) - (erased ? 1 : 0);
+    const rest = parameter.dotDotDotToken !== undefined;
+    return [...calls].flatMap((call) => {
+        let spreads = 0;
+        return invoked.of(call).arguments.flatMap((argument, index) => {
+            const spread = isSpreadElement(argument);
+            const earliest = index - spreads;
+            spreads += spread ? 1 : 0;
+            const open = spread || earliest < index;
+            const lands = open ? rest || earliest <= place : rest ? index >= place : index === place;
+            return lands ? [spread ? argument.expression : argument] : [];
+        });
+    });
+}

package/dist/src/exemptions/classes.js

@@ -0,0 +1,13 @@
+import { EXEMPTION_CLASSES } from "../contract/contract.generated.js";
+function runsOnTS(row) {
+    const languages = row.languages;
+    return languages.includes("ts");
+}
+const TS_ROWS = EXEMPTION_CLASSES.filter(runsOnTS);
+/** The classes that run on TypeScript, in the vocabulary's order. */
+export const TS_EXEMPTION_CLASSES = TS_ROWS.map((row) => row.class);
+const VISIBILITY = new Map(TS_ROWS.map((row) => [row.class, row.typescriptVisibility]));
+/** Which private members one class that runs on TypeScript may retain. */
+export function typescriptVisibilityOf(exemptionClass) {
+    return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
+}

package/dist/src/{decorator.js → exemptions/decorator.js}

@@ -7,8 +7,8 @@
  * static members of a decorated class included.
  */
 import { decoratorsOf, spelledDecorator } from "./calls.js";
-import { isParameterProperty, nodeKey, } from "./inventory.js";
-import { renderPosition } from "./position.js";
+import { isParameterProperty } from "../inventory.js";
+import { renderPosition } from "../position.js";
 /** The kinds of declaration a decorator is attached to and holds back. */
 const DECORATED = new Set(["class", "method", "class-member"]);
 /**
@@ -16,7 +16,7 @@ const DECORATED = new Set(["class", "method", "class-member"]);
  * class, recorded at the decorator.
  */
 export function decorator(input) {
-    const { project, held, targetRoot } = input;
+    const { held, sites, targetRoot } = input;
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
     const membersOf = new Map();
     for (const symbol of held.symbols) {
@@ -30,32 +30,21 @@ export function decorator(input) {
             }
         }
     }
-    const decorated = [];
     // A decorated class's container passes each constructor argument, which keeps the
-    // parameter, not the member a parameter property stores it in.
-    const parameterMembers = new Set();
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node) => {
-            const id = held.declarations.get(nodeKey(file, node));
-            const symbol = id === undefined ? undefined : byId.get(id);
-            if (id !== undefined && isParameterProperty(node)) {
-                parameterMembers.add(id);
-            }
-            // A parameter property's decorator is attached to its parameter, and to no member.
-            if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
-                for (const attached of decoratorsOf(node)) {
-                    decorated.push({
-                        symbol,
-                        detail: `decorated by ${spelledDecorator(attached)}`,
-                        site: renderPosition(file, targetRoot, attached.getStart()),
-                    });
-                }
-            }
-            node.forEachChild(visit);
-        };
-        file.forEachChild(visit);
-    }
-    return decorated.flatMap(({ symbol, detail, site }) => (symbol.kind === "class"
-        ? (membersOf.get(symbol.id) ?? []).filter((member) => !parameterMembers.has(member.id))
-        : [symbol]).map((member) => ({ id: member.id, detail, site })));
+    // parameter, not the member a parameter property stores it in. A parameter property's
+    // decorator is attached to its parameter, and to no member.
+    return sites.decorated.flatMap(({ id, node }) => {
+        const symbol = byId.get(id);
+        if (symbol === undefined || !DECORATED.has(symbol.kind) || isParameterProperty(node)) {
+            return [];
+        }
+        const members = symbol.kind === "class"
+            ? (membersOf.get(symbol.id) ?? []).filter((member) => !sites.parameterProperties.has(member.id))
+            : [symbol];
+        return decoratorsOf(node).flatMap((attached) => {
+            const detail = `decorated by ${spelledDecorator(attached)}`;
+            const site = renderPosition(node.getSourceFile(), targetRoot, attached.getStart());
+            return members.map((member) => ({ id: member.id, detail, site }));
+        });
+    });
 }

package/dist/src/exemptions/detectors.js

@@ -0,0 +1,48 @@
+/**
+ * The exemption classes this analyzer detects, each by its detector, and what their
+ * detection reads of the run once for every project. A class without a detector here
+ * retains nothing.
+ */
+import { decorator } from "./decorator.js";
+import { enumGroup } from "./enum-group.js";
+import { frameworkLifecycle } from "./framework-lifecycle.js";
+import { generatedFile } from "./generated-file.js";
+import { injectionContainer } from "./injection-container.js";
+import { interfaceSatisfaction } from "./interface-satisfaction.js";
+import { detect } from "./lifecycle.js";
+import { reflectiveLookup } from "./reflective-lookup.js";
+import { serializationContract } from "./serialization-contract.js";
+import { readTemplates, templateField } from "./template-field.js";
+export const DETECTORS = new Map([
+    ["interface-satisfaction", interfaceSatisfaction],
+    ["enum-group", enumGroup],
+    ["generated-file", generatedFile],
+    ["template-field", templateField],
+    ["reflective-lookup", reflectiveLookup],
+    ["decorator", decorator],
+    ["injection-container", injectionContainer],
+    ["framework-lifecycle", frameworkLifecycle],
+    ["serialization-contract", serializationContract],
+]);
+/**
+ * The detection of one run: what every project's detectors read of the run, read once,
+ * and a function that runs them over one project. A switched-off class reads nothing,
+ * its templates included, and generated files are held only where the configuration
+ * leaves them out of the analysis.
+ */
+export function detection(host, targetRoot, config, consumers, detectors) {
+    const disabled = new Set(config.exemptions.disabled);
+    const templates = disabled.has("template-field")
+        ? { delimiters: config.analysis.template_delimiters, files: [] }
+        : readTemplates(host, targetRoot, config.analysis);
+    const included = config.analysis.generated_files === "include";
+    return ({ project, held, generated }) => detect({
+        project,
+        held,
+        targetRoot,
+        templates,
+        ts: config.ts,
+        consumers,
+        ...(included ? {} : { generated }),
+    }, detectors, disabled);
+}

package/dist/src/{enum-group.js → exemptions/enum-group.js}

@@ -6,24 +6,17 @@
  * 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/ast";
+import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "../unwrap.js";
 import { TypeFlags } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered, UNANSWERED } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { nodeKey } from "../inventory.js";
+import { renderPosition } from "../position.js";
+import { isAnswered, UNANSWERED } from "../query.js";
+import { ERASED } from "./value-reach.js";
 /** The operand types a conversion produces an enum value from. */
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
-const DECODED = TypeFlags.Any | TypeFlags.Unknown;
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node) {
-    let held = node;
-    while (isParenthesizedExpression(held)) {
-        held = held.expression;
-    }
-    return held;
-}
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -45,7 +38,7 @@ function typeName(type) {
 }
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression) {
-    const held = unparenthesized(expression);
+    const held = parenthesesRemoved(expression);
     if (isIdentifier(held)) {
         return held;
     }
@@ -135,7 +128,7 @@ function detailOf(project, site, enumName, operand) {
     if (parts.some((part) => (part.flags & STRING) !== 0)) {
         return site.form === "assertion" ? "converted from string" : undefined;
     }
-    if (parts.some((part) => (part.flags & DECODED) !== 0)) {
+    if (parts.some((part) => (part.flags & ERASED) !== 0)) {
         return `decoded as ${enumName}`;
     }
     return undefined;

package/dist/src/{erased-stores.js → exemptions/erased-stores.js}

@@ -6,12 +6,11 @@
  * 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 it.
  */
-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";
-import { checkedTypes } from "./value-reach.js";
-/** The types that keep nothing of the value they are given. */
-const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { must } from "../query.js";
+import { checkedTypes, ERASED } from "./value-reach.js";
+import { parenthesesRemoved } from "../unwrap.js";
 /** 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. */
@@ -20,9 +19,6 @@ function literalKey(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.
@@ -76,8 +72,8 @@ function propertyAt(source, name) {
  * 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 target = parenthesesRemoved(pattern);
+    const source = from.path.length === 0 ? parenthesesRemoved(from.value) : from.value;
     const into = (element, step, literal) => {
         patternTargets(element, literal === undefined
             ? { value: from.value, path: [...from.path, step] }