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

package/src/dependencies.ts

@@ -31,17 +31,18 @@ import {
 } from "@typescript/native/ast";
 import { automaticTypes, type AutomaticTypes } from "./automatic-types.ts";
 import {
-  configurationFiles,
   declaredIn as declaredBeside,
   dependenciesNamed,
   moduleStrings,
   outsideChain,
+  type ConfigurationFiles,
   type OutsideModule,
   type ParseFile,
-} from "./configuration-files.ts";
+} from "./entries/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,
@@ -54,8 +55,11 @@ import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
-import { manifestCommands, nodemonTexts } from "./manifest.ts";
-import { commandFileTexts, workflowCommands } from "./workflow-steps.ts";
+import { manifestCommands, nodemonTexts } from "./roots/manifest.ts";
+import { writtenName } from "./platform-calls.ts";
+import { callsPlatform } from "./platform-symbols.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
+import type { Workflows } from "./entries/workflow-steps.ts";
 import {
   pathsNamed,
   preloadedPackages,
@@ -354,8 +358,9 @@ function bindingsOf(node: Node | undefined): readonly Texted[] {
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one. A string of a configuration file uses each dependency
- * the manifest beside the file declares that it spells.
+ * shadows the name is not one. A string of a configuration file, as the entry sources
+ * read them in `configuration`, uses each dependency the manifest beside the file
+ * declares that it spells.
  */
 export function projectNeeds<Brand>(
   project: ProjectView<Brand>,
@@ -363,6 +368,8 @@ export function projectNeeds<Brand>(
   host: Host,
   targetRoot: string,
   parse: ParseFile,
+  configuration: ConfigurationFiles,
+  workflows: Workflows,
 ): ProjectNeeds {
   const programPackages = new Set<string>();
   for (const name of project.program.getSourceFileNames()) {
@@ -416,7 +423,6 @@ export function projectNeeds<Brand>(
     return names;
   };
   const files = sourceFilesOf(project, targetRoot);
-  const configuration = configurationFiles(host, targetRoot, files, parse);
   for (const { file, manifestDir } of configuration.modules) {
     const names = declaredAt(joinPath(manifestDir, MANIFEST));
     for (const { node, text } of moduleStrings(file)) {
@@ -436,7 +442,7 @@ export function projectNeeds<Brand>(
     targetRoot,
     files,
     parse,
-    scriptRunFiles(host, targetRoot, files),
+    scriptRunFiles(host, targetRoot, files, workflows),
   );
   for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
     for (const manifestDir of manifestDirs) {
@@ -459,6 +465,7 @@ function scriptRunFiles(
   host: Host,
   targetRoot: string,
   files: SourceFiles,
+  workflows: Workflows,
 ): readonly { readonly path: string; readonly manifestDir: string }[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const dirs = new Set<string>([root]);
@@ -471,12 +478,7 @@ function scriptRunFiles(
     }
   }
   const named = new Map<string, readonly string[]>([
-    [
-      root,
-      workflowReadings(host, root)
-        .flatMap(pathsNamed)
-        .map((one) => one.path),
-    ],
+    [root, workflows.readings.flatMap(pathsNamed).map((one) => one.path)],
   ]);
   for (const dir of dirs) {
     const read = readDocument(host, joinPath(dir, MANIFEST));
@@ -521,20 +523,9 @@ function manifestUses(host: Host, dir: string, manifest: Record<string, unknown>
 }
 
 /** What the target root's workflow steps, git hooks and recipes use, held with their files' whole text. */
-function workflowUses(host: Host, targetRoot: string): CommandUses {
-  const uses = usesOf(workflowReadings(host, targetRoot));
-  return { ...uses, held: [uses.held, ...commandFileTexts(host, targetRoot)].join("\n") };
-}
-
-/**
- * What the target root's workflow steps, git hooks, hook managers and recipes run, each held
- * with the directory the file writes for it.
- */
-function workflowReadings(host: Host, targetRoot: string): readonly CommandReading[] {
-  return workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
-    const reading = readCommands(text, dir);
-    return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
-  });
+function workflowUses(workflows: Workflows): CommandUses {
+  const uses = usesOf(workflows.readings);
+  return { ...uses, held: [uses.held, ...workflows.texts].join("\n") };
 }
 
 /** What some command strings say about the packages they use. */
@@ -660,8 +651,16 @@ function fileNeeds<Brand>(
   if (names.size > 0 || automatic.globals.size > 0) {
     visit(file);
   }
+  const loads = runtimeLoads(file);
+  const callees = loads.flatMap((load) => load.callees);
 
-  const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates, ...globals];
+  const asked = [
+    ...specifiers,
+    ...bindings.map(({ node }) => node),
+    ...candidates,
+    ...globals,
+    ...callees,
+  ];
   const handles: Handle<Brand>[] = asked.map((node) => project.handle(node));
   const resolved = project.symbolsAt(handles);
 
@@ -737,35 +736,83 @@ function fileNeeds<Brand>(
   for (const reference of file.typeReferenceDirectives) {
     use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
   }
-  for (const specifier of resolvedSpecifiers(file)) {
-    const named = packageOfSpecifier(specifier.text);
-    if (named !== undefined) {
+  // A callee the checker leaves unanswered may be a require, so its call holds the
+  // dependency it names by live code, as program.33 holds one.
+  const calleesAt = unresolvedAt + globals.length;
+  const decided = new Map<string, boolean>();
+  const requires = new Set<Identifier>();
+  const unansweredCallees = new Set<Identifier>();
+  callees.forEach((callee, index) => {
+    const symbol = resolved[calleesAt + index];
+    if (symbol === UNANSWERED) {
+      unansweredCallees.add(callee);
+      return;
+    }
+    // The decision reads the callee's symbol and its written name, and nothing else of it.
+    const key = symbol === undefined ? undefined : `${symbol.id}\u0000${callee.text}`;
+    const answer =
+      (key === undefined ? undefined : decided.get(key)) ??
+      callsPlatform(project, "require", callee, symbol, () => undefined);
+    if (key !== undefined) {
+      decided.set(key, answer);
+    }
+    if (answer) {
+      requires.add(callee);
+    }
+  });
+  for (const { specifier, named, callees: through } of loads) {
+    if (through.length === 0 || through.some((one) => requires.has(one))) {
       use(ownersOf(file, held, specifier), [named]);
+    } else if (through.some((one) => unansweredCallees.has(one))) {
+      use([PROJECT_OWNER], [named]);
     }
   }
   return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 
 /**
- * The literal specifiers one file asks the runtime to resolve, through `import.meta.resolve`
- * or `require.resolve`, each of which needs the package it names installed.
+ * A call of one file that may load or resolve a package at run time: the literal specifier
+ * naming it, and the names a `require` would be written with, of which one has to be a
+ * `require` for the call to need the package; none for a use where it stands.
  */
-function resolvedSpecifiers(file: SourceFile): readonly Texted[] {
-  const found: Texted[] = [];
-  if (!file.text.includes(".resolve(")) {
-    return found;
-  }
+interface RuntimeLoad {
+  readonly specifier: Texted;
+  readonly named: string;
+  readonly callees: readonly Identifier[];
+}
+
+/**
+ * The calls one file may load or resolve a package with at run time, each of whose first
+ * argument is literal text naming a package: a `require()` call, which the compiler lists among
+ * a file's imports only in a JavaScript file and only through the bare name; a `.resolve` of
+ * another name, which needs it where that name is a `require`; and `import.meta.resolve` or
+ * a `.resolve` of the name `require`, whatever it names, a use where it stands.
+ */
+function runtimeLoads(file: SourceFile): readonly RuntimeLoad[] {
+  const found: RuntimeLoad[] = [];
   const visit = (node: Node): void => {
-    if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
-      const callee = node.expression;
+    if (isCallExpression(node)) {
       const [argument] = node.arguments;
-      const receiver = callee.expression;
-      const resolving =
-        callee.name.text === "resolve" &&
-        ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
-          (isIdentifier(receiver) && receiver.text === "require"));
-      if (resolving && argument !== undefined && isLiteralText(argument)) {
-        found.push(argument);
+      if (argument !== undefined && isLiteralText(argument)) {
+        const named = packageOfSpecifier(argument.text);
+        const callee = parenthesesRemoved(node.expression);
+        const receiver =
+          isPropertyAccessExpression(callee) && callee.name.text === "resolve"
+            ? parenthesesRemoved(callee.expression)
+            : undefined;
+        const stands =
+          receiver !== undefined &&
+          ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
+            (isIdentifier(receiver) && receiver.text === "require"));
+        const callees = stands
+          ? []
+          : [
+              writtenName(callee),
+              receiver === undefined ? undefined : writtenName(receiver),
+            ].filter((one) => one !== undefined);
+        if (named !== undefined && (stands || callees.length > 0)) {
+          found.push({ specifier: argument, named, callees });
+        }
       }
     }
     node.forEachChild(visit);
@@ -988,6 +1035,7 @@ function addNeededPeers(
 export function dependenciesOf(
   host: Host,
   targetRoot: string,
+  workflows: Workflows,
   perProject: readonly ProjectNeeds[],
   candidates: readonly string[],
   members: readonly string[] = [],
@@ -1010,7 +1058,7 @@ export function dependenciesOf(
       unbuilt.add(path);
     }
   }
-  const workflow = workflowUses(host, targetRoot);
+  const workflow = workflowUses(workflows);
   const declared: DeclaredDependency[] = [];
   const ran = new Set<string>();
   const peers = new Map<string, readonly string[]>();

package/src/entries/build-scripts.ts

@@ -0,0 +1,292 @@
+/**
+ * The files a bundler's JavaScript API builds from, read from the build scripts a
+ * manifest's scripts run: the strings an options object passes as the bundler's entries.
+ * A script is read without running it, so a value that is not written out, a computed
+ * path or an options object built at run time among them, names nothing.
+ */
+
+import {
+  isArrowFunction,
+  isCallExpression,
+  isConstructorDeclaration,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isMethodDeclaration,
+  isNewExpression,
+  isSetAccessorDeclaration,
+  isVariableDeclaration,
+  type CallExpression,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { declarationOf, membersNamed, staticModule, type Value } from "./static-module.ts";
+import { filesNamedBy, type ParseFile } from "./configuration-files.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
+import { unwrapped } from "../unwrap.ts";
+import { holdsManifest, inInstalledPackages, manifestAt } from "../fs/manifest.ts";
+import { globExpression } from "../text/glob.ts";
+import { pathsNamed, readCommands } from "../commands/read.ts";
+import { manifestCommands } from "../roots/manifest.ts";
+import { extensionOf, MODULE_EXTENSIONS } from "../extensions.ts";
+
+/** One bundler API: the module, the functions it exports that build, and the option naming entries. */
+interface BundlerAPI {
+  readonly module: string;
+  /** The exported names of the building functions; `default` is the module's own value called. */
+  readonly calls: readonly string[];
+  /** The option whose strings name the entries, read as `entries` states. */
+  readonly option: string;
+  /** The option that moves the directory the entries are read against. */
+  readonly base: string;
+  /** Whether an entry string is a path, glob characters matching, or a module request, only a relative one naming a file. */
+  readonly paths: boolean;
+}
+
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
+ * `input` against the working directory, each the manifest's directory when its script runs.
+ */
+const BUNDLERS: readonly BundlerAPI[] = [
+  {
+    module: "esbuild",
+    calls: ["build", "buildSync", "context"],
+    option: "entryPoints",
+    base: "absWorkingDir",
+    paths: true,
+  },
+  { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
+  { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
+];
+
+/** One own file a build script's bundler call names as an entry. */
+interface BuildEntry {
+  readonly file: SourceFile;
+  /** The string that named it. */
+  readonly source: string;
+}
+
+/** One path an entry value writes. */
+interface EntryPath {
+  readonly path: string;
+  /** What the script writes for it. */
+  readonly text: string;
+  /** Whether it is written as neither a relative nor an absolute path. */
+  readonly request: boolean;
+}
+
+/** The one value an object writes last for a key, undefined where it writes none or may hide it. */
+function lastMember(object: Value, key: string): Value | undefined {
+  return membersNamed(object, key)?.at(-1);
+}
+
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a join of the
+ * script's own directory and literals, read against that directory.
+ */
+function pathOf(value: Value, dir: string, scriptDir: string): EntryPath | undefined {
+  if (value.kind === "text") {
+    const { text } = value;
+    const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
+    return { path: resolvePath(dir, text), text, request };
+  }
+  if (value.kind === "directory") {
+    const joined = value.segments.join("/");
+    return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+  }
+  return undefined;
+}
+
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(value: Value): readonly Value[] {
+  if (value.kind === "array") {
+    return value.elements.flatMap(entryValues);
+  }
+  if (value.kind === "object") {
+    const imported = lastMember(value, "import") ?? lastMember(value, "in");
+    if (imported !== undefined) {
+      return entryValues(imported);
+    }
+    return value.members.flatMap((member) => entryValues(member.value));
+  }
+  return [value];
+}
+
+/** The own files one entry string names, read as `api` reads it. */
+function entriesNamed(
+  files: SourceFiles,
+  api: BundlerAPI,
+  entry: EntryPath,
+): readonly SourceFile[] {
+  if (!api.paths && entry.request) {
+    return [];
+  }
+  if (api.paths && /[*?[{]/u.test(entry.text)) {
+    const expression = globExpression(entry.path);
+    return [...files.byName.values()].filter((file) => expression.test(file.fileName));
+  }
+  const dir = dirnamePath(entry.path);
+  return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
+}
+
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunction(node: Node): boolean {
+  return (
+    isFunctionDeclaration(node) ||
+    isFunctionExpression(node) ||
+    isArrowFunction(node) ||
+    isMethodDeclaration(node) ||
+    isConstructorDeclaration(node) ||
+    isGetAccessorDeclaration(node) ||
+    isSetAccessorDeclaration(node)
+  );
+}
+
+/**
+ * The calls one build script runs: those of its top level, and those of each function a
+ * call it runs calls or passes on, as a callee, an argument or a function called where it
+ * is written, a name read through to the function it declares.
+ */
+function runCalls(file: SourceFile, each: (call: CallExpression) => void): void {
+  const ran = new Set<Node>();
+  const run = (fn: Node): void => {
+    if (!ran.has(fn)) {
+      ran.add(fn);
+      fn.forEachChild(visit);
+    }
+  };
+  const runs = (node: Node): void => {
+    const at = unwrapped(node);
+    const declared = isIdentifier(at) ? declarationOf(at) : undefined;
+    const fn =
+      declared !== undefined && isVariableDeclaration(declared) && declared.initializer
+        ? unwrapped(declared.initializer)
+        : (declared ?? at);
+    if (isFunction(fn)) {
+      run(fn);
+    }
+  };
+  const visit = (node: Node): void => {
+    if (isFunction(node)) {
+      return;
+    }
+    if (isCallExpression(node) || isNewExpression(node)) {
+      if (isCallExpression(node)) {
+        each(node);
+      }
+      runs(node.expression);
+      for (const argument of node.arguments ?? []) {
+        runs(argument);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+}
+
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file: SourceFile, dir: string, files: SourceFiles): readonly BuildEntry[] {
+  const module = staticModule(file);
+  const building = new Map<CallExpression, BundlerAPI>();
+  for (const api of BUNDLERS) {
+    for (const one of module.calls(api.module)) {
+      if (api.calls.includes(one.export)) {
+        building.set(one.call, api);
+      }
+    }
+  }
+  const scriptDir = dirnamePath(file.fileName);
+  const found: BuildEntry[] = [];
+  runCalls(file, (call) => {
+    const api = building.get(call);
+    if (api === undefined) {
+      return;
+    }
+    for (const options of module.argument(call)) {
+      const entries = lastMember(options, api.option);
+      const base = api.base === "" ? undefined : lastMember(options, api.base);
+      const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
+      if (entries === undefined || against === undefined) {
+        continue;
+      }
+      for (const value of entryValues(entries)) {
+        const named = pathOf(value, against.path, scriptDir);
+        if (named === undefined) {
+          continue;
+        }
+        for (const entry of entriesNamed(files, api, named)) {
+          found.push({ file: entry, source: named.text });
+        }
+      }
+    }
+  });
+  return found;
+}
+
+/** The modules one manifest's command strings run or name, by absolute path, each below the target root. */
+function scriptModules(host: Host, root: string, dir: string): readonly string[] {
+  const manifest = manifestAt(host, dir);
+  const found = new Set<string>();
+  for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
+    for (const { path } of pathsNamed(readCommands(command, dir))) {
+      if (
+        extensionOf(path, MODULE_EXTENSIONS) !== undefined &&
+        relativePath(root, path) !== undefined &&
+        !inInstalledPackages(path) &&
+        host.kindOf(path) === "file"
+      ) {
+        found.add(path);
+      }
+    }
+  }
+  return [...found].sort(bytewise);
+}
+
+/**
+ * Every own file of one project a build script names as a bundler's entry: a module a
+ * script of a manifest at or above an own file runs, below the target root, read from
+ * the program where it holds the module and parsed alone otherwise, where a parser is given.
+ */
+export function buildScriptEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile | undefined,
+): readonly BuildEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const dirs = new Set<string>([root]);
+  for (const file of files.byName.values()) {
+    for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+      if (dirs.has(dir)) {
+        break;
+      }
+      dirs.add(dir);
+    }
+  }
+  const found: BuildEntry[] = [];
+  for (const dir of [...dirs].sort(bytewise)) {
+    if (!holdsManifest(host, dir)) {
+      continue;
+    }
+    for (const path of scriptModules(host, root, dir)) {
+      let script = files.byName.get(path);
+      if (script === undefined && parse !== undefined) {
+        try {
+          script = parse(path, host.readFile(path));
+        } catch {
+          continue;
+        }
+      }
+      if (script !== undefined) {
+        found.push(...scriptEntries(script, dir, files));
+      }
+    }
+  }
+  return found;
+}