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

package/src/element-access.ts

@@ -41,12 +41,8 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import type { Type } from "@typescript/native/sync";
-import type { AliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
-import type { Reference } from "./references.ts";
-import type { ProjectView } from "./session.ts";
+import type { Read, ReadRule } from "./references/read-rule.ts";
 import { parenthesesRemoved } from "./unwrap.ts";
 
 type Use = "read" | "write" | "both";
@@ -242,190 +238,200 @@ interface Candidate {
 }
 
 /**
- * The references the element accesses of one project's own files make to the members their
- * index's literal type names, each made by the declaration holding the access or the call.
+ * The reads the element accesses of a side's files make of the members their index's literal
+ * type names, each made by the declaration holding the access or the call. A type the checker
+ * leaves unanswered holds what its answer could have read.
  */
-export function elementAccessReferences<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  chains: AliasChains,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const queries = project.queries;
-  const candidates: Candidate[] = [];
-  const calls = new Map<Node, { readonly file: SourceFile; readonly from: string }>();
-  const names: Identifier[] = [];
-
-  for (const file of project.ownSourceFiles()) {
-    const fileId = held.declarations.get(nodeKey(file, file));
-    if (fileId === undefined) {
-      continue;
-    }
-    const visit = (node: Node, from: string): void => {
-      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-      if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
-        candidates.push({ file, from: holder, access: node, use: useOf(node) });
-      }
-      if (isCallExpression(node)) {
-        calls.set(node, { file, from: holder });
-      }
-      if (isIdentifier(node)) {
-        names.push(node);
-      }
-      node.forEachChild((child) => {
-        visit(child, holder);
-      });
-    };
-    file.forEachChild((child) => {
-      visit(child, fileId);
-    });
-  }
-  if (candidates.length === 0) {
-    return [];
-  }
-
-  // A parameter index is decided at the calls only where the function is a callable every
-  // use of which is a call, so the symbols of the parameters and of every name are read.
-  const parameterOf = new Map<Candidate, { callable: Callable; at: number }>();
-  const byCallable = new Map<Identifier, Candidate[]>();
-  for (const candidate of candidates) {
-    const index = parenthesesRemoved(candidate.access.argumentExpression);
-    const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
-    const callable = fn === undefined ? undefined : callableOf(fn);
-    if (callable === undefined || !isIdentifier(index)) {
-      continue;
-    }
-    const at = callable.parameters.findIndex(
-      (parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text,
-    );
-    if (at < 0 || assigns(callable.body, index.text)) {
-      continue;
-    }
-    parameterOf.set(candidate, { callable, at });
-    byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
-  }
-  const callableNames = [...byCallable.keys()];
-  const spelled = new Set(callableNames.map((name) => name.text));
-  const sameName = names.filter((name) => spelled.has(name.text));
-  const symbols = queries.symbolsAt([...callableNames, ...sameName]);
-  const symbolOf = new Map<Node, unknown>();
-  [...callableNames, ...sameName].forEach((node, at) => {
-    const symbol = symbols[at];
-    if (symbol !== UNANSWERED && symbol !== undefined) {
-      symbolOf.set(node, symbol);
-    }
-  });
-  const callsOf = new Map<Node, CallExpression[] | undefined>();
-  for (const name of callableNames) {
-    const symbol = symbolOf.get(name);
-    let found: CallExpression[] | undefined = symbol === undefined ? undefined : [];
-    for (const use of sameName) {
-      if (found === undefined) {
-        break;
-      }
-      if (use === name || symbolOf.get(use) !== symbol) {
-        continue;
-      }
-      const parent = use.parent;
-      found =
-        isCallExpression(parent) && parent.expression === use ? [...found, parent] : undefined;
-    }
-    callsOf.set(name, found);
-  }
-
-  const lookups: Lookup[] = [];
-  for (const candidate of candidates) {
-    const deferred = parameterOf.get(candidate);
-    const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
-    if (deferred === undefined || sites === undefined) {
-      lookups.push({
-        file: candidate.file,
-        from: candidate.from,
-        at: candidate.access.argumentExpression,
-        object: candidate.access.expression,
-        index: candidate.access.argumentExpression,
-        use: candidate.use,
-      });
-      continue;
-    }
-    // An object that is a parameter too is read as the argument each call passes there.
-    const object = parenthesesRemoved(candidate.access.expression);
-    const objectAt = isIdentifier(object)
-      ? deferred.callable.parameters.findIndex(
-          (parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text,
-        )
-      : -1;
-    for (const call of sites) {
-      const parameter = deferred.callable.parameters[deferred.at];
-      const index = call.arguments[deferred.at] ?? parameter?.initializer;
-      const site = calls.get(call);
-      if (index === undefined || site === undefined) {
-        continue;
-      }
-      lookups.push({
-        file: site.file,
-        from: site.from,
-        at: call,
-        object:
-          (objectAt < 0 ? undefined : call.arguments[objectAt]) ?? candidate.access.expression,
-        index,
-        use: candidate.use,
-      });
-    }
-  }
-
-  const nodes = lookups.flatMap((one) => [one.index, one.object]);
-  const types = queries.typesAt(nodes);
-  const typeOf = (node: Node, at: number): Type | undefined => {
-    const type = types[at];
-    return nodes[at] === node && type !== UNANSWERED ? type : undefined;
-  };
-  // A type parameter's body serves every instantiation, so it reads what its constraint admits.
-  const keysOf = (type: Type): Type => {
-    if (!type.isTypeParameter()) {
-      return type;
-    }
-    const constraint = queries.constraintOf(type);
-    return constraint === UNANSWERED || constraint === undefined ? type : constraint;
-  };
-  const partsOf = (type: Type): readonly Type[] => {
-    const parts = queries.constituents(type);
-    return parts === UNANSWERED ? [type] : parts;
-  };
+export const elementAccess: ReadRule = {
+  start() {
+    const candidates: Candidate[] = [];
+    const calls = new Map<Node, { readonly file: SourceFile; readonly from: string }>();
+    const names: Identifier[] = [];
+    return {
+      visit(node, { file, from }) {
+        if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
+          candidates.push({ file, from, access: node, use: useOf(node) });
+        }
+        if (isCallExpression(node)) {
+          calls.set(node, { file, from });
+        }
+        if (isIdentifier(node)) {
+          names.push(node);
+        }
+      },
+      reads({ project, chains }) {
+        const found: Read[] = [];
+        if (candidates.length === 0) {
+          return found;
+        }
+        const queries = project.queries;
+        // A parameter index is decided at the calls only where the function is a callable every
+        // use of which is a call, so the symbols of the parameters and of every name are read.
+        const parameterOf = new Map<Candidate, { callable: Callable; at: number }>();
+        const byCallable = new Map<Identifier, Candidate[]>();
+        for (const candidate of candidates) {
+          const index = parenthesesRemoved(candidate.access.argumentExpression);
+          const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
+          const callable = fn === undefined ? undefined : callableOf(fn);
+          if (callable === undefined || !isIdentifier(index)) {
+            continue;
+          }
+          const at = callable.parameters.findIndex(
+            (parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text,
+          );
+          if (at < 0 || assigns(callable.body, index.text)) {
+            continue;
+          }
+          parameterOf.set(candidate, { callable, at });
+          byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
+        }
+        const callableNames = [...byCallable.keys()];
+        const spelled = new Set(callableNames.map((name) => name.text));
+        const sameName = names.filter((name) => spelled.has(name.text));
+        const asked = [...callableNames, ...sameName];
+        const symbols = queries.symbolsAt(asked);
+        const symbolOf = new Map<Node, unknown>();
+        asked.forEach((node, at) => {
+          const symbol = symbols[at];
+          if (symbol !== undefined) {
+            symbolOf.set(node, symbol);
+          }
+        });
+        const callsOf = new Map<Node, CallExpression[] | undefined>();
+        for (const name of callableNames) {
+          const symbol = symbolOf.get(name);
+          let sites: CallExpression[] | undefined =
+            symbol === undefined || symbol === UNANSWERED ? undefined : [];
+          for (const use of sameName) {
+            if (sites === undefined) {
+              break;
+            }
+            const other = symbolOf.get(use);
+            if (use === name || (other !== symbol && other !== UNANSWERED)) {
+              continue;
+            }
+            // A use the checker could not resolve may be the function's, read where it is not called.
+            const parent = use.parent;
+            sites =
+              other !== UNANSWERED && isCallExpression(parent) && parent.expression === use
+                ? [...sites, parent]
+                : undefined;
+          }
+          callsOf.set(name, sites);
+        }
 
-  const found: Reference[] = [];
-  lookups.forEach((lookup, at) => {
-    const indexType = typeOf(lookup.index, 2 * at);
-    const objectType = typeOf(lookup.object, 2 * at + 1);
-    const literals = indexType === undefined ? undefined : literalNames(partsOf(keysOf(indexType)));
-    if (objectType === undefined || literals === undefined) {
-      return;
-    }
-    const position = renderPosition(lookup.file, root, lookup.at.getStart());
-    for (const part of partsOf(objectType)) {
-      const properties = queries.propertiesOf(part);
-      for (const property of properties === UNANSWERED ? [] : properties) {
-        if (!literals.has(property.escapedName)) {
-          continue;
+        const lookups: Lookup[] = [];
+        for (const candidate of candidates) {
+          const deferred = parameterOf.get(candidate);
+          const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
+          if (deferred === undefined || sites === undefined) {
+            lookups.push({
+              file: candidate.file,
+              from: candidate.from,
+              at: candidate.access.argumentExpression,
+              object: candidate.access.expression,
+              index: candidate.access.argumentExpression,
+              use: candidate.use,
+            });
+            continue;
+          }
+          // An object that is a parameter too is read as the argument each call passes there.
+          const object = parenthesesRemoved(candidate.access.expression);
+          const objectAt = isIdentifier(object)
+            ? deferred.callable.parameters.findIndex(
+                (parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text,
+              )
+            : -1;
+          for (const call of sites) {
+            const parameter = deferred.callable.parameters[deferred.at];
+            const index = call.arguments[deferred.at] ?? parameter?.initializer;
+            const site = calls.get(call);
+            if (index === undefined || site === undefined) {
+              continue;
+            }
+            lookups.push({
+              file: site.file,
+              from: site.from,
+              at: call,
+              object:
+                (objectAt < 0 ? undefined : call.arguments[objectAt]) ??
+                candidate.access.expression,
+              index,
+              use: candidate.use,
+            });
+          }
         }
-        for (const to of chains.declarationsOf(property)) {
-          for (const use of lookup.use === "both" ? (["read", "write"] as const) : [lookup.use]) {
+
+        const nodes = lookups.flatMap((one) => [one.index, one.object]);
+        const types = queries.typesAt(nodes);
+        // A type parameter's body serves every instantiation, so it reads what its constraint admits.
+        const keysOf = (type: Type): Type => {
+          if (!type.isTypeParameter()) {
+            return type;
+          }
+          const constraint = queries.constraintOf(type);
+          return constraint === UNANSWERED || constraint === undefined ? type : constraint;
+        };
+        const partsOf = (type: Type): readonly Type[] => {
+          const parts = queries.constituents(type);
+          return parts === UNANSWERED ? [type] : parts;
+        };
+        lookups.forEach((lookup, at) => {
+          const indexType = types[2 * at];
+          const objectType = types[2 * at + 1];
+          const literals =
+            indexType === undefined || indexType === UNANSWERED
+              ? undefined
+              : literalNames(partsOf(keysOf(indexType)));
+          if (indexType === UNANSWERED || objectType === UNANSWERED) {
             found.push({
+              kind: "held",
               from: lookup.from,
-              to,
-              position,
-              use,
-              resolution: "keyed",
-              test: testFiles.has(position.path),
+              ...(literals === undefined ? {} : { names: [...literals] }),
+              ...(objectType === UNANSWERED || objectType === undefined
+                ? literals === undefined
+                  ? { members: true as const }
+                  : {}
+                : { types: partsOf(objectType) }),
             });
+            return;
           }
-        }
-      }
-    }
-  });
-  return found;
-}
+          if (objectType === undefined || literals === undefined) {
+            return;
+          }
+          for (const part of partsOf(objectType)) {
+            const properties = queries.propertiesOf(part);
+            if (properties === UNANSWERED) {
+              found.push({ kind: "held", from: lookup.from, names: [...literals] });
+              continue;
+            }
+            for (const property of properties) {
+              if (!literals.has(property.escapedName)) {
+                continue;
+              }
+              for (const to of chains.declarationsOf(property)) {
+                for (const use of lookup.use === "both"
+                  ? (["read", "write"] as const)
+                  : [lookup.use]) {
+                  found.push({
+                    kind: "named",
+                    from: lookup.from,
+                    to,
+                    file: lookup.file,
+                    at: lookup.at,
+                    use,
+                    via: "keyed",
+                  });
+                }
+              }
+            }
+          }
+        });
+        return found;
+      },
+    };
+  },
+};
 
 /** The names a union of literal types spells, or none where a constituent is no string or number literal. */
 function literalNames(parts: readonly Type[]): ReadonlySet<string> | undefined {

package/src/entries/build-scripts.ts

@@ -24,7 +24,7 @@ import {
 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 { ancestors, dirnamePath, isExplicitPath, relativePath, resolvePath } from "../paths.ts";
 import type { SourceFiles } from "../source-files.ts";
 import { bytewise } from "../text/compare.ts";
 import { unwrapped } from "../unwrap.ts";
@@ -93,7 +93,7 @@ function lastMember(object: Value, key: string): Value | undefined {
 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("/");
+    const request = !isExplicitPath(text);
     return { path: resolvePath(dir, text), text, request };
   }
   if (value.kind === "directory") {

package/src/entries/configuration-files.ts

@@ -15,7 +15,15 @@ import {
 } from "@typescript/native/ast";
 import { relativeSpecifiers } from "./static-module.ts";
 import type { Host } from "../host.ts";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isAbsolutePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+  startsRelativePath,
+} from "../paths.ts";
 import type { SourceFiles } from "../source-files.ts";
 import { bytewise } from "../text/compare.ts";
 import { isRecord } from "../json-document.ts";
@@ -50,9 +58,6 @@ const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[]
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
 
-/** The prefixes a string names a file with, relative to the file that writes it. */
-const RELATIVE_PREFIXES = ["./", "../"] as const;
-
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
 const COUNTERPARTS: readonly (readonly [string, readonly string[]])[] = [
   [".js", [".ts", ".tsx"]],
@@ -270,9 +275,7 @@ export function configurationFiles(
     }
     document.manifestDirs.push(next.manifestDir);
     for (const text of document.strings) {
-      const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
-        ? resolvePath(dirnamePath(next.path), text)
-        : undefined;
+      const path = startsRelativePath(text) ? resolvePath(dirnamePath(next.path), text) : undefined;
       if (
         path?.endsWith(".json") === true &&
         isProjectPath(root, path) &&
@@ -425,7 +428,7 @@ export function dependenciesNamed(text: string, declared: readonly string[]): re
  * none.
  */
 export function filesNamedBy(files: SourceFiles, dir: string, text: string): readonly SourceFile[] {
-  if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
+  if (text === "" || isAbsolutePath(text) || /[*?[{]/u.test(text)) {
     return [];
   }
   const path = resolvePath(dir, text);

package/src/entries/conventions.ts

@@ -42,6 +42,7 @@ import {
 import type { Host } from "../host.ts";
 import {
   ancestors,
+  cannotStartPackageName,
   dirnamePath,
   joinPath,
   normalizePath,
@@ -683,7 +684,7 @@ function prefixedPackage(value: string, reading: PrefixedNameReading): string |
   const { prefix, marker } = reading;
   let name: string;
   if (marker === undefined) {
-    if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+    if (value.includes(":") || cannotStartPackageName(value)) {
       return undefined;
     }
     const parts = value.split("/");

package/src/entries/html-entries.ts

@@ -12,7 +12,15 @@ import {
 } from "@typescript/native/ast";
 import { resolveRelativeSpecifier, type ParseFile } from "./configuration-files.ts";
 import type { Host } from "../host.ts";
-import { ancestors, dirnamePath, joinPath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  hasURLScheme,
+  isAbsolutePath,
+  isExplicitPath,
+  joinPath,
+  resolvePath,
+} from "../paths.ts";
 import type { SourceFiles } from "../source-files.ts";
 import { filesBelow } from "../fs/tree.ts";
 import { holdsManifest } from "../fs/manifest.ts";
@@ -32,15 +40,9 @@ const SCRIPT_END = /<\/script\s*>/iu;
 /** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
 const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
 
-/** A value that names a resource on another origin, or by another scheme. */
-const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
-
 /** The `type` values a classic script carries, compared in lowercase. */
 const CLASSIC_TYPES: ReadonlySet<string> = new Set(["text/javascript", "application/javascript"]);
 
-/** The prefixes an inline script's specifier names a file of the target with. */
-const FILE_PREFIXES = ["/", "./", "../"] as const;
-
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text: string): ReadonlyMap<string, string> {
   const found = new Map<string, string>();
@@ -94,9 +96,7 @@ function scriptValues(parse: ParseFile | undefined, path: string, text: string):
     const end = rest.search(SCRIPT_END);
     const content = end === -1 ? rest : rest.slice(0, end);
     values.push(
-      ...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) =>
-        FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix)),
-      ),
+      ...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter(isExplicitPath),
     );
   }
   return values;
@@ -132,18 +132,19 @@ export function htmlEntries(
     }
     const dir = dirnamePath(path);
     for (const value of scriptValues(parse, path, text)) {
-      if (ELSEWHERE.test(value)) {
+      // A value with a scheme, or one starting `//`, names a resource on another origin.
+      if (value.startsWith("//") || hasURLScheme(value)) {
         continue;
       }
-      const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
-      const relative = value.startsWith("/") ? `.${value}` : value;
+      const base = isAbsolutePath(value) ? manifestDirectory(host, root, dir) : dir;
+      const relative = isAbsolutePath(value) ? `.${value}` : value;
       const reached = resolveRelativeSpecifier(host, base, relative);
       const file = reached === undefined ? undefined : files.byName.get(reached);
       if (file !== undefined) {
         found.push({ file, source: value });
         continue;
       }
-      const served = value.startsWith("/")
+      const served = isAbsolutePath(value)
         ? files.outputDirs.filter((outDir) => outDir === dir)
         : [];
       const emitting = [base, ...served].flatMap((against) =>

package/src/entries/mdx-entries.ts

@@ -7,7 +7,7 @@
 import type { SourceFile } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.ts";
 import type { Host } from "../host.ts";
-import { dirnamePath, joinPath, resolvePath } from "../paths.ts";
+import { dirnamePath, joinPath, resolvePath, startsRelativePath } from "../paths.ts";
 import type { SourceFiles } from "../source-files.ts";
 import { filesBelow } from "../fs/tree.ts";
 
@@ -154,7 +154,7 @@ function importedBy(
     }
     const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
     const specifier = matched?.[2];
-    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+    if (specifier !== undefined && startsRelativePath(specifier)) {
       found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
     }
   }

package/src/entries/static-module.ts

@@ -62,6 +62,7 @@ import {
 } from "@typescript/native/ast";
 import { commonJSModuleValue, type ModuleValue } from "../inventory/commonjs.ts";
 import { callsPlatformBy, lexicalBinding, writtenName, type BindingOf } from "../platform-calls.ts";
+import { startsRelativePath } from "../paths.ts";
 import { unwrapped } from "../unwrap.ts";
 
 /** Where a value's text starts in its file, or undefined in a document read with no positions. */
@@ -589,7 +590,7 @@ export function relativeSpecifiers(file: SourceFile): readonly string[] {
   }
   const found: string[] = [];
   const named = (specifier: string | undefined): void => {
-    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+    if (specifier !== undefined && startsRelativePath(specifier)) {
       found.push(specifier);
     }
   };