@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/roots/unseen-loads.js

@@ -0,0 +1,236 @@
+/**
+ * The loads by a computed path: those whose files the analysis resolves, and those it
+ * cannot, whose files are roots the analysis does not see, so the configuration's roots
+ * are never complete.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isMetaProperty, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { amdLoadOf, amdUnresolved } from "../amd.js";
+import { membersNamed, textsOf, writtenValue } from "../entries/static-module.js";
+import { writtenName } from "../platform-calls.js";
+import { cannotStartPackageName, dirnamePath, hasURLScheme, isAbsolutePath, relativePath, resolvePath, startsRelativePath, } from "../paths.js";
+import { unwrapped } from "../unwrap.js";
+import { globExpression } from "../text/glob.js";
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+function leadingLiteral(node) {
+    const at = unwrapped(node);
+    if (isTemplateExpression(at)) {
+        return at.head.text;
+    }
+    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+        const left = unwrapped(at.left);
+        return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+            ? left.text
+            : leadingLiteral(at.left);
+    }
+    return undefined;
+}
+/**
+ * The directory below `dir` a computed load's leading literal names, every file of which
+ * the load reaches, or none where it names a package, `dir` itself or a directory holding
+ * it, each of which would name every sibling.
+ */
+function computedLoadDirectory(dir, prefix) {
+    if (!startsRelativePath(prefix) || !prefix.endsWith("/")) {
+        return undefined;
+    }
+    const target = resolvePath(dir, prefix);
+    return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+/** Whether one node is a call that may load a module by a computed path. */
+export function isLoadCall(node) {
+    if (!isCallExpression(node)) {
+        return false;
+    }
+    return (node.expression.kind === SyntaxKind.ImportKeyword ||
+        writtenName(node.expression) !== undefined ||
+        isMetaGlob(node));
+}
+/**
+ * The files one `import.meta.glob` call loads, as Vite's `toAbsoluteGlob` reads its globs
+ * (https://vite.dev/guide/features.html#glob-import): `/` against the project root, `./`
+ * and `../` against a literal `base` (read against the root where it starts with `/`) or the
+ * calling file's directory, `**` as written, and `!` removing what it matches. Undefined
+ * where Vite reads a glob through an alias, the root is unknown, or a glob or base is computed.
+ */
+function globbed(file, first, options, others, rootOf) {
+    const patterns = textsOf(writtenValue(first), true);
+    const bases = globOption(options, "base");
+    const [written, ...more] = bases ?? [];
+    const base = written === undefined ? undefined : textsOf(written, false);
+    if (patterns === undefined ||
+        bases === undefined ||
+        more.length > 0 ||
+        (written !== undefined && base === undefined)) {
+        return undefined;
+    }
+    const dir = dirnamePath(file.fileName);
+    const root = () => rootOf(file.fileName);
+    const against = (at) => {
+        if (!isAbsolutePath(at)) {
+            return resolvePath(dir, at);
+        }
+        const top = root();
+        return top === undefined ? undefined : resolvePath(top, `.${at}`);
+    };
+    const from = base?.[0] === undefined ? dir : against(base[0]);
+    const keep = [];
+    const drop = [];
+    for (const written of patterns) {
+        const negated = written.startsWith("!");
+        const pattern = negated ? written.slice(1) : written;
+        let path;
+        if (isAbsolutePath(pattern)) {
+            path = against(pattern);
+        }
+        else if (startsRelativePath(pattern)) {
+            path = from === undefined ? undefined : resolvePath(from, pattern);
+        }
+        else if (pattern.startsWith("**")) {
+            path = pattern;
+        }
+        if (path === undefined) {
+            return undefined;
+        }
+        (negated ? drop : keep).push(globExpression(path));
+    }
+    return others.filter((candidate) => keep.some((glob) => glob.test(candidate.file.fileName)) &&
+        !drop.some((glob) => glob.test(candidate.file.fileName)));
+}
+/**
+ * The computed loads among one file's load calls, each loading the `candidates` but the
+ * file itself: an `import()` or `require()` whose path starts with a relative literal naming
+ * a directory below the file's loads every candidate below it, as a bundler's context module
+ * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
+ * call of a computed path that names no such directory and no package is an unresolved load,
+ * and so is an AMD call one of whose dependencies names no path ({@link amdUnresolved}).
+ */
+export function computedLoadsOf(file, calls, candidates, rootOf) {
+    const dir = dirnamePath(file.fileName);
+    const others = candidates.filter((candidate) => candidate.file !== file);
+    return calls.flatMap(({ call, from }) => {
+        const [first, options] = call.arguments;
+        if (first === undefined) {
+            return [];
+        }
+        if (isMetaGlob(call)) {
+            const files = globbed(file, first, options, others, rootOf);
+            const asset = readsAsAsset(options);
+            return [
+                {
+                    call,
+                    from,
+                    require: undefined,
+                    amd: false,
+                    files: files ?? [],
+                    resolved: files !== undefined,
+                    asset,
+                    eager: isEager(options),
+                },
+            ];
+        }
+        const amd = amdLoadOf(call);
+        if (amd !== undefined) {
+            return amdUnresolved(amd)
+                ? [
+                    {
+                        call,
+                        from,
+                        require: amd.callee,
+                        amd: true,
+                        files: [],
+                        resolved: false,
+                        asset: false,
+                        eager: false,
+                    },
+                ]
+                : [];
+        }
+        const argument = unwrapped(first);
+        const require = call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
+        if (!mayNamePath(argument)) {
+            return [];
+        }
+        const prefix = leadingLiteral(argument);
+        if (namesPackage(prefix)) {
+            return [];
+        }
+        const target = prefix === undefined ? undefined : computedLoadDirectory(dir, prefix);
+        const files = target === undefined
+            ? []
+            : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
+        return [
+            {
+                call,
+                from,
+                require,
+                amd: false,
+                files,
+                resolved: target !== undefined,
+                asset: false,
+                eager: false,
+            },
+        ];
+    });
+}
+/**
+ * Whether a computed argument may be a module path: anything but a string, which names its
+ * module, and a value no path is, a number, a boolean, `null`, an object, an array, a
+ * function or a class.
+ */
+function mayNamePath(argument) {
+    return !NO_PATH.has(argument.kind);
+}
+const NO_PATH = new Set([
+    SyntaxKind.StringLiteral,
+    SyntaxKind.NoSubstitutionTemplateLiteral,
+    SyntaxKind.NumericLiteral,
+    SyntaxKind.BigIntLiteral,
+    SyntaxKind.TrueKeyword,
+    SyntaxKind.FalseKeyword,
+    SyntaxKind.NullKeyword,
+    SyntaxKind.ObjectLiteralExpression,
+    SyntaxKind.ArrayLiteralExpression,
+    SyntaxKind.ArrowFunction,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.ClassExpression,
+    SyntaxKind.RegularExpressionLiteral,
+]);
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node) {
+    if (!isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/** The values the options of an `import.meta.glob` write for one key, undefined where a spread may hide one. */
+function globOption(options, key) {
+    return options === undefined ? [] : membersNamed(writtenValue(options), key);
+}
+/** Whether the options of an `import.meta.glob` set `eager` to `true`. */
+function isEager(options) {
+    return (globOption(options, "eager")?.some((value) => value.kind === "boolean" && value.value) === true);
+}
+/** The query parameters that make Vite load a file as its text or its URL, each written bare. */
+const ASSET_QUERY = /(?:^\?|&)(?:raw|url|inline)(?:&|$)/u;
+/**
+ * Whether the options of an `import.meta.glob` read each file as text or as a URL: a
+ * `query` string holding a bare `raw`, `url` or `inline`, or an `as` of `raw` or `url`,
+ * which Vite reads as that query (https://vite.dev/guide/features.html#glob-import). Any
+ * other query is read as loading the module, which keeps more than it may.
+ */
+function readsAsAsset(options) {
+    const texts = (key) => (globOption(options, key) ?? []).flatMap((value) => value.kind === "text" ? [value.text] : []);
+    return (texts("as").some((text) => text === "raw" || text === "url") ||
+        texts("query").some((text) => ASSET_QUERY.test(text.startsWith("?") ? text : `?${text}`)));
+}
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix) {
+    return (prefix !== undefined &&
+        prefix !== "" &&
+        !cannotStartPackageName(prefix) &&
+        !hasURLScheme(prefix));
+}

package/dist/src/serialization-contract.js

@@ -12,7 +12,7 @@ import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync"
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must, Unanswerable } from "./query.js";
@@ -898,7 +898,8 @@ export function serializationContract(input) {
 }
 /**
  * The data members the decodes and copies of `files` fill, as {@link Decoded} names them.
- * A generic declared outside the analysis, or only ambiently, fills the type that a type
+ * A generic declared outside the analysis, or only ambiently, or one that reads a value
+ * {@link readTypes} finds untyped as its own type parameter, fills the type that a type
  * parameter of its own no parameter names binds, where the awaited result carries that
  * type through its data members rather than only naming it, as a store's methods do: no
  * argument hands the value over, so it fills it where the analysis cannot see, and may
@@ -951,6 +952,10 @@ function decodedOf(project, held, files, consumers) {
     for (const file of files) {
         file.forEachChild(visit);
     }
+    const read = readTypes(project, untyped);
+    // A generic of the analysis that reads an untyped value as its own type parameter is a
+    // client of what made the value, and fills what that parameter binds as an outside one does.
+    const clients = new Set(read.made.flatMap((type) => (type.isTypeParameter() ? [type.id] : [])));
     const filled = [];
     const resolved = queries.resolvedSignatures(calls).map(must);
     for (const signature of resolved) {
@@ -963,7 +968,8 @@ function decodedOf(project, held, files, consumers) {
         const node = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
         if (declaration === undefined ||
             (inAnalysis(declaration.path) &&
-                (node === undefined || (node.flags & NodeFlags.Ambient) === 0))) {
+                (node === undefined || (node.flags & NodeFlags.Ambient) === 0) &&
+                !generic.some((id) => clients.has(id)))) {
             continue;
         }
         const result = must(queries.returnTypeOf(declared));
@@ -982,7 +988,6 @@ function decodedOf(project, held, files, consumers) {
             filled.push({ carried: awaited(project, given), types });
         }
     }
-    const read = readTypes(project, untyped);
     const copies = copiedNames(project, spreads, calls);
     if (filled.length === 0 &&
         read.parsed.length === 0 &&

package/dist/src/source-files.js

@@ -5,12 +5,11 @@
  */
 import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { OUTPUT_EXTENSIONS } from "./extensions.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 /** The extension a source file's name drops when the project writes it out. */
 const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
