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

package/src/dependencies.ts

@@ -29,24 +29,26 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { amdLoadOf, amdPlatform } from "./amd.ts";
 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 { declarationBindings } from "./import-bindings.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { packageScope } from "./load/package-scope.ts";
 import {
   ancestors,
+  cannotStartPackageName,
   dirnamePath,
-  isAbsolutePath,
   joinPath,
   relativePath,
   resolvePath,
@@ -55,8 +57,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,
@@ -299,7 +304,7 @@ function configurationPackages(
     }
     seen.add(file);
     for (const entry of extendsOf(host, file, parse)) {
-      if (entry.startsWith(".") || isAbsolutePath(entry)) {
+      if (cannotStartPackageName(entry)) {
         const local = resolvePath(dirnamePath(file), entry);
         pending.push(local.endsWith(".json") ? local : `${local}.json`);
       } else {
@@ -329,34 +334,18 @@ function importOf(specifier: Node): Node | undefined {
 
 /** The local names one import declaration binds. */
 function bindingsOf(node: Node | undefined): readonly Texted[] {
-  if (node === undefined) {
-    return [];
-  }
-  if (isImportEqualsDeclaration(node)) {
-    return [node.name];
-  }
-  if (!isImportDeclaration(node) || node.importClause === undefined) {
-    return [];
-  }
-  const clause = node.importClause;
-  const names: Texted[] = clause.name === undefined ? [] : [clause.name];
-  const bindings = clause.namedBindings;
-  if (bindings !== undefined) {
-    if (bindings.kind === SyntaxKind.NamespaceImport) {
-      names.push(bindings.name);
-    } else {
-      names.push(...bindings.elements.map((element) => element.name));
-    }
-  }
-  return names;
+  return node !== undefined && (isImportDeclaration(node) || isImportEqualsDeclaration(node))
+    ? declarationBindings(node).map((binding) => binding.name)
+    : [];
 }
 
 /**
  * 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>,
@@ -364,6 +353,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()) {
@@ -417,7 +408,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)) {
@@ -437,7 +427,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) {
@@ -460,6 +450,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]);
@@ -472,12 +463,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));
@@ -522,20 +508,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. */
@@ -661,8 +636,17 @@ 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 amdCallees = new Set(loads.flatMap((load) => (load.amd ? 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);
 
@@ -738,35 +722,96 @@ 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, its written name and its platform name, and nothing else.
+    const platform = amdCallees.has(callee) ? amdPlatform(callee) : "require";
+    const key =
+      symbol === undefined ? undefined : `${symbol.id}\u0000${platform}\u0000${callee.text}`;
+    const answer =
+      (key === undefined ? undefined : decided.get(key)) ??
+      callsPlatform(project, platform, callee, symbol);
+    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[];
+  /** Whether the specifier is an id of an AMD call's dependency list, its callee AMD's `define` or `require`. */
+  readonly amd: boolean;
+}
+
+/**
+ * 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; and each id of
+ * an AMD dependency list (references-ts.37), which needs it where the call is AMD's.
+ */
+function runtimeLoads(file: SourceFile): readonly RuntimeLoad[] {
+  const found: RuntimeLoad[] = [];
   const visit = (node: Node): void => {
-    if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
-      const callee = node.expression;
+    const amd = amdLoadOf(node);
+    if (amd !== undefined) {
+      for (const { id } of amd.ids) {
+        const named = packageOfSpecifier(id.text);
+        if (named !== undefined) {
+          found.push({ specifier: id, named, callees: [amd.callee], amd: true });
+        }
+      }
+    } else 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, amd: false });
+        }
       }
     }
     node.forEachChild(visit);
@@ -989,6 +1034,7 @@ function addNeededPeers(
 export function dependenciesOf(
   host: Host,
   targetRoot: string,
+  workflows: Workflows,
   perProject: readonly ProjectNeeds[],
   candidates: readonly string[],
   members: readonly string[] = [],
@@ -1011,7 +1057,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/destructuring.ts

@@ -213,17 +213,6 @@ function sourceOf(target: Node): Source | undefined {
   }
 }
 
-/** What resolving one project's property reads cost at the client boundary. */
-interface DestructuringCost {
-  /** Batched type lookups, one per capped run of a file's patterns and assigned values. */
-  readonly patternBatches: number;
-  /**
-   * Per-type lookups: one property table per distinct destructured type, and each step
-   * an assignment target takes into its assigned value.
-   */
-  readonly patternLookups: number;
-}
-
 /** Resolves property reads to the symbols the destructured values' types declare. */
 interface Destructuring {
   /**
@@ -232,7 +221,6 @@ interface Destructuring {
    * {@link UNANSWERED} where a question about the value's type went unanswered.
    */
   resolve(reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[];
-  readonly cost: DestructuringCost;
 }
 
 /** A type along a destructuring, or the mark that a question about it went unanswered. */
@@ -250,8 +238,6 @@ export function destructuring<Brand>(
 ): Destructuring {
   const queries = project.queries;
   const tables = new Map<number, Answer<ReadonlyMap<string, TSSymbol>>>();
-  let patternBatches = 0;
-  let patternLookups = 0;
 
   const tableOf = (type: Type): Answer<ReadonlyMap<string, TSSymbol>> => {
     const known = tables.get(type.id);
@@ -261,7 +247,6 @@ export function destructuring<Brand>(
     let table: Answer<ReadonlyMap<string, TSSymbol>> = new Map<string, TSSymbol>();
     if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
       const read = properties.of(type);
-      patternLookups += read.asked ? 1 : 0;
       table = isAnswered(read.properties)
         ? new Map(read.properties.map((property) => [property.name, property]))
         : UNANSWERED;
@@ -274,7 +259,6 @@ export function destructuring<Brand>(
     if ((type.flags & TypeFlags.Union) === 0) {
       return type;
     }
-    patternLookups += 1;
     return queries.nonNullable(type);
   };
 
@@ -290,11 +274,9 @@ export function destructuring<Brand>(
       if (index === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       const elements = queries.typeArguments(type);
       return isAnswered(elements) ? elements[index] : UNANSWERED;
     }
-    patternLookups += 1;
     const array = queries.isArray(type);
     if (!isAnswered(array)) {
       return UNANSWERED;
@@ -302,7 +284,6 @@ export function destructuring<Brand>(
     if (!array) {
       return undefined;
     }
-    patternLookups += 1;
     const elements = queries.typeArguments(type);
     return isAnswered(elements) ? elements[0] : UNANSWERED;
   };
@@ -320,7 +301,6 @@ export function destructuring<Brand>(
     if (more.length > 0) {
       return UNANSWERED;
     }
-    patternLookups += 1;
     return queries.typeOfSymbol(property);
   };
 
@@ -328,7 +308,6 @@ export function destructuring<Brand>(
     if (callee === undefined || callee === UNANSWERED) {
       return callee;
     }
-    patternLookups += 1;
     const signatures = queries.signaturesOf(callee, SignatureKind.Call);
     if (!isAnswered(signatures)) {
       return UNANSWERED;
@@ -337,7 +316,6 @@ export function destructuring<Brand>(
     if (signature === undefined) {
       return undefined;
     }
-    patternLookups += 1;
     return queries.returnTypeOf(signature);
   };
 
@@ -369,7 +347,6 @@ export function destructuring<Brand>(
     if (result !== undefined && result !== UNANSWERED) {
       let parts: Answer<readonly Type[]> = [result];
       if (result.isUnionType()) {
-        patternLookups += 1;
         parts = queries.constituents(result);
       }
       const values: readonly Found[] = isAnswered(parts)
@@ -403,7 +380,6 @@ export function destructuring<Brand>(
       if (property === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       return queries.typeOfSymbol(property);
     }
     return elementOf(defined, next.index);
@@ -425,7 +401,6 @@ export function destructuring<Brand>(
       }
     }
     const asked = [...asking];
-    patternBatches += Math.ceil(asked.length / cap);
     const answered = new Map<Node, Found>();
     queries.typesAt(asked, cap).forEach((type, index) => {
       const node = asked[index];
@@ -456,10 +431,5 @@ export function destructuring<Brand>(
     });
   };
 
-  return {
-    resolve,
-    get cost() {
-      return { patternBatches, patternLookups };
-    },
-  };
+  return { resolve };
 }