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

package/dist/src/unseen-loads.js

@@ -1,17 +1,20 @@
 /**
- * The loads of a project's production files whose target the analysis cannot resolve: an
- * `import()` or `require()` call whose path is computed and starts with no relative literal
- * naming a directory below the calling file's. The files such a load runs are roots the
- * analysis does not see, so the configuration's roots are never complete.
+ * The loads by a computed path: those whose files the analysis resolves, and those of a
+ * project's production files it cannot resolve, an `import()` or `require()` call whose
+ * path starts with no relative literal naming a directory below the calling file's. The
+ * files such a load runs are roots the analysis does not see, so the configuration's
+ * roots are never complete.
  */
-import { isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCallExpression, isIdentifier, isMetaProperty, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { literalsOf } from "./entry-points.js";
+import { hasOwnBody } from "./own-body.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { renderPosition } from "./position.js";
-import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.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. */
-export function leadingLiteral(node) {
+function leadingLiteral(node) {
     const at = unwrapped(node);
     if (isTemplateExpression(at)) {
         return at.head.text;
@@ -25,17 +28,107 @@ export function leadingLiteral(node) {
     return undefined;
 }
 /**
- * The directory below `dir` a computed load's leading literal names, which the entry
- * rules root every file of, or none where it names a package, `dir` itself or a
- * directory holding it, each of which would name files no rule roots.
+ * 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.
  */
-export function computedLoadDirectory(dir, prefix) {
+function computedLoadDirectory(dir, prefix) {
     if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !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;
+    }
+    const callee = node.expression;
+    return (callee.kind === SyntaxKind.ImportKeyword ||
+        (isIdentifier(callee) && callee.text === "require") ||
+        isMetaGlob(node));
+}
+/**
+ * The resolved 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, every candidate below it, and an
+ * `import.meta.glob` of relative literal globs, every candidate one matches, each read
+ * against the file's directory, as a bundler's context module reads them.
+ */
+export function computedLoadsOf(file, calls, candidates) {
+    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 globs = (literalsOf(first) ?? [])
+                .filter((pattern) => pattern.startsWith("./") || pattern.startsWith("../"))
+                .map((pattern) => globExpression(resolvePath(dir, pattern)));
+            const files = others.filter((candidate) => globs.some((glob) => glob.test(candidate.file.fileName)));
+            const asset = readsAsAsset(options);
+            return [{ call, from, require: undefined, files, asset, eager: isEager(options) }];
+        }
+        const prefix = leadingLiteral(first);
+        const target = prefix === undefined ? undefined : computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
+            return [];
+        }
+        const files = others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
+        const callee = call.expression;
+        const require = isIdentifier(callee) ? callee : undefined;
+        return [{ call, from, require, files, asset: false, eager: false }];
+    });
+}
+/** 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 an `import.meta.glob` options object assigns, each by its literal key. */
+function globOptions(options) {
+    const literal = options === undefined ? undefined : unwrapped(options);
+    if (literal === undefined || !isObjectLiteralExpression(literal)) {
+        return [];
+    }
+    return literal.properties.flatMap((property) => isPropertyAssignment(property) &&
+        (isIdentifier(property.name) || isStringLiteral(property.name))
+        ? [[property.name.text, unwrapped(property.initializer)]]
+        : []);
+}
+/** Whether the options of an `import.meta.glob` set `eager` to `true`. */
+function isEager(options) {
+    return globOptions(options).some(([key, value]) => key === "eager" && value.kind === SyntaxKind.TrueKeyword);
+}
+/** 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) {
+    return globOptions(options).some(([key, value]) => {
+        if (!isStringLiteral(value) && !isNoSubstitutionTemplateLiteral(value)) {
+            return false;
+        }
+        if (key === "as") {
+            return value.text === "raw" || value.text === "url";
+        }
+        return (key === "query" &&
+            ASSET_QUERY.test(value.text.startsWith("?") ? value.text : `?${value.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 &&
@@ -47,8 +140,7 @@ function namesPackage(prefix) {
 /**
  * Every unresolved load the project's production files write, in file then source order.
  * `testFiles` holds the test files by their path below the target root. A `require` call
- * loads a module only where the name resolves to no declaration of the project's own
- * files: one the project declares is its own function.
+ * loads a module unless {@link hasOwnBody} reads it as the project's own function.
  */
 export function unseenLoadsOf(project, configuration, targetRoot, testFiles) {
     const tests = new Set(testFiles);
@@ -84,13 +176,10 @@ export function unseenLoadsOf(project, configuration, targetRoot, testFiles) {
         file.forEachChild(visit);
     }
     const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
-    const own = project.ownPaths();
     const local = new Set();
     project.symbolsAt(requires.map((node) => project.handle(node))).forEach((symbol, at) => {
         const node = requires[at];
-        if (node !== undefined &&
-            symbol !== UNANSWERED &&
-            symbol?.declarations.some((handle) => own.has(handle.path)) === true) {
+        if (node !== undefined && typeof symbol === "object" && hasOwnBody(project, symbol)) {
             local.add(node);
         }
     });

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.14",
+  "version": "8.0.0-dev.15",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.14",
+  "version": "8.0.0-dev.15",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -43,7 +43,7 @@
     "@stryker-mutator/typescript-checker": "10.1.1",
     "@stryker-mutator/vitest-runner": "10.1.1",
     "@types/node": "24.19.2",
-    "eslint": "10.13.0",
+    "eslint": "10.14.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",

package/src/alias-chain.ts

@@ -14,7 +14,7 @@ import {
   isNamespaceImport,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
-import { declarationsByName, isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
+import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -132,7 +132,7 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
         names.add(node.expression.text);
       }
     }
-    const byName = declarationsByName(held);
+    const byName = held.byName;
     const ids = [...names].flatMap((name) => byName.get(name) ?? []);
     return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
       id,

package/src/analysis.ts

@@ -51,7 +51,8 @@ import { implementations, mergeImplementations } from "./implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
-import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
+import { type Inventory, type InventorySymbol } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
 import { readManifest, type ManifestEntry } from "./manifest.ts";
 import {
   liveFilesAt,

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:58ac31fa90fcbefdbbcbcbd6d2c7a8af6dd4cd883c04d79abfe96f979ffe10e1",
+    digest: "sha256:4a66f7f01b0f1a23cf843b77ef48d762f2dcf486153e665560f107f10b0ea838",
   },
   gaps: [],
 } as const;

package/src/consumers.ts

@@ -1,6 +1,6 @@
 import type { PartialConfig } from "./config.ts";
 import type { Host } from "./host.ts";
-import { inventory } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
 import { relativePath } from "./paths.ts";
 import { references, type ConsumerSide, type Reference } from "./references.ts";
 import { narrowedTo, type ProjectView } from "./session.ts";

package/src/contract/contract.generated.ts

@@ -1297,6 +1297,7 @@ export const FAILURE_CLASSES = {
   "unreadable-document": "setup",
   "missing-import-path": "setup",
   "binding-undecodable": "setup",
+  "unsupported-language": "setup",
   "unwritten-output": "run",
   "unreportable-path": "run",
   "memory-exhausted": "run",

package/src/dependencies.ts

@@ -41,7 +41,8 @@ import {
 } from "./configuration-files.ts";
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
-import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { packageScope } from "./load/package-scope.ts";
 import {
   ancestors,
   dirnamePath,

package/src/entry-points.ts

@@ -1,14 +1,7 @@
 /**
- * The files a tool or the platform enters without any import naming them: the
- * configuration files a tool loads by their file name and the files their strings
- * name, the test files the runner executes, and a worker a call addresses by a string
- * literal.
- *
- * Each rule is read from the program and nothing else: a file name the tool
- * itself looks for, a literal written in a configuration file, or a literal
- * argument of a call the checker resolves to the platform's own declaration. A
- * value that is not a literal is not evaluated and not guessed, so a file it would
- * have named is entered by nothing here.
+ * The files a tool or the platform enters without any import naming them, each by a name
+ * the tool looks for or a literal it reads. A value that is not a literal is not evaluated
+ * or guessed, so a file it would have named is entered by nothing here.
  */
 
 import {
@@ -23,7 +16,6 @@ import {
   isPropertyAccessExpression,
   isPropertyAssignment,
   isStringLiteral,
-  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -39,11 +31,11 @@ import { buildScriptEntries } from "./build-scripts.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
 import { documentEntries } from "./mdx-entries.ts";
+import { hasOwnBody } from "./own-body.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
-import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.ts";
 import { workflowEntries } from "./workflow-steps.ts";
 import { unwrapped } from "./unwrap.ts";
 import { globExpression } from "./text/glob.ts";
@@ -66,12 +58,6 @@ export type EntryRule =
   | "html-entry"
   /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
   | "workflow-step"
-  /**
-   * A file a load whose path is computed may name: below the directory the literal
-   * start of an `import()` or `require()` argument names, or matched by the literal
-   * glob of `import.meta.glob`.
-   */
-  | "computed-import"
   /** A file an import line of a Markdown or MDX document below the target root names. */
   | "document-import";
 
@@ -216,7 +202,7 @@ function memberOf(object: Node, name: string): Node | undefined {
  * The strings one member holds, when it is written as a literal or an array of
  * literals. `undefined` is a value the text does not state.
  */
-function literalsOf(value: Node): readonly string[] | undefined {
+export function literalsOf(value: Node): readonly string[] | undefined {
   const at = unwrapped(value);
   const single = literalOf(at);
   if (single !== undefined) {
@@ -244,11 +230,6 @@ function isRelative(text: string): boolean {
   return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
 }
 
-/** Whether a module specifier is relative, which a bare name is not: it names a package. */
-function isModuleRelative(text: string): boolean {
-  return text.startsWith("./") || text.startsWith("../");
-}
-
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
 function pathPart(text: string): string {
   const cut = text.search(/[?#]/u);
@@ -396,6 +377,8 @@ function browserTestsOf(file: SourceFile, files: SourceFiles): readonly EntryPoi
 interface WorkerSite {
   readonly literal: string;
   readonly platformNames: readonly Node[];
+  /** The `URL` the address is built with; {@link hasOwnBody} owns which one names no file. */
+  readonly url: Node | undefined;
 }
 
 /**
@@ -405,14 +388,14 @@ interface WorkerSite {
  */
 function workerAddress(
   argument: Node | undefined,
-): { readonly literal: string; readonly names: readonly Node[] } | undefined {
+): { readonly literal: string; readonly url: Node | undefined } | undefined {
   if (argument === undefined) {
     return undefined;
   }
   const at = unwrapped(argument);
   const literal = literalOf(at);
   if (literal !== undefined) {
-    return { literal, names: [] };
+    return { literal, url: undefined };
   }
   if (!isNewExpression(at) || !isIdentifier(at.expression) || at.expression.text !== "URL") {
     return undefined;
@@ -431,7 +414,7 @@ function workerAddress(
   ) {
     return undefined;
   }
-  return { literal: text, names: [at.expression] };
+  return { literal: text, url: at.expression };
 }
 
 /**
@@ -451,7 +434,8 @@ function workerSitesOf(file: SourceFile): readonly WorkerSite[] {
       if (address !== undefined) {
         found.push({
           literal: address.literal,
-          platformNames: [node.expression, ...address.names],
+          platformNames: [node.expression],
+          url: address.url,
         });
       }
     }
@@ -471,7 +455,8 @@ function workerSitesOf(file: SourceFile): readonly WorkerSite[] {
         if (address !== undefined) {
           found.push({
             literal: address.literal,
-            platformNames: [callee.expression.expression, ...address.names],
+            platformNames: [callee.expression.expression],
+            url: address.url,
           });
         }
       }
@@ -483,10 +468,10 @@ function workerSitesOf(file: SourceFile): readonly WorkerSite[] {
 }
 
 /**
- * The workers one file addresses. A call's names must resolve to a symbol the platform
- * declares, which a file of the target may augment and no import brings in; a name only
- * the target declares is the target's own constructor or object, which addresses no
- * worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's `Worker`, `SharedWorker` or `navigator` must
+ * resolve to a symbol the platform declares, which a file of the target may augment and no
+ * import brings in; a name only the target declares is the target's own constructor or
+ * object, which addresses no worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf<Brand>(
   project: ProjectView<Brand>,
@@ -498,7 +483,8 @@ function workersOf<Brand>(
     return [];
   }
   const names = sites.flatMap((site) => site.platformNames);
-  const symbols = project.symbolsAt(names.map((name) => project.handle(name)));
+  const urls = sites.flatMap((site) => site.url ?? []);
+  const symbols = project.symbolsAt([...names, ...urls].map((name) => project.handle(name)));
   const platform = new Set<Node>();
   // A name the checker could not resolve is read as the platform's, so a worker it
   // stands on is rooted rather than reported.
@@ -516,10 +502,19 @@ function workersOf<Brand>(
       platform.add(name);
     }
   });
+  urls.forEach((url, index) => {
+    const symbol = symbols[names.length + index];
+    if (typeof symbol !== "object" || !hasOwnBody(project, symbol)) {
+      platform.add(url);
+    }
+  });
   const dir = dirnamePath(file.fileName);
   const found: EntryPoint[] = [];
   for (const site of sites) {
-    if (!site.platformNames.every((name) => platform.has(name))) {
+    if (
+      !site.platformNames.every((name) => platform.has(name)) ||
+      (site.url !== undefined && !platform.has(site.url))
+    ) {
       continue;
     }
     for (const named of filesNamed(files, dir, site.literal)) {
@@ -529,77 +524,6 @@ function workersOf<Brand>(
   return found;
 }
 
-/** Whether one call is `import.meta.glob(...)`. */
-function isMetaGlob(node: Node): boolean {
-  if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
-    return false;
-  }
-  const { expression, name } = node.expression;
-  return (
-    isIdentifier(name) &&
-    name.text === "glob" &&
-    isMetaProperty(expression) &&
-    expression.keywordToken === SyntaxKind.ImportKeyword
-  );
-}
-
-/**
- * The files one file loads by a computed path, each with what exports: every own file
- * below the directory a relative literal start of an `import()` or `require()` argument
- * names, other than the calling file's own directory or one holding it, which would name
- * every sibling, and
- * every own file a relative literal glob of `import.meta.glob` matches, both read against
- * the calling file's directory, as a bundler's context module reads them.
- */
-function computedImportsOf(file: SourceFile, files: SourceFiles): readonly EntryPoint[] {
-  const dir = dirnamePath(file.fileName);
-  const found: EntryPoint[] = [];
-  const below = (prefix: string): void => {
-    const target = computedLoadDirectory(dir, prefix);
-    if (target === undefined) {
-      return;
-    }
-    for (const candidate of files.byName.values()) {
-      if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
-        found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
-      }
-    }
-  };
-  const globbed = (pattern: string): void => {
-    if (!isModuleRelative(pattern)) {
-      return;
-    }
-    const expression = globExpression(resolvePath(dir, pattern));
-    for (const candidate of files.byName.values()) {
-      if (candidate !== file && expression.test(candidate.fileName)) {
-        found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
-      }
-    }
-  };
-  const visit = (node: Node): void => {
-    if (isCallExpression(node)) {
-      const [first] = node.arguments;
-      const callee = node.expression;
-      const loads =
-        callee.kind === SyntaxKind.ImportKeyword ||
-        (isIdentifier(callee) && callee.text === "require");
-      if (loads && first !== undefined) {
-        const prefix = leadingLiteral(first);
-        if (prefix !== undefined) {
-          below(prefix);
-        }
-      } else if (isMetaGlob(node) && first !== undefined) {
-        for (const pattern of literalsOf(first) ?? []) {
-          globbed(pattern);
-        }
-      }
-    }
-    node.forEachChild(visit);
-  };
-  file.forEachChild(visit);
-  return found;
-}
-
 /**
  * Every file of one project the rules enter, in no particular order and possibly more
  * than once: a file two rules enter appears once per rule.
@@ -637,7 +561,6 @@ export function entryPoints<Brand>(
       }
     }
     found.push(...workersOf(project, file, files));
-    found.push(...computedImportsOf(file, files));
   }
   for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
     found.push({ file, rule: "html-entry", source, exports: true });

package/src/file-facts.ts

@@ -6,7 +6,7 @@
 
 import type { SourceFile } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
-import { packageScope } from "./inventory.ts";
+import { packageScope } from "./load/package-scope.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { renderRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";

package/src/graph.ts

@@ -65,7 +65,6 @@ const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   worker: true,
   "html-entry": true,
   "workflow-step": true,
-  "computed-import": true,
   "document-import": true,
 };