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

package/src/suppress-inline.ts

@@ -5,18 +5,21 @@
  */
 
 import { CODE } from "./contract/contract.generated.ts";
-import {
-  isConstructorDeclaration,
-  SyntaxKind,
-  type Node,
-  type SourceFile,
-} from "@typescript/native/ast";
+import { SyntaxKind, type Node, type SourceFile } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.ts";
-import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
-import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { relativePath } from "./paths.ts";
+import {
+  byPosition,
+  lineEnd,
+  positionKey,
+  renderPosition,
+  startLine,
+  tokenStart,
+  type Position,
+} from "./position.ts";
 import { importRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
-import { signatureOf } from "./signatures.ts";
 import {
   isPartKind,
   SuppressionError,
@@ -88,43 +91,6 @@ const LITERALS: ReadonlySet<SyntaxKind> = new Set([
   SyntaxKind.JsxText,
 ]);
 
-/** Whether one character ends a line, under the language's line terminators. */
-function endsLine(char: string | undefined): boolean {
-  return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
-}
-
-/** The offset where the line holding `from` ends. */
-function lineEnd(text: string, from: number): number {
-  let at = from;
-  while (at < text.length && !endsLine(text[at])) {
-    at += 1;
-  }
-  return at;
-}
-
-/**
- * The offset of the first token at or after `from`: whitespace, comments and a leading
- * hashbang are trivia.
- */
-export function tokenStart(text: string, from: number): number {
-  let at = from;
-  if (at === 0 && text.startsWith("#!")) {
-    at = lineEnd(text, 0);
-  }
-  for (;;) {
-    if (/\s/u.test(text[at] ?? "")) {
-      at += 1;
-    } else if (text.startsWith("//", at)) {
-      at = lineEnd(text, at);
-    } else if (text.startsWith("/*", at)) {
-      const close = text.indexOf("*/", at + 2);
-      at = close < 0 ? text.length : close + 2;
-    } else {
-      return at;
-    }
-  }
-}
-
 /**
  * Every `//` line comment of one file, in file order. The text between tokens is read as
  * the language reads it: a block comment holds no line comment, and the literal tokens the
@@ -191,63 +157,59 @@ function bindingKey(one: Binding): string {
   return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
 
+/** One declaration the inventory places, the declaration that holds its parts, and its lines. */
+interface Placed {
+  readonly one: Declared;
+  readonly holder: Declared;
+  readonly startLines: readonly number[];
+  readonly partLines: readonly number[];
+}
+
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(
+  held: Inventory,
+  symbols: ReadonlyMap<string, Declared>,
+): ReadonlyMap<string, readonly Placed[]> {
+  const byPath = new Map<string, Placed[]>();
+  for (const [id, placed] of held.placement) {
+    const one = symbols.get(id);
+    const holder = symbols.get(placed.holder);
+    if (one === undefined || holder === undefined) {
+      continue;
+    }
+    const at = byPath.get(one.position.path) ?? [];
+    at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+    byPath.set(one.position.path, at);
+  }
+  return byPath;
+}
+
 /**
- * The declarations of one file by the line each begins on, the line of its first token: a
- * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
 function declarationLines(
   file: SourceFile,
+  placed: readonly Placed[],
   held: Inventory,
-  symbols: ReadonlyMap<string, Declared>,
   targetRoot: string,
 ): ReadonlyMap<number, readonly Binding[]> {
   const below = new Map<number, Binding[]>();
-  const add = (offset: number, one: Binding): void => {
-    const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+  const add = (line: number, one: Binding): void => {
     const at = below.get(line) ?? [];
     if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
       at.push(one);
     }
     below.set(line, at);
   };
-  const declaredAt = (node: Node): Declared | undefined => {
-    const id = held.declarations.get(nodeKey(file, node));
-    return id === undefined ? undefined : symbols.get(id);
-  };
-  const visit = (node: Node): void => {
-    const one = declaredAt(node);
-    const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-    if (owner !== undefined && isConstructorDeclaration(node)) {
-      for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-        add(at.pos, { declared: undefined, part: owner });
-      }
+  for (const { one, holder, startLines, partLines } of placed) {
+    for (const line of startLines) {
+      add(line, { declared: one, part: holder });
     }
-    const holder =
-      one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-    if (one !== undefined && holder !== undefined) {
-      add(node.pos, { declared: one, part: holder });
-    }
-    if (one !== undefined) {
-      // A parameter on a later line of a wrapped signature takes its directive on the
-      // line above it, inside the parameter list, and the directive binds the function.
-      for (const parameter of signatureOf(node)?.parameters ?? []) {
-        add(parameter.pos, { declared: one, part: one });
-      }
-      const list = node.parent;
-      if (
-        node.kind === SyntaxKind.VariableDeclaration &&
-        list.kind === SyntaxKind.VariableDeclarationList &&
-        list.parent.kind === SyntaxKind.VariableStatement
-      ) {
-        add(list.parent.pos, { declared: one, part: one });
-      }
+    for (const line of partLines) {
+      add(line, { declared: undefined, part: one });
     }
-    node.forEachChild(visit);
-  };
-  file.forEachChild(visit);
+  }
   // An import binding is a subject of its own, bound on its line as a declaration is.
   const fileId = held.declarations.get(nodeKey(file, file));
   const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -259,7 +221,7 @@ function declarationLines(
       statement = statement.parent;
     }
     for (const at of [statement.pos, name.getStart()]) {
-      add(at, { declared: one, part: one });
+      add(startLine(file, at), { declared: one, part: one });
     }
   }
   return below;
@@ -296,13 +258,15 @@ export function inlineDirectives<Brand>(
       .filter((symbol) => symbol.kind !== "file")
       .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]),
   );
+  const placed = placedByPath(held, symbols);
   const found: InlineDirective[] = [];
   for (const file of project.ownSourceFiles()) {
     const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
     if (comments.length === 0) {
       continue;
     }
-    const below = declarationLines(file, held, symbols, targetRoot);
+    const path = relativePath(targetRoot, file.fileName) ?? "";
+    const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
     for (const comment of comments) {
       const site = renderPosition(file, targetRoot, comment.offset);
       const target = trails(file, comment.offset) ? site.line : site.line + 1;

package/src/unseen-loads.ts

@@ -1,26 +1,36 @@
 /**
- * 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,
+  isMetaProperty,
   isNoSubstitutionTemplateLiteral,
+  isObjectLiteralExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
   isStringLiteral,
   isTemplateExpression,
   SyntaxKind,
+  type CallExpression,
+  type Identifier,
   type Node,
+  type SourceFile,
 } from "@typescript/native/ast";
+import { literalsOf } from "./entry-points.ts";
+import { hasOwnBody } from "./own-body.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { renderPosition, type Position } from "./position.ts";
-import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import { unwrapped } from "./unwrap.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** One load the analysis cannot resolve, in the configuration whose production file writes it. */
 export interface UnseenLoad {
@@ -30,7 +40,7 @@ export interface UnseenLoad {
 }
 
 /** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-export function leadingLiteral(node: Node): string | undefined {
+function leadingLiteral(node: Node): string | undefined {
   const at = unwrapped(node);
   if (isTemplateExpression(at)) {
     return at.head.text;
@@ -45,11 +55,11 @@ export function leadingLiteral(node: Node): string | 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: string, prefix: string): string | undefined {
+function computedLoadDirectory(dir: string, prefix: string): string | undefined {
   if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
     return undefined;
   }
@@ -57,6 +67,150 @@ export function computedLoadDirectory(dir: string, prefix: string): string | und
   return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
 }
 
+/** One `import()`, `require()` or `import.meta.glob()` call, and the declaration whose code writes it. */
+export interface LoadCall {
+  readonly call: CallExpression;
+  readonly from: string;
+}
+
+/** One file a computed load may load, by its id. */
+interface Loadable {
+  readonly file: SourceFile;
+  readonly fileId: string;
+}
+
+/** One load by a computed path whose files the analysis resolves. */
+interface ComputedLoad {
+  readonly call: CallExpression;
+  readonly from: string;
+  /** The `require` the call names; {@link hasOwnBody} owns which one loads nothing. */
+  readonly require: Identifier | undefined;
+  readonly files: readonly Loadable[];
+  /** Whether the load reads each file as text or as a URL, which references no declaration of it. */
+  readonly asset: boolean;
+  /**
+   * Whether the load is an eager glob, which Vite turns into static imports at the top of
+   * the calling module (https://vite.dev/guide/features.html#glob-import), so the file
+   * evaluates what it loads wherever the call is written.
+   */
+  readonly eager: boolean;
+}
+
+/** Whether one node is a call that may load a module by a computed path. */
+export function isLoadCall(node: Node): node is CallExpression {
+  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: SourceFile,
+  calls: readonly LoadCall[],
+  candidates: readonly Loadable[],
+): readonly ComputedLoad[] {
+  const dir = dirnamePath(file.fileName);
+  const others = candidates.filter((candidate) => candidate.file !== file);
+  return calls.flatMap(({ call, from }): ComputedLoad[] => {
+    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: CallExpression): boolean {
+  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: Node | undefined): readonly [string, Node][] {
+  const literal = options === undefined ? undefined : unwrapped(options);
+  if (literal === undefined || !isObjectLiteralExpression(literal)) {
+    return [];
+  }
+  return literal.properties.flatMap((property): [string, Node][] =>
+    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: Node | undefined): boolean {
+  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: Node | undefined): boolean {
+  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: string | undefined): boolean {
   return (
@@ -71,8 +225,7 @@ function namesPackage(prefix: string | undefined): boolean {
 /**
  * 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<Brand>(
   project: ProjectView<Brand>,
@@ -116,15 +269,10 @@ export function unseenLoadsOf<Brand>(
     file.forEachChild(visit);
   }
   const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
-  const own = project.ownPaths();
   const local = new Set<Node>();
   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);
     }
   });