-/** The extensions the project may write a source file's output under. */
-const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -43,13 +42,10 @@ function layoutOf(project, fileNames) {
     };
 }
 /**
- * The lookups over one project's own files.
- *
- * A path that names an emitted file is read back to the source the project would
- * emit it from through the project's own emit mapping and nothing else: the
- * extension is one the compiler emits from a source extension, and a path below the
- * output directory is read below the directory the compiler emits from, which the
- * configuration declares or which is the directory every input file shares.
+ * The lookups over one project's own files. A path naming an emitted file is read back to its
+ * source through the project's own emit mapping alone: the extension is one the compiler emits
+ * from a source extension, and a path below the output directory is read below the directory
+ * the compiler emits from, which the configuration declares or every input file shares.
  */
 export function sourceFilesOf(project, targetRoot) {
     const byName = new Map();

package/dist/src/stores.js

@@ -5,6 +5,7 @@
  */
 import { isGetAccessorDeclaration, isSetAccessorDeclaration, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
+import { classedAsTest, madeByTestCode, withheldBy } from "./tests/file-class.js";
 /** The class members one project's own files declare by a getter or a setter. */
 export function accessorsOf(project, held) {
     const found = [];
@@ -25,9 +26,10 @@ export function accessorsOf(project, held) {
 /** The run's stores, from what each configuration contributed, the records and the mode. */
 export function storesOf(per, exempt, mode) {
     return {
-        references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        references: per.flatMap((one) => one.references.filter((reference) => !withheldBy(mode, reference, one.support))),
         readInTests: new Set(per.flatMap((one) => one.references
-            .filter((reference) => reference.test && reference.use !== "write")
+            .filter((reference) => reference.use !== "write" &&
+            classedAsTest(madeByTestCode(reference, one.support), reference.consumer !== undefined, mode))
             .map((reference) => reference.to))),
         accessors: new Set(per.flatMap((one) => one.accessors)),
         exempt: new Set(exempt.map((record) => record.id)),

package/dist/src/suppress.js

@@ -4,9 +4,9 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
-import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { KIND_ROWS, REMEDIES, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
 import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
@@ -66,6 +66,8 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/** No hold. */
+const NO_HOLDS = { withholds: () => false, holdsRecord: () => false };
 /** The subject of the kind each live code names. */
 const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
 /** The subject a finding about one symbol kind is about. */
@@ -78,32 +80,25 @@ function subjectOf(kind) {
 function rowOf(subject) {
     return subject === "file" || subject === "dependency" || subject === "record";
 }
-/**
- * Whether a finding's subject is a row of a document rather than a declaration. Apart
- * from a dependency row, nothing withholds a finding about one.
- */
+/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
     return rowOf(subjectOf(kind));
 }
-/** Whether a code reports a row of a document. */
-export function isRowCode(code) {
-    return rowOf(SUBJECT_OF_CODE.get(code));
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code) {
+    return SUBJECT_OF_CODE.get(code);
 }
 /**
- * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
- * naming the row's reference and file withholds its finding and marks nothing, and an
- * inline directive never binds one.
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
  */
-export function isDependencySubject(kind) {
-    return subjectOf(kind) === "dependency";
-}
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code) {
-    return SUBJECT_OF_CODE.get(code) === "dependency";
+export function names(subject, mechanism) {
+    return REMEDIES[subject ?? "declaration"].suppressions.includes(mechanism);
 }
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code) {
-    return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind, mechanism) {
+    return names(subjectOf(kind), mechanism);
 }
 /**
  * Whether a finding's subject is a part of the declaration its reference names: a part
@@ -136,14 +131,13 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (isDependencySubject(finding.symbol.kind)) {
-        return (record.mechanism !== "inline" &&
-            record.symbol === finding.symbol.ref &&
-            record.path === finding.position.path);
-    }
-    if (isRowSubject(finding.symbol.kind)) {
+    const subject = subjectOf(finding.symbol.kind);
+    if (!names(subject, record.mechanism)) {
         return false;
     }
+    if (subject === "dependency") {
+        return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+    }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
         return true;
     }
@@ -155,10 +149,10 @@ export function pairs(record, finding) {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
-export function ledgerOf(records, would, dials) {
+export function ledgerOf(records, would, dials, holds = NO_HOLDS) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
@@ -166,13 +160,17 @@ export function ledgerOf(records, would, dials) {
         const first = would.find(open);
         const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
         if (claimed.length === 0) {
-            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+            verdicts.push(record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+                ? "dormant"
+                : "stale");
             continue;
         }
         for (const finding of claimed) {
             taken.add(claimKey(finding));
         }
-        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+            ? "dormant"
+            : "in-effect");
     }
     return {
         verdicts,

package/dist/src/sweep.js

@@ -6,6 +6,22 @@
  * declaration only unreachable ones reference is live under the first, dead under the second.
  */
 import { namesACaller, OUTSIDE } from "./graph.js";
+import { edgeWithheldBy } from "./tests/file-class.js";
+/** The references to one declaration the mode counts: under `production` none test code made but those it classes as production. */
+function countedRefs(made, mode) {
+    if (made === undefined) {
+        return 0;
+    }
+    if (!mode.production) {
+        return made.production + made.test;
+    }
+    return made.production + (mode.consumerTestsProduction === true ? made.consumerTest : 0);
+}
+/** The references to one declaration, split as the mode classes them, whatever it counts. */
+export function splitRefs(made, mode) {
+    const moved = mode.consumerTestsProduction === true ? (made?.consumerTest ?? 0) : 0;
+    return { production: (made?.production ?? 0) + moved, test: (made?.test ?? 0) - moved };
+}
 /**
  * Answers which declarations of one graph are dead under the input's mode.
  *
@@ -30,13 +46,7 @@ export function sweep(graph, input) {
             called[root.at] = true;
         }
     }
-    const counted = (at) => {
-        const made = graph.made[at];
-        if (made === undefined) {
-            return 0;
-        }
-        return input.mode.production ? made.production : made.production + made.test;
-    };
+    const counted = (at) => countedRefs(graph.made[at], input.mode);
     const reached = reachable(graph, held, input.mode);
     const liveUnder = graph.symbols.map((_symbol, at) => {
         const relations = [];
@@ -60,10 +70,11 @@ export function sweep(graph, input) {
         if (dead[at] !== true) {
             return;
         }
+        const split = splitRefs(graph.made[at], input.mode);
         candidates.push({
             id: symbol.id,
-            productionRefs: graph.made[at]?.production ?? 0,
-            testRefs: graph.made[at]?.test ?? 0,
+            productionRefs: split.production,
+            testRefs: split.test,
             relation: counted(at) === 0 ? "reference-counting" : "reachability",
             testOfDeadCode: testOfDeadCode[at] === true,
         });
@@ -100,11 +111,12 @@ export function reachedWithTheTests(graph, held, namespaces = true) {
     return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
 }
 /**
- * The references a loaded consumer makes that the mode counts. A production mode counts
- * none a consumer's test file made, as it counts none of the target's.
+ * The references a loaded consumer or an unheld file makes that the mode counts. A
+ * production mode counts no test reference, but a loaded consumer's where the mode classes
+ * a consumer's tests as production.
  */
 function callsOf(graph, mode) {
-    return graph.consumed.filter((edge) => !mode.production || !edge.test);
+    return graph.consumed.filter((edge) => !edgeWithheldBy(mode, edge));
 }
 /** Per declaration of the graph, whether one of the identifiers names it. */
 function flagged(graph, ids) {
@@ -149,7 +161,7 @@ function reachable(graph, held, mode, namespaces = true) {
     const walk = (holding) => {
         for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
             for (const edge of graph.out[at] ?? []) {
-                if (!holding && mode.production && edge.test) {
+                if (!holding && edgeWithheldBy(mode, edge)) {
                     continue;
                 }
                 enter(edge.to, namespaces && !edge.evaluation);