@cplieger/deadset-ts 8.0.0-dev.20 → 8.0.0-dev.22

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

@@ -1,29 +1,20 @@
 /**
  * The calls and decorators of one project that the configured classes read: what each
- * callee resolves to, 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 be, at any depth inside
- * the array and object literals it writes, named directly or through variables, and a
- * decorator written as a call is a call.
+ * 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, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isConditionalExpression, isDecorator, isFunctionDeclaration, isFunctionExpression, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isShorthandPropertyAssignment, isOmittedExpression, isSpreadAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+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 { nodeKey } from "./inventory.js";
-import { must } from "./query.js";
-import { unwrapped } from "./unwrap.js";
-/** The name node a callee or a decorator expression resolves through, where it has one. */
-export function calleeName(expression) {
-    if (isParenthesizedExpression(expression)) {
-        return calleeName(expression.expression);
-    }
-    if (isPropertyAccessExpression(expression)) {
-        return expression.name;
-    }
-    return isIdentifier(expression) ? expression : undefined;
-}
+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 calleeName(isCallExpression(expression) ? expression.expression : 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) {
@@ -35,36 +26,90 @@ export function spelledDecorator(decorator) {
 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",
+]);
 /**
- * What each of a batch of nodes resolves to, every alias followed to the declaration
- * it stands for. A node the checker resolves to nothing, and an alias that resolves
- * to nothing, are absent from the answer. Each alias is followed once. A question the
- * checker does not answer stops the pass, as {@link must} stops.
+ * 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.
  */
-export function resolvedTargets(project, nodes) {
-    const followed = new Map();
-    const targets = new Map();
-    project
-        .symbolsAt(nodes.map((node) => project.handle(node)))
-        .map(must)
-        .forEach((symbol, index) => {
-        const node = nodes[index];
-        if (symbol === undefined || node === undefined) {
-            return;
+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];
         }
-        let target = symbol;
-        if ((symbol.flags & SymbolFlags.Alias) !== 0) {
-            if (!followed.has(symbol.id)) {
-                const aliased = must(project.queries.aliased(symbol));
-                followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
-            }
-            target = followed.get(symbol.id);
+        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,
+                },
+            };
         }
-        if (target !== undefined) {
-            targets.set(node, target);
+    }
+    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);
         }
-    });
-    return targets;
+    }
+    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) {
@@ -76,74 +121,7 @@ function shorthandTarget(project, node) {
     return aliased.declarations.length === 0 ? undefined : aliased;
 }
 /**
- * The values one expression passes: each value it can be ({@link leavesOf}), or what an
- * array or object literal it can be holds, at any depth.
- */
-function passedIn(written, found) {
-    for (const expression of leavesOf(written)) {
-        if (isArrayLiteralExpression(expression)) {
-            for (const element of expression.elements) {
-                passedIn(element, found);
-            }
-        }
-        else if (isObjectLiteralExpression(expression)) {
-            for (const property of expression.properties) {
-                if (isPropertyAssignment(property)) {
-                    passedIn(property.initializer, found);
-                }
-                else if (isSpreadAssignment(property)) {
-                    passedIn(property.expression, found);
-                }
-                else if (isShorthandPropertyAssignment(property)) {
-                    found.push({ site: property.name, name: property, shorthand: true });
-                }
-            }
-        }
-        else if (!isOmittedExpression(expression)) {
-            found.push({ site: expression, name: calleeName(expression), shorthand: false });
-        }
-    }
-}
-/** The operators whose value is one of their operands. */
-const CHOOSING = new Set([
-    SyntaxKind.QuestionQuestionToken,
-    SyntaxKind.BarBarToken,
-    SyntaxKind.AmpersandAmpersandToken,
-]);
-/**
- * The expressions one value can be: itself, or each branch of a conditional, each operand
- * of `??`, `||` and `&&` and the last of a comma, inside any wrapper that changes no value.
- * Each is read alone because the checker reduces a union by subtype, so the type at the
- * whole drops a class structurally equal to, or a subtype of, another branch's.
- */
-function leavesOf(written) {
-    const expression = unwrapped(isSpreadElement(written) ? written.expression : written);
-    if (isConditionalExpression(expression)) {
-        return [...leavesOf(expression.whenTrue), ...leavesOf(expression.whenFalse)];
-    }
-    if (isBinaryExpression(expression)) {
-        const operator = expression.operatorToken.kind;
-        if (CHOOSING.has(operator)) {
-            return [...leavesOf(expression.left), ...leavesOf(expression.right)];
-        }
-        if (operator === SyntaxKind.CommaToken) {
-            return leavesOf(expression.right);
-        }
-    }
-    return [expression];
-}
-/** The values one argument passes, a spread argument's included. */
-function leavesPassed(argument) {
-    const found = [];
-    passedIn(argument, found);
-    return found;
-}
-/** The values one argument passes that name their declaration. */
-export function valuesPassed(argument) {
-    return leavesPassed(argument).filter((value) => value.name !== undefined);
-}
-/**
- * What one passed value holds: the declaration its name resolves to, and the classes and
+ * 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.
  */
@@ -160,21 +138,27 @@ function heldBy(project, value, known) {
         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 call passes, by the call: each class a value an argument
- * can be 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 passes it. A class of another
- * program passes nothing.
+ * 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 classesPassed(project, held, chains, calls) {
-    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
-    const targets = resolvedTargets(project, [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))));
+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);
+        calling ??= callsByDeclaration(project, sites.calls.map((one) => one.call), invoked);
         return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
     };
     const classesOf = (value, seen) => {
@@ -190,14 +174,14 @@ export function classesPassed(project, held, chains, calls) {
             return ids;
         }
         seen.add(symbol.id);
-        const through = (written) => leavesPassed(written).flatMap((value) => classesOf(value, seen));
+        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).flatMap(through);
+                return argumentsAt(project, node, callsOfFunction, invoked).flatMap(through);
             }
             const bound = boundTo(project, node);
             return [
@@ -206,15 +190,15 @@ export function classesPassed(project, held, chains, calls) {
             ];
         });
     };
