@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/src/configuration-files.ts

@@ -69,11 +69,19 @@ export const RESOLVED_EXTENSIONS = [
   ".cjs",
 ] as const;
 
+/** The directory a package manager installs packages into, whose files are no project's own. */
+const MODULES_DIR = "node_modules";
+
 /** The file's name, the last segment of its path. */
 function basename(path: string): string {
   return path.slice(path.lastIndexOf("/") + 1);
 }
 
+/** Whether one path is the project's own: below the target root and in no `node_modules`. */
+function isProjectPath(root: string, path: string): boolean {
+  return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -92,6 +100,8 @@ export function isConfigurationDocumentName(name: string): boolean {
 interface ConfigurationDocument {
   /** The file, absolute. */
   readonly path: string;
+  /** The directories of the manifests whose dependencies the strings are read against. */
+  readonly manifestDirs: readonly string[];
   /** Every string value at any depth, in document order; a member's name is no value. */
   readonly strings: readonly string[];
 }
@@ -100,11 +110,169 @@ interface ConfigurationDocument {
 export type ParseFile = (fileName: string, text: string) => SourceFile;
 
 /** One file no program holds that a configuration module outside the program leads to. */
-export interface OutsideModule {
+interface OutsideModule {
   /** The file, parsed alone. */
   readonly file: SourceFile;
-  /** The directory of the configuration module the file was reached from, which holds its manifest. */
-  readonly manifestDir: string;
+  /** The directories of the manifests of the configuration files the file was reached from. */
+  readonly manifestDirs: readonly string[];
+}
+
+/** The flags a tool's command line names its configuration file with. */
+const CONFIG_FLAGS: ReadonlySet<string> = new Set(["--config", "-c"]);
+
+/** The extensions of a module a configuration flag may name. */
+const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
+
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+const BLANK = /[ \t\r\f\v]/u;
+
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+function shellWords(command: string): readonly (string | undefined)[] {
+  const words: (string | undefined)[] = [];
+  let word: string | undefined;
+  let computed = false;
+  const end = (): void => {
+    if (word !== undefined) {
+      words.push(computed ? undefined : word);
+    }
+    word = undefined;
+    computed = false;
+  };
+  for (let at = 0; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === "\\" && command.charAt(at + 1) === "\n") {
+      at += 1;
+    } else if (BLANK.test(char)) {
+      end();
+    } else if (OPERATOR.test(char)) {
+      end();
+      words.push(undefined);
+    } else if (char === "#" && word === undefined) {
+      const newline = command.indexOf("\n", at);
+      at = newline < 0 ? command.length : newline - 1;
+    } else if (char === "\\") {
+      at += 1;
+      word = (word ?? "") + command.charAt(at);
+    } else if (char === "'" || char === '"') {
+      const close = closingQuote(command, at);
+      if (close < 0) {
+        word ??= "";
+        computed = true;
+        break;
+      }
+      const quoted =
+        char === "'"
+          ? { text: command.slice(at + 1, close), computed: false }
+          : doubleQuoted(command.slice(at + 1, close));
+      word = (word ?? "") + quoted.text;
+      computed ||= quoted.computed;
+      at = close;
+    } else {
+      computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+      word = (word ?? "") + char;
+    }
+  }
+  end();
+  return words;
+}
+
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner: string): { readonly text: string; readonly computed: boolean } {
+  let text = "";
+  let computed = false;
+  for (let at = 0; at < inner.length; at += 1) {
+    const char = inner.charAt(at);
+    const next = inner.charAt(at + 1);
+    if (char === "\\" && next === "\n") {
+      at += 1;
+    } else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+      text += next;
+      at += 1;
+    } else {
+      computed ||= char === "$" || char === "`";
+      text += char;
+    }
+  }
+  return { text, computed };
+}
+
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command: string, open: number): number {
+  const quote = command.charAt(open);
+  for (let at = open + 1; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === quote) {
+      return at;
+    }
+    if (quote === '"' && char === "\\") {
+      at += 1;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The files the scripts of the manifest in one directory name after a configuration flag,
+ * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
+ * the target root and in no `node_modules`.
+ */
+function scriptConfigurations(host: Host, root: string, dir: string): readonly string[] {
+  let scripts: unknown;
+  try {
+    const manifest: unknown = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+    scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+  } catch {
+    return [];
+  }
+  if (!isRecord(scripts)) {
+    return [];
+  }
+  const found: string[] = [];
+  for (const command of Object.values(scripts)) {
+    if (typeof command !== "string") {
+      continue;
+    }
+    const words = shellWords(command);
+    words.forEach((word, at) => {
+      const named =
+        word !== undefined && CONFIG_FLAGS.has(word)
+          ? words[at + 1]
+          : word === undefined
+            ? undefined
+            : /^--config=(.+)$/su.exec(word)?.[1];
+      const path = named === undefined ? undefined : resolvePath(dir, named);
+      if (
+        path !== undefined &&
+        [".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
+        isProjectPath(root, path) &&
+        host.kindOf(path) === "file"
+      ) {
+        found.push(path);
+      }
+    });
+  }
+  return found;
+}
+
+/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
+function readDocument(host: Host, path: string): unknown {
+  try {
+    return JSON.parse(host.readFile(path)) as unknown;
+  } catch {
+    return undefined;
+  }
 }
 
 /** The configuration files one project holds and sits beside. */
@@ -117,7 +285,12 @@ interface ConfigurationFiles {
    * the program does not hold either, read where a parser is given.
    */
   readonly outside: readonly OutsideModule[];
-  /** Every JSON configuration file in a directory of the project's files or above one. */
+  /**
+   * Every JSON configuration file in a directory of the project's files or above one, every
+   * JSON file a script's configuration flag names, and every JSON file below the target
+   * root and in no `node_modules` a relative string of either names, read against each
+   * manifest whose chain reaches it.
+   */
   readonly documents: readonly ConfigurationDocument[];
 }
 
@@ -187,7 +360,8 @@ export function configurationFiles(
     }
   }
 
-  const documents: ConfigurationDocument[] = [];
+  const pending: { path: string; manifestDir: string }[] = [];
+  const named: { path: string; manifestDir: string }[] = [];
   for (const dir of [...dirs].sort()) {
     if (!holdsManifest(dir)) {
       continue;
@@ -200,24 +374,59 @@ export function configurationFiles(
         .map((entry) => entry.name)
         .sort();
     } catch {
+      names = [];
+    }
+    pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+    for (const path of scriptConfigurations(host, root, dir)) {
+      const held = files.byName.get(path);
+      if (path.endsWith(".json")) {
+        pending.push({ path, manifestDir: dir });
+      } else if (held !== undefined) {
+        modules.push({ file: held, form: "a script's configuration flag" });
+      } else {
+        named.push({ path, manifestDir: dir });
+      }
+    }
+  }
+
+  // A document reached from two manifests is read against each, so a chain is keyed by both.
+  const documents = new Map<string, { path: string; manifestDirs: string[]; strings: string[] }>();
+  const unreadable = new Set<string>();
+  for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+    let document = documents.get(next.path);
+    if (unreadable.has(next.path) || document?.manifestDirs.includes(next.manifestDir) === true) {
       continue;
     }
-    for (const name of names) {
-      const path = joinPath(dir, name);
-      let value: unknown;
-      try {
-        value = JSON.parse(host.readFile(path));
-      } catch {
+    if (document === undefined) {
+      const value = readDocument(host, next.path);
+      if (value === undefined) {
+        unreadable.add(next.path);
         continue;
       }
-      documents.push({ path, strings: documentStrings(value) });
+      document = { path: next.path, manifestDirs: [], strings: documentStrings(value) };
+      documents.set(next.path, document);
+    }
+    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;
+      if (
+        path?.endsWith(".json") === true &&
+        isProjectPath(root, path) &&
+        host.kindOf(path) === "file"
+      ) {
+        pending.push({ path, manifestDir: next.manifestDir });
+      }
     }
   }
   return {
     modules,
-    documents,
+    documents: [...documents.values()],
     outside:
-      parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+      parse === undefined
+        ? []
+        : outsideModules(host, [...dirs], files, holdsManifest, parse, named),
   };
 }
 
@@ -280,8 +489,9 @@ function outsideModules(
   files: SourceFiles,
   holdsManifest: (dir: string) => boolean,
   parse: ParseFile,
+  named: readonly { readonly path: string; readonly manifestDir: string }[],
 ): readonly OutsideModule[] {
-  const pending: { path: string; manifestDir: string }[] = [];
+  const pending: { path: string; manifestDir: string }[] = [...named];
   for (const dir of [...dirs].sort()) {
     if (!holdsManifest(dir)) {
       continue;
@@ -298,29 +508,37 @@ function outsideModules(
     }
     pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
   }
-  const found: OutsideModule[] = [];
-  const seen = new Set<string>();
+  const found = new Map<string, { file: SourceFile; manifestDirs: string[] }>();
+  const unreadable = new Set<string>();
   for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-    if (seen.has(next.path) || files.byName.has(next.path)) {
+    let outside = found.get(next.path);
+    if (
+      unreadable.has(next.path) ||
+      files.byName.has(next.path) ||
+      outside?.manifestDirs.includes(next.manifestDir) === true
+    ) {
       continue;
     }
-    seen.add(next.path);
-    let text: string;
-    try {
-      text = host.readFile(next.path);
-    } catch {
-      continue;
+    if (outside === undefined) {
+      let text: string;
+      try {
+        text = host.readFile(next.path);
+      } catch {
+        unreadable.add(next.path);
+        continue;
+      }
+      outside = { file: parse(next.path, text), manifestDirs: [] };
+      found.set(next.path, outside);
     }
-    const file = parse(next.path, text);
-    found.push({ file, manifestDir: next.manifestDir });
-    for (const specifier of relativeSpecifiers(file)) {
+    outside.manifestDirs.push(next.manifestDir);
+    for (const specifier of relativeSpecifiers(outside.file)) {
       const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
       if (reached !== undefined) {
         pending.push({ path: reached, manifestDir: next.manifestDir });
       }
     }
   }
-  return found;
+  return [...found.values()];
 }
 
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "4.1.0",
+    corpusVersion: "5.0.0",
     result: "pass",
-    digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
+    digest: "sha256:26c486907df44fb8eaf3f749f60a6010ac94e7cfeeda70c4aa406445193ab80a",
   },
   gaps: [],
 } as const;

package/src/contextual-uses.ts

@@ -3,8 +3,8 @@
  * An object-literal property writes the member of its name on each constituent of the
  * literal's contextual type that declares one. A value reaching a position typed by another
  * object type reads each of its members that type declares, through array elements and
- * function parameters and results too; a class instance there is the
- * interface-satisfaction class's evidence instead.
+ * the parameters and results of functions and constructors too; a class instance there is
+ * the interface-satisfaction class's evidence instead.
  */
 
 import {
@@ -18,12 +18,13 @@ import {
   isPropertyAssignment,
   isSetAccessorDeclaration,
   isShorthandPropertyAssignment,
+  isSpreadAssignment,
   isStringLiteral,
   type Expression,
   type Node,
   type ObjectLiteralExpression,
 } from "@typescript/native/unstable/ast";
-import { SignatureKind, type Type } from "@typescript/native/unstable/sync";
+import { SignatureKind, SymbolFlags, type Type } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import type { Inventory, SymbolKind } from "./inventory.ts";
 import { isAnswered, type PropertyTables } from "./query.ts";
@@ -45,14 +46,14 @@ export interface FlowAt {
 }
 
 /** One use the contextual types make: the node it is written at and the members it names. */
-export interface ContextualUse {
+interface ContextualUse {
   readonly at: Node;
   readonly from: string;
   readonly ids: readonly string[];
 }
 
 /** What the contextual types of one project's literals and values use, and what asking cost. */
-export interface ContextualUses {
+interface ContextualUses {
   /** Each literal property that writes a member, by the property's node. */
   readonly writes: readonly ContextualUse[];
   /** Each value whose members a position typed by another object type reads. */
@@ -63,8 +64,13 @@ export interface ContextualUses {
   readonly lookups: number;
 }
 
-/** The name one literal property is written under, where the name is literal text. */
-function propertyName(property: Node): { node: Node; text: string } | undefined {
+/**
+ * The name one literal property is written under: its literal text, or the computed name
+ * node whose key the checker names, a unique symbol among them.
+ */
+function propertyName(
+  property: Node,
+): { node: Node; text: string } | { node: Node; text: undefined } | undefined {
   if (
     !isPropertyAssignment(property) &&
     !isShorthandPropertyAssignment(property) &&
@@ -83,12 +89,14 @@ function propertyName(property: Node): { node: Node; text: string } | undefined
     if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
       return { node: name, text: key.text };
     }
+    return { node: name, text: undefined };
   }
   return undefined;
 }
 
-/** The parameter and result types of one call signature, each where the checker answered. */
+/** The parameter and result types of one call or construct signature, each where the checker answered. */
 interface Called {
+  readonly kind: SignatureKind;
   readonly parameters: readonly (Type | undefined)[];
   readonly result: Type | undefined;
 }
@@ -110,6 +118,8 @@ interface Member {
   readonly handles: ReadonlySet<string>;
   /** Whether a declaration of it is in one of the target's own files. */
   readonly own: boolean;
+  /** Whether the checker reads it as an accessor. */
+  readonly accessor: boolean;
 }
 
 /**
@@ -129,6 +139,11 @@ export function contextualUses<Brand>(
   const queries = project.queries;
   const ownPaths = project.ownPaths();
   const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+  const privateNames = new Set(
+    held.symbols
+      .filter((symbol) => symbol.visibility === "private-name")
+      .map((symbol) => symbol.id),
+  );
   let batches = 0;
   let lookups = 0;
   const batchesOf = (count: number): number => Math.ceil(count / cap);
@@ -171,6 +186,7 @@ export function contextualUses<Brand>(
           property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`),
         ),
         own: property.declarations.some((handle) => ownPaths.has(handle.path)),
+        accessor: (property.flags & SymbolFlags.Accessor) !== 0,
       });
     }
     tables.set(type.id, table);
@@ -183,6 +199,31 @@ export function contextualUses<Brand>(
     literals.map((one) => one.literal),
     cap,
   );
+  // A computed name that is not literal text names the property the literal declares
+  // under the checker's own key, which is how a type declares a member a unique symbol
+  // keys: asked once, for the literals that have a contextual type.
+  const computed = literals.flatMap(({ literal }, index) =>
+    contexts[index] === undefined || !isAnswered(contexts[index])
+      ? []
+      : literal.properties.flatMap((property) => {
+          const name = propertyName(property);
+          return name !== undefined && name.text === undefined ? [name.node] : [];
+        }),
+  );
+  batches += batchesOf(computed.length);
+  const keys = new Map<Node, string>();
+  (computed.length === 0
+    ? []
+    : project.symbolsAt(
+        computed.map((node) => project.handle(node)),
+        cap,
+      )
+  ).forEach((symbol, index) => {
+    const node = computed[index];
+    if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+      keys.set(node, symbol.name);
+    }
+  });
   literals.forEach(({ literal, from }, index) => {
     const context = contexts[index];
     if (context === undefined || !isAnswered(context)) {
@@ -191,10 +232,11 @@ export function contextualUses<Brand>(
     const tablesOf = partsOf(context).map(membersOf);
     for (const property of literal.properties) {
       const name = propertyName(property);
-      if (name === undefined) {
+      const text = name?.text ?? (name === undefined ? undefined : keys.get(name.node));
+      if (name === undefined || text === undefined) {
         continue;
       }
-      const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+      const ids = [...new Set(tablesOf.flatMap((table) => table.get(text)?.ids ?? []))];
       if (ids.length > 0) {
         writes.push({ at: name.node, from, ids });
       }
@@ -237,13 +279,22 @@ export function contextualUses<Brand>(
   };
 
   const calls = new Map<number, Called | undefined>();
-  /** The parameter and return types of a type's one call signature, read once per type. */
+  /**
+   * The parameter and return types of a type's one call signature, or of its one construct
+   * signature where it has no call signature, read once per type.
+   */
   const callOf = (type: Type): Called | undefined => {
     if (calls.has(type.id)) {
       return calls.get(type.id);
     }
     lookups += 1;
-    const signatures = queries.signaturesOf(type, SignatureKind.Call);
+    let kind = SignatureKind.Call;
+    let signatures = queries.signaturesOf(type, kind);
+    if (isAnswered(signatures) && signatures.length === 0) {
+      lookups += 1;
+      kind = SignatureKind.Construct;
+      signatures = queries.signaturesOf(type, kind);
+    }
     let called: Called | undefined;
     const [signature, ...more] = isAnswered(signatures) ? signatures : [];
     if (signature !== undefined && more.length === 0) {
@@ -253,6 +304,7 @@ export function contextualUses<Brand>(
       const result = queries.returnTypeOf(signature);
       lookups += parameters.length + 1;
       called = {
+        kind,
         parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
         result: isAnswered(result) ? result : undefined,
       };
@@ -298,7 +350,7 @@ export function contextualUses<Brand>(
           continue;
         }
         const other = called === undefined ? undefined : callOf(part);
-        if (called === undefined || other === undefined) {
+        if (called === undefined || other?.kind !== called.kind) {
           continue;
         }
         other.parameters.forEach((parameter, index) => {
@@ -381,5 +433,39 @@ export function contextualUses<Brand>(
       reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
     }
   });
+  const spreads = literals.flatMap(({ literal, from }) =>
+    literal.properties.flatMap((property) =>
+      isSpreadAssignment(property) ? [{ value: property.expression, from }] : [],
+    ),
+  );
+  batches += batchesOf(spreads.length);
+  const spreadTypes = queries.typesAt(
+    spreads.map((one) => one.value),
+    cap,
+  );
+  spreads.forEach(({ value, from }, index) => {
+    const type = spreadTypes[index];
+    if (type === undefined || !isAnswered(type)) {
+      return;
+    }
+    // A spread gets every own enumerable property, an overwritten key's getter included.
+    // So it reads each data member but a class's accessor, which sits on the prototype with
+    // the class's methods (never data members), and a private name, which is no property
+    // (https://tc39.es/ecma262/#sec-copydataproperties).
+    const own = (member: Member, id: string): boolean =>
+      !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-member");
+    const ids = [
+      ...new Set(
+        partsOf(type).flatMap((part) =>
+          [...membersOf(part).values()].flatMap((member) =>
+            member.ids.filter((id) => own(member, id)),
+          ),
+        ),
+      ),
+    ];
+    if (ids.length > 0) {
+      reads.push({ at: value, from, ids });
+    }
+  });
   return { writes, reads, batches, lookups };
 }