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

package/src/injection-container.ts

@@ -27,7 +27,7 @@ import {
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./configured-declarations.ts";
+} from "./roots/configured-declarations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { isParameterProperty, nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";

package/src/interface-satisfaction.ts

@@ -29,7 +29,7 @@ import {
 } from "@typescript/native/ast";
 import { SymbolFlags, type Type } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.ts";
-import { emptyImplementation } from "./implementations.ts";
+import { emptyImplementation } from "./findings/implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Reference } from "./references.ts";
 import type { Exemption } from "./sweep.ts";

package/src/inventory/commonjs.ts

@@ -59,6 +59,7 @@ import {
   type DeclarationSource,
   type SymbolKind,
 } from "../inventory.ts";
+import { callsPlatformBy, lexicalBinding, writtenName, type BindingOf } from "../platform-calls.ts";
 import type { Component } from "../ref.ts";
 import { spellsNoBinding } from "../spelled-names.ts";
 import { unwrapped } from "../unwrap.ts";
@@ -67,13 +68,14 @@ import { unwrapped } from "../unwrap.ts";
  * The export table of a CommonJS file: the module value `module.exports` is assigned and
  * the properties written on it, read from the top-level unconditional statements in order,
  * as Node runs them (https://nodejs.org/api/modules.html#moduleexports). Each entry is
- * keyed by the node that writes it, which is the checker's declaration of the export where
- * it binds one, so the two name one subject. Any other write of the exports opens the
- * table: its entries are kept and the file is listed open.
+ * keyed by the node that writes it, the checker's declaration of the export where it binds
+ * one. Any other write of the exports opens the table: its entries are kept and the file is
+ * listed open. `declarationOf` reads a `require()` call through the file's own scopes.
  */
 export function commonJS(
   typeIsModule: (path: string) => boolean,
   resolved: Resolved,
+  declarationOf: (occurrence: Identifier) => Node | undefined,
 ): DeclarationSource {
   return {
     declare(file: SourceFile, owner: Building, into: Builder): void {
@@ -82,7 +84,12 @@ export function commonJS(
       }
       const bound = boundOccurrences(file, resolved);
       const free = (node: Node): boolean => !bound.has(node);
-      const table = readTable(file, free, topLevelDeclarations(file));
+      const table = readTable(
+        file,
+        free,
+        topLevelDeclarations(file),
+        lexicalBinding(declarationOf),
+      );
       const open = table.open || opens(file, free, table.modelled);
       for (const entry of table.entries.values()) {
         const record = into.declare(entry.node, owner, entry.kind, entry.name, {
@@ -267,6 +274,8 @@ interface Entry {
   readonly component: Component;
   readonly localName: string | undefined;
   readonly kind: SymbolKind;
+  /** The value written under the key, undefined for an accessor. */
+  readonly value: Node | undefined;
   /** The declaration of the file the module value names, which the export then exports. */
   readonly target?: Node;
   /** The class whose members the entry holds. */
@@ -279,6 +288,10 @@ interface Table {
   readonly open: boolean;
   /** Every write the scan read, which the opening walk then passes over. */
   readonly modelled: ReadonlySet<Node>;
+  /** The value the last assignment of `module.exports` writes, undefined where none does. */
+  readonly whole: Node | undefined;
+  /** Whether a member write opens the table, apart from a module value the table cannot read. */
+  readonly membersOpen: boolean;
 }
 
 const DEFAULT: Component = { text: "default", computed: false };
@@ -288,23 +301,34 @@ function readTable(
   file: SourceFile,
   isFree: (node: Node) => boolean,
   declarations: ReadonlyMap<string, Node>,
+  bindingOf: BindingOf,
 ): Table {
   const entries = new Map<string, Entry>();
   const modelled = new Set<Node>();
-  let open = false;
+  // Written inside the closures below, which the compiler's narrowing does not follow.
+  let open = false as boolean;
   let aliasing = true;
+  let whole: Node | undefined;
+  let wholeOpen = false;
   const free = (node: Node, name: string): boolean =>
     isIdentifier(node) && node.text === name && isFree(node);
   const isModuleExports = (node: Node): node is PropertyAccessExpression =>
     isPropertyAccessExpression(node) &&
     free(node.expression, "module") &&
     node.name.text === "exports";
-  const isRequire = (node: Node): boolean =>
-    isCallExpression(node) &&
-    free(node.expression, "require") &&
-    node.arguments.length === 1 &&
-    node.arguments[0] !== undefined &&
-    isLiteralText(node.arguments[0]);
+  const isRequire = (node: Node): boolean => {
+    if (!isCallExpression(node) || node.arguments.length !== 1) {
+      return false;
+    }
+    const [argument] = node.arguments;
+    const callee = writtenName(node.expression);
+    return (
+      argument !== undefined &&
+      isLiteralText(argument) &&
+      callee !== undefined &&
+      callsPlatformBy("require", callee, bindingOf)
+    );
+  };
 
   /** What a value written under one key declares. */
   const entryOf = (
@@ -314,7 +338,7 @@ function readTable(
     value: Node | undefined,
   ): Entry => {
     const held = value === undefined ? undefined : unwrapped(value);
-    const base = { node, name, component, localName: undefined };
+    const base = { node, name, component, localName: undefined, value };
     if (held === undefined) {
       return { ...base, kind: "variable" };
     }
@@ -365,6 +389,7 @@ function readTable(
   /** The module value one assignment writes, placed at the `exports` name it assigns. */
   const moduleValue = (node: BinaryExpression, name: Node): void => {
     entries.clear();
+    whole = node.right;
     const value = unwrapped(node.right);
     if (isRequire(value)) {
       return;
@@ -373,7 +398,7 @@ function readTable(
       value.properties.forEach(literalProperty);
       return;
     }
-    const base = { node, name, component: DEFAULT };
+    const base = { node, name, component: DEFAULT, value: node.right };
     const target = isIdentifier(value) ? declarations.get(value.text) : undefined;
     if (target !== undefined) {
       entries.set("default", { ...base, localName: undefined, kind: "export-alias", target });
@@ -389,7 +414,7 @@ function readTable(
         members: value,
       });
     } else {
-      open = true;
+      wholeOpen = true;
     }
   };
 
@@ -422,8 +447,18 @@ function readTable(
         }
       } else if (isModuleExports(left)) {
         modelled.add(expression);
-        moduleValue(expression, left.name);
-        aliasing = false;
+        const inner = unwrapped(expression.right);
+        const chained =
+          isBinaryExpression(inner) &&
+          inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+          free(inner.left, "exports")
+            ? inner
+            : undefined;
+        if (chained !== undefined) {
+          modelled.add(chained);
+        }
+        moduleValue(chained ?? expression, left.name);
+        aliasing = chained !== undefined;
       } else if (isPropertyAccessExpression(left) || isElementAccessExpression(left)) {
         const object = exportsObject(left.expression);
         const key = isPropertyAccessExpression(left) ? left.name : left.argumentExpression;
@@ -454,7 +489,57 @@ function readTable(
       }
     }
   }
-  return { entries, open, modelled };
+  return { entries, open: open || wholeOpen, modelled, whole, membersOpen: open };
+}
+
+/** One member a CommonJS file's module value holds, as {@link commonJSModuleValue} reads it. */
+interface WrittenMember {
+  readonly key: string;
+  /** The value written, undefined for an accessor. */
+  readonly value: Node | undefined;
+  /** The node that writes the member. */
+  readonly node: Node;
+}
+
+/** The module value a CommonJS file leaves once Node has run its top level. */
+export interface ModuleValue {
+  /** The value the last assignment of `module.exports` writes, where that is no object literal. */
+  readonly whole: Node | undefined;
+  /** The members written on the module value, an object literal assigned to `module.exports` among them. */
+  readonly members: readonly WrittenMember[];
+  /** Whether a write the table does not model may set any member. */
+  readonly open: boolean;
+}
+
+/**
+ * The module value one file leaves where Node runs it as CommonJS, read by the one table
+ * the inventory's export table reads, or undefined where the file writes module syntax.
+ * `declarationOf` names the declaration each name resolves to, undefined for none, as a
+ * lexical reading of a file outside every program answers it.
+ */
+export function commonJSModuleValue(
+  file: SourceFile,
+  declarationOf: (occurrence: Identifier) => Node | undefined,
+): ModuleValue | undefined {
+  if (writesModuleSyntax(file)) {
+    return undefined;
+  }
+  const free = (node: Node): boolean => {
+    const declaration = isIdentifier(node) ? declarationOf(node) : undefined;
+    return declaration === undefined || !bindsOwn(declaration, file);
+  };
+  const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+  const held = table.whole === undefined ? undefined : unwrapped(table.whole);
+  const members = [...table.entries.values()].flatMap((entry) =>
+    entry.component === DEFAULT && held !== undefined && !isObjectLiteralExpression(held)
+      ? []
+      : [{ key: entry.component.text, value: entry.value, node: entry.node }],
+  );
+  return {
+    whole: held === undefined || isObjectLiteralExpression(held) ? undefined : table.whole,
+    members,
+    open: table.membersOpen || opens(file, free, table.modelled),
+  };
 }
 
 /** Whether one node is `Object.defineProperty`. */

package/src/inventory/enumerate.ts

@@ -15,6 +15,7 @@ import { relativePath } from "../paths.ts";
 import { renderPosition } from "../position.ts";
 import { isAnswered, UNANSWERED } from "../query.ts";
 import type { Handle, ProjectView } from "../session.ts";
+import { declarationOf } from "../entries/static-module.ts";
 import { commonJS, type Resolved } from "./commonjs.ts";
 import { SYNTAX } from "./syntax.ts";
 
@@ -34,7 +35,7 @@ export function inventory<Brand>(
   const moduleOf = packageScope(host, targetRoot);
   const sources: readonly DeclarationSource[] = [
     SYNTAX,
-    commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project)),
+    commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project), declarationOf),
   ];
   const into = new Builder(targetRoot);
   for (const file of files) {

package/src/javascript-file.ts

@@ -1,29 +1,46 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import { globExpression } from "./text/glob.ts";
+
 export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
 
-/** A minified file by its name; any other is one by its size and its mean line length. */
-const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+/** The patterns the TypeScript row of `languages.json` skips files by, each matched against a name alone. */
+const MINIFIED_NAMES = LANGUAGE_ROWS.ts.skippedFiles.map((pattern) => ({
+  pattern,
+  expression: globExpression(pattern),
+}));
 const MINIFIED_BYTES = 10_240;
 const MINIFIED_LINE = 500;
 
-/** Whether one name is a minified file's, which decides it without its text. */
-export function minifiedByName(fileName: string): boolean {
-  return MINIFIED_NAME.test(fileName);
+/** What a minified file is decided by where its text is not read. */
+const LONG_LINES = "long lines";
+
+/** The skipped-file pattern one file's name matches, which decides it minified without its text. */
+export function minifiedByName(fileName: string): string | undefined {
+  const name = fileName.slice(fileName.lastIndexOf("/") + 1);
+  return MINIFIED_NAMES.find((one) => one.expression.test(name))?.pattern;
 }
 
-/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
-export function minified(fileName: string, text: string): boolean {
+/**
+ * What decides one JavaScript file minified: the skipped-file pattern its name matches, or
+ * {@link LONG_LINES} for a text of the size whose mean line is longer than the limit;
+ * undefined for a file that is not minified.
+ */
+export function minifiedBy(fileName: string, text: string): string | undefined {
   if (!JAVASCRIPT_FILE.test(fileName)) {
-    return false;
+    return undefined;
   }
-  if (minifiedByName(fileName)) {
-    return true;
+  const named = minifiedByName(fileName);
+  if (named !== undefined) {
+    return named;
   }
   // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
   if (text.length * 3 < MINIFIED_BYTES) {
-    return false;
+    return undefined;
   }
   const lines = text.split(/\r?\n/u).length;
-  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE
+    ? LONG_LINES
+    : undefined;
 }
 
 /** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */

package/src/keyof-comparisons.ts

@@ -10,7 +10,10 @@ import {
   isCaseClause,
   isElementAccessExpression,
   isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
   isPropertyAccessExpression,
+  isStringLiteral,
   isSwitchStatement,
   isTypeOperatorNode,
   SyntaxKind,
@@ -20,12 +23,8 @@ import {
   type TypeNode,
 } from "@typescript/native/ast";
 import { SymbolFlags, 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";
 
 /** The operators that compare their operands for equality. */
@@ -83,125 +82,141 @@ function literalNames(parts: readonly Type[]): readonly string[] {
 }
 
 /**
- * The references the key comparisons of one project's own files make to the members their
- * literal side names, each made by the declaration holding the comparison.
+ * The reads the key comparisons of a side's files make of the members their literal side
+ * names, each made by the declaration holding the comparison. A question the checker leaves
+ * unanswered holds what its answer could have read.
  */
-export function keyofComparisonReferences<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  chains: AliasChains,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const queries = project.queries;
-  const comparisons: Comparison[] = [];
-  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 (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
-        comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
-        comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
-      }
-      if (isSwitchStatement(node)) {
-        for (const clause of node.caseBlock.clauses) {
-          if (isCaseClause(clause)) {
-            comparisons.push({
-              file,
-              from: holder,
-              keyed: node.expression,
-              other: clause.expression,
+export const keyofComparisons: ReadRule = {
+  start() {
+    const comparisons: Comparison[] = [];
+    return {
+      visit(node, { file, from }) {
+        if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+          comparisons.push({ file, from, keyed: node.left, other: node.right });
+          comparisons.push({ file, from, keyed: node.right, other: node.left });
+        }
+        if (isSwitchStatement(node)) {
+          for (const clause of node.caseBlock.clauses) {
+            if (isCaseClause(clause)) {
+              comparisons.push({ file, from, keyed: node.expression, other: clause.expression });
+            }
+          }
+        }
+      },
+      reads({ project, chains }) {
+        const queries = project.queries;
+        const found: Read[] = [];
+        const named = comparisons.flatMap((one) => {
+          const name = nameOf(one.keyed);
+          return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
+            ? []
+            : [{ ...one, name }];
+        });
+        if (named.length === 0) {
+          return found;
+        }
+        // The operand's own declaration states the key type, which the checker resolves to
+        // the literals it admits and so no longer names the type the key indexes.
+        const symbols = queries.symbolsAt(named.map((one) => one.name));
+        const keyed = named.flatMap((one, at) => {
+          const asked = symbols[at];
+          const symbol =
+            asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+              ? asked
+              : queries.aliased(asked);
+          if (symbol === UNANSWERED) {
+            const text = literalText(one.other);
+            found.push({
+              kind: "held",
+              from: one.from,
+              ...(text === undefined ? {} : { names: [text] }),
             });
+            return [];
+          }
+          if (symbol === undefined) {
+            return [];
           }
+          const operands = symbol.declarations.flatMap((handle) => {
+            const declared = (
+              project.declarationAt(handle)?.node as { readonly type?: TypeNode } | undefined
+            )?.type;
+            return declared === undefined ? [] : keyofOperands(declared);
+          });
+          return operands.length === 0 ? [] : [{ ...one, operands }];
+        });
+        if (keyed.length === 0) {
+          return found;
         }
-      }
-      node.forEachChild((child) => {
-        visit(child, holder);
-      });
-    };
-    file.forEachChild((child) => {
-      visit(child, fileId);
-    });
-  }
-  const named = comparisons.flatMap((one) => {
-    const name = nameOf(one.keyed);
-    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
-      ? []
-      : [{ ...one, name }];
-  });
-  if (named.length === 0) {
-    return [];
-  }
-
-  // The operand's own declaration states the key type, which the checker resolves to
-  // the literals it admits and so no longer names the type the key indexes.
-  const symbols = queries.symbolsAt(named.map((one) => one.name));
-  const keyed = named.flatMap((one, at) => {
-    const asked = symbols[at];
-    const symbol =
-      asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
-        ? asked
-        : queries.aliased(asked);
-    if (symbol === UNANSWERED || symbol === undefined) {
-      return [];
-    }
-    const operands = symbol.declarations.flatMap((handle) => {
-      const declared = (
-        project.declarationAt(handle)?.node as { readonly type?: TypeNode } | undefined
-      )?.type;
-      return declared === undefined ? [] : keyofOperands(declared);
-    });
-    return operands.length === 0 ? [] : [{ ...one, operands }];
-  });
-  if (keyed.length === 0) {
-    return [];
-  }
-  const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
-  const types = queries.typesAt(nodes);
-  const typeOf = new Map<Node, Type>();
-  nodes.forEach((node, at) => {
-    const type = types[at];
-    if (type !== UNANSWERED && type !== undefined) {
-      typeOf.set(node, type);
-    }
-  });
-  const partsOf = (type: Type): readonly Type[] => {
-    const parts = queries.constituents(type);
-    return parts === UNANSWERED ? [type] : parts;
-  };
-
-  const found: Reference[] = [];
-  for (const one of keyed) {
-    const literal = typeOf.get(one.other);
-    const names = literal === undefined ? [] : literalNames(partsOf(literal));
-    if (names.length === 0) {
-      continue;
-    }
-    const position = renderPosition(one.file, root, one.other.getStart());
-    for (const operand of one.operands) {
-      const object = typeOf.get(operand);
-      for (const part of object === undefined ? [] : partsOf(object)) {
-        const properties = queries.propertiesOf(part);
-        for (const property of properties === UNANSWERED ? [] : properties) {
-          if (!names.includes(property.name)) {
-            continue;
+        const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+        const types = queries.typesAt(nodes);
+        const typeOf = new Map<Node, Type | typeof UNANSWERED>();
+        nodes.forEach((node, at) => {
+          const type = types[at];
+          if (type !== undefined) {
+            typeOf.set(node, type);
           }
-          for (const to of chains.declarationsOf(property)) {
+        });
+        const partsOf = (type: Type): readonly Type[] => {
+          const parts = queries.constituents(type);
+          return parts === UNANSWERED ? [type] : parts;
+        };
+        for (const one of keyed) {
+          const literal = typeOf.get(one.other);
+          const objects = one.operands.map((operand) => typeOf.get(operand));
+          if (literal === UNANSWERED) {
+            const known = objects.filter((type) => type !== undefined && type !== UNANSWERED);
             found.push({
+              kind: "held",
               from: one.from,
-              to,
-              position,
-              use: "read",
-              resolution: "keyed",
-              test: testFiles.has(position.path),
+              types: known.flatMap(partsOf),
+              ...(known.length < objects.length ? { members: true as const } : {}),
             });
+            continue;
+          }
+          const names = literal === undefined ? [] : literalNames(partsOf(literal));
+          if (names.length === 0) {
+            continue;
+          }
+          for (const object of objects) {
+            if (object === UNANSWERED) {
+              found.push({ kind: "held", from: one.from, names });
+              continue;
+            }
+            for (const part of object === undefined ? [] : partsOf(object)) {
+              const properties = queries.propertiesOf(part);
+              if (properties === UNANSWERED) {
+                found.push({ kind: "held", from: one.from, names });
+                continue;
+              }
+              for (const property of properties) {
+                if (!names.includes(property.name)) {
+                  continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                  found.push({
+                    kind: "named",
+                    from: one.from,
+                    to,
+                    file: one.file,
+                    at: one.other,
+                    use: "read",
+                    via: "keyed",
+                  });
+                }
+              }
+            }
           }
         }
-      }
-    }
-  }
-  return found;
+        return found;
+      },
+    };
+  },
+};
+
+/** The text a string or number literal operand spells, where it is one. */
+function literalText(node: Expression): string | undefined {
+  const at = parenthesesRemoved(node);
+  return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at)
+    ? at.text
+    : undefined;
 }