-    return new Map([...passed].map(([call, values]) => {
+    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 [call, [...uses.values()]];
-    }));
+        return [...uses.values()];
+    });
 }
 /**
  * The symbols of the classes and functions the checker's type at one expression holds as
@@ -269,16 +253,14 @@ function keyOf(handle) {
     return `${handle.path}#${String(handle.index)}`;
 }
 /**
- * Every call of the project by the declarations its callee 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
+ * 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) {
-    const calls = callsOf(project);
+function callsByDeclaration(project, calls, invoked) {
     const own = project.ownPaths();
-    const callees = resolvedTargets(project, calls.flatMap((call) => calleeName(call.expression) ?? []));
     const named = new Map();
     const keysOf = (symbol, seen) => {
         const known = named.get(symbol.id);
@@ -293,7 +275,7 @@ function callsByDeclaration(project) {
             const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
             const copied = [
                 ...bound.symbols,
-                ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+                ...(bound.written === undefined ? [] : carriedValues(bound.written)).flatMap((value) => {
                     const { named: next, typed } = heldBy(project, value);
                     return [...typed, ...(next === undefined ? [] : [next])];
                 }),
@@ -303,18 +285,14 @@ function callsByDeclaration(project) {
         named.set(symbol.id, keys);
         return keys;
     };
-    const calleeOf = (call) => {
-        const name = calleeName(call.expression);
-        return name === undefined ? undefined : callees.get(name);
-    };
-    const declared = (call) => ((calleeOf(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+    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(call.expression)))
+        .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 = calleeOf(call);
+        const callee = invoked.callee(call);
         const held = [
             ...(callee === undefined ? [] : [callee]),
             ...(types.has(call) ? heldIn(project, types.get(call)) : []),
@@ -327,12 +305,13 @@ function callsByDeclaration(project) {
 }
 /**
  * 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. 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.
+ * 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) {
+function argumentsAt(project, parameter, callsOfFunction, invoked) {
     const owner = parameter.parent;
     if (!isFunctionDeclaration(owner) &&
         !isMethodDeclaration(owner) &&
@@ -347,7 +326,7 @@ function argumentsAt(project, parameter, callsOfFunction) {
     const rest = parameter.dotDotDotToken !== undefined;
     return [...calls].flatMap((call) => {
         let spreads = 0;
-        return call.arguments.flatMap((argument, index) => {
+        return invoked.of(call).arguments.flatMap((argument, index) => {
             const spread = isSpreadElement(argument);
             const earliest = index - spreads;
             spreads += spread ? 1 : 0;
@@ -357,35 +336,3 @@ function argumentsAt(project, parameter, callsOfFunction) {
         });
     });
 }
-/** Every class declaration of the target that carries a decorator. */
-export function decoratedClasses(project, held) {
-    const found = [];
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node) => {
-            if (isClassDeclaration(node)) {
-                const id = held.declarations.get(nodeKey(file, node));
-                const decorators = decoratorsOf(node);
-                if (id !== undefined && decorators.length > 0) {
-                    found.push({ id, decorators });
-                }
-            }
-            node.forEachChild(visit);
-        };
-        file.forEachChild(visit);
-    }
-    return found;
-}
-/** Every call expression of the project's own files, decorators written as calls included. */
-export function callsOf(project) {
-    const found = [];
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node) => {
-            if (isCallExpression(node)) {
-                found.push(node);
-            }
-            node.forEachChild(visit);
-        };
-        file.forEachChild(visit);
-    }
-    return found;
-}

package/dist/src/{exempt-classes.js → exemptions/classes.js}

@@ -1,4 +1,4 @@
-import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
+import { EXEMPTION_CLASSES } from "../contract/contract.generated.js";
 function runsOnTS(row) {
     const languages = row.languages;
     return languages.includes("ts");

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}

@@ -7,16 +7,16 @@
  * 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, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
-import { parenthesesRemoved } from "./unwrap.js";
+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 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
@@ -128,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}

@@ -7,12 +7,10 @@
  * declare hands the value to the code that declares it.
  */
 import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, 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";
-import { parenthesesRemoved } from "./unwrap.js";
-/** The types that keep nothing of the value they are given. */
-const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+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. */