@cplieger/deadset-ts 5.2.3 → 6.0.1

package/src/indexed-access.ts

@@ -0,0 +1,295 @@
+/**
+ * The members an indexed-access type names. `T["a" | "b"]` reads the members `a` and `b`
+ * of `T` as a property access by either name would. Where the index is a type parameter
+ * a call fixes, the call names the members the literal type argument names, written or
+ * inferred, which is read off the parameter the type parameter annotates whole. The type
+ * query of a type-query alias is no reference.
+ */
+
+import {
+  isArrowFunction,
+  isCallExpression,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isIdentifier,
+  isIndexedAccessTypeNode,
+  isLiteralTypeNode,
+  isMethodDeclaration,
+  isNewExpression,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
+  isParenthesizedTypeNode,
+  isPropertyAccessExpression,
+  isStringLiteral,
+  isTypeReferenceNode,
+  isUnionTypeNode,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+  type TypeNode,
+} from "@typescript/native/unstable/ast";
+import type { Type } from "@typescript/native/unstable/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 { typeQueryAliases } from "./type-query-alias.ts";
+
+/** A function whose signature declares type parameters, by the kinds of node that can. */
+type Generic = Node & {
+  readonly typeParameters?: readonly { readonly name: Node }[];
+  readonly parameters: readonly { readonly name: Node; readonly type?: TypeNode }[];
+};
+
+function isGeneric(node: Node): node is Generic {
+  return (
+    (isFunctionDeclaration(node) ||
+      isMethodDeclaration(node) ||
+      isArrowFunction(node) ||
+      isFunctionExpression(node)) &&
+    (node as { readonly typeParameters?: readonly unknown[] }).typeParameters !== undefined
+  );
+}
+
+function unwrappedType(node: TypeNode): TypeNode {
+  return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
+}
+
+/** The names a literal index type spells, or none where the index is any other type. */
+function literalNames(index: TypeNode): readonly string[] | undefined {
+  const node = unwrappedType(index);
+  if (isUnionTypeNode(node)) {
+    const names = node.types.map(literalNames);
+    return names.every((one) => one !== undefined) ? names.flat() : undefined;
+  }
+  if (!isLiteralTypeNode(node)) {
+    return undefined;
+  }
+  const literal = node.literal;
+  if (isStringLiteral(literal) || isNoSubstitutionTemplateLiteral(literal)) {
+    return [literal.text];
+  }
+  return isNumericLiteral(literal) ? [String(Number(literal.text))] : undefined;
+}
+
+/** The name a literal type carries, a union's each, or none where a constituent is no literal. */
+function literalTypeNames(
+  type: Type,
+  parts: (type: Type) => readonly Type[],
+): string[] | undefined {
+  const names: string[] = [];
+  for (const part of parts(type)) {
+    if (part.isStringLiteralType()) {
+      names.push(part.value);
+    } else if (part.isNumberLiteralType()) {
+      names.push(String(part.value));
+    } else {
+      return undefined;
+    }
+  }
+  return names;
+}
+
+/** One indexed-access type whose index is a type parameter its function declares. */
+interface ByParameter {
+  readonly object: TypeNode;
+  /** The index of the parameter the type parameter annotates whole. */
+  readonly parameter: number;
+}
+
+/** An indexed access to resolve: the object type, the names, and where the reference is made. */
+interface Access {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly at: Node;
+  readonly object: TypeNode | Type;
+  readonly names: readonly string[];
+}
+
+/**
+ * The references the indexed-access types of one project's own files make to the members
+ * they name, each made by the declaration that holds the type or the call, or by the file.
+ */
+export function indexedAccessReferences<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const accesses: Access[] = [];
+  const generics = new Map<string, ByParameter[]>();
+  const calls: { file: SourceFile; from: string; call: Node; name: string }[] = [];
+  const names = new Set<string>();
+
+  for (const file of project.ownSourceFiles()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId === undefined) {
+      continue;
+    }
+    const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
+    const visit = (node: Node, from: string, enclosing: readonly Generic[]): void => {
+      const own = held.declarations.get(nodeKey(file, node));
+      const holder = own ?? from;
+      const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
+      if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
+        const literal = literalNames(node.indexType);
+        if (literal !== undefined) {
+          accesses.push({ file, from: holder, at: node, object: node.objectType, names: literal });
+        } else {
+          parameterIndex(node, inside, file, generics, names);
+        }
+      }
+      if (isCallExpression(node) || isNewExpression(node)) {
+        const callee = node.expression;
+        const name = isIdentifier(callee)
+          ? callee.text
+          : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+            ? callee.name.text
+            : undefined;
+        if (name !== undefined) {
+          calls.push({ file, from: holder, call: node, name });
+        }
+      }
+      node.forEachChild((child) => {
+        visit(child, holder, inside);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId, []);
+    });
+  }
+
+  for (const { file, from, call, name } of calls) {
+    if (!names.has(name)) {
+      continue;
+    }
+    const resolved = queries.resolvedSignature(call);
+    if (resolved === UNANSWERED || resolved?.declaration === undefined) {
+      continue;
+    }
+    const declaration = project.declarationAt(resolved.declaration)?.node;
+    const byParameter =
+      declaration === undefined
+        ? undefined
+        : generics.get(nodeKey(declaration.getSourceFile(), declaration));
+    if (byParameter === undefined) {
+      continue;
+    }
+    for (const { object, parameter } of byParameter) {
+      const fixed = queries.typeAtPosition(resolved, parameter);
+      const literal =
+        fixed === UNANSWERED ? undefined : literalTypeNames(fixed, (type) => partsOf(type));
+      if (literal !== undefined) {
+        accesses.push({ file, from, at: call, object, names: literal });
+      }
+    }
+  }
+
+  function partsOf(type: Type): readonly Type[] {
+    const parts = queries.constituents(type);
+    return parts === UNANSWERED ? [type] : parts;
+  }
+
+  const objectNodes = accesses.flatMap((one) => ("kind" in one.object ? [one.object] : []));
+  const typeOf = new Map<Node, Type>();
+  queries.typesAt(objectNodes).forEach((answer, index) => {
+    const node = objectNodes[index];
+    if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
+      typeOf.set(node, answer);
+    }
+  });
+
+  const found: Reference[] = [];
+  for (const access of accesses) {
+    const type = "kind" in access.object ? typeOf.get(access.object) : access.object;
+    if (type === undefined) {
+      continue;
+    }
+    const position = renderPosition(access.file, root, access.at.getStart());
+    for (const part of partsOf(type)) {
+      const properties = queries.propertiesOf(part);
+      if (properties === UNANSWERED) {
+        continue;
+      }
+      for (const property of properties) {
+        if (!access.names.includes(property.escapedName)) {
+          continue;
+        }
+        for (const to of chains.declarationsOf(property)) {
+          found.push({
+            from: access.from,
+            to,
+            position,
+            use: "read",
+            resolution: "batch",
+            test: testFiles.has(position.path),
+          });
+        }
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Records an indexed-access type whose index names a type parameter of an enclosing
+ * function that a parameter of that function is annotated with whole, so a call's
+ * argument for that parameter fixes the index.
+ */
+function parameterIndex(
+  node: Node & { readonly objectType: TypeNode; readonly indexType: TypeNode },
+  enclosing: readonly Generic[],
+  file: SourceFile,
+  generics: Map<string, ByParameter[]>,
+  names: Set<string>,
+): void {
+  const index = unwrappedType(node.indexType);
+  if (!isTypeReferenceNode(index) || !isIdentifier(index.typeName)) {
+    return;
+  }
+  const spelled = index.typeName.text;
+  for (const generic of [...enclosing].reverse()) {
+    const declares = (generic.typeParameters ?? []).some(
+      (parameter) => isIdentifier(parameter.name) && parameter.name.text === spelled,
+    );
+    if (!declares) {
+      continue;
+    }
+    const at = generic.parameters.findIndex((parameter) => {
+      const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
+      return (
+        type !== undefined &&
+        isTypeReferenceNode(type) &&
+        isIdentifier(type.typeName) &&
+        type.typeName.text === spelled
+      );
+    });
+    if (at >= 0) {
+      const key = nodeKey(file, generic);
+      generics.set(key, [...(generics.get(key) ?? []), { object: node.objectType, parameter: at }]);
+      const name = calledName(generic);
+      if (name !== undefined) {
+        names.add(name);
+      }
+    }
+    return;
+  }
+}
+
+/** The name a call writes to call one generic function: its own, or its variable's. */
+function calledName(generic: Generic): string | undefined {
+  const own = (generic as { readonly name?: Node }).name;
+  if (own !== undefined && isIdentifier(own)) {
+    return own.text;
+  }
+  const parent = generic.parent as { readonly kind: SyntaxKind; readonly name?: Node };
+  return parent.kind === SyntaxKind.VariableDeclaration &&
+    parent.name !== undefined &&
+    isIdentifier(parent.name)
+    ? parent.name.text
+    : undefined;
+}

package/src/interface-satisfaction.ts

@@ -1,19 +1,14 @@
 /**
- * The interface-satisfaction class: a class member is held back when a value of the
- * class reaches a position the checker types as an interface requiring a member of
- * that name, so a caller reaches the member through the interface while no name in
- * the program resolves to it.
- *
- * A value reaches such a position as an `implements` entry, the initializer of a
- * declaration whose type is written, an assignment, an argument, a returned value, an
- * array element, an object property, or the operand of `as` or `satisfies`, read
- * through parentheses, conditionals and the operators whose result is an operand.
- * `this` in an instance member is a value of its class. Types are asked in batches;
- * the contextual lookup has none, so it is asked only of a value whose type is a class
- * of the target, and each distinct pair, interface and class is asked once.
+ * The interface-satisfaction class: a member is held back when a value of its class
+ * reaches a position the checker types as an interface requiring that member, through an
+ * `implements` entry, a typed initializer, an assignment, an argument, a return, an array
+ * element, an object property or an `as` or `satisfies` operand. `this` is a value of its
+ * class, and a position typed by a type parameter reaches its constraint. The contextual
+ * lookup has no batch form, so it is asked only of a value typed as a target class.
  */
 
 import {
+  isCallExpression,
   isClassDeclaration,
   isClassExpression,
   isClassStaticBlockDeclaration,
@@ -22,6 +17,7 @@ import {
   isGetAccessorDeclaration,
   isHeritageClause,
   isMethodDeclaration,
+  isNewExpression,
   isObjectLiteralExpression,
   isSetAccessorDeclaration,
   ModifierFlags,
@@ -32,8 +28,11 @@ import {
 } from "@typescript/native/unstable/ast";
 import { SymbolFlags, type Type } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.ts";
+import { emptyImplementation } from "./implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey } from "./inventory.ts";
+import type { Reference } from "./references.ts";
+import type { Exemption } from "./sweep.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
@@ -60,6 +59,12 @@ interface Clause {
   readonly entry: Node;
 }
 
+/** A class member answering an interface member: its declarations, and whether it is empty. */
+interface Answering {
+  readonly ids: readonly string[];
+  readonly empty: boolean;
+}
+
 /** One class type reaching one interface type, and the places it does. */
 interface Pair {
   readonly owner: ClassAt;
@@ -223,7 +228,11 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
   const interfaceNames = new Map<number, string | undefined>();
   /** The interface types one position's type is or holds, each with the interface's name. */
   const interfacesOf = (type: Type): readonly { type: Type; name: string }[] =>
-    partsOf(type).flatMap((part) => {
+    partsOf(type).flatMap((part): readonly { type: Type; name: string }[] => {
+      if (part.isTypeParameter()) {
+        const constraint = must(queries.constraintOf(part));
+        return constraint === undefined ? [] : interfacesOf(constraint);
+      }
       if (!interfaceNames.has(part.id)) {
         const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
         interfaceNames.set(
@@ -237,6 +246,22 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
       return name === undefined ? [] : [{ type: part, name }];
     });
 
+  /**
+   * The type an argument's parameter declares in the generic signature a call
+   * instantiates, which is a type parameter where the argument is a type argument's value:
+   * the contextual type of such an argument is the instantiation, not the parameter.
+   */
+  const genericPosition = (value: Expression): Type | undefined => {
+    const call = value.parent;
+    if (!isCallExpression(call) && !isNewExpression(call)) {
+      return undefined;
+    }
+    const at = (call.arguments ?? []).findIndex((argument) => argument === value);
+    const resolved = at < 0 ? undefined : must(queries.resolvedSignature(call));
+    const generic = resolved === undefined ? undefined : must(queries.genericOf(resolved));
+    return generic === undefined ? undefined : must(queries.typeAtPosition(generic, at));
+  };
+
   const pairs = new Map<string, Pair>();
   const reach = (owner: ClassAt, source: Type, target: Type, name: string, site: Node): void => {
     const key = `${String(source.id)}:${String(target.id)}`;
@@ -274,19 +299,18 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
   const positions = queries.contextualTypes(carrying.map((one) => one.flow.value));
   carrying.forEach(({ flow, sources }, index) => {
     const position = must(positions[index]);
-    if (position === undefined) {
-      return;
-    }
-    for (const reached of interfacesOf(position)) {
-      for (const source of sources) {
-        reach(source.owner, source.type, reached.type, reached.name, flow.value);
+    for (const type of [position, genericPosition(flow.value)]) {
+      for (const reached of type === undefined ? [] : interfacesOf(type)) {
+        for (const source of sources) {
+          reach(source.owner, source.type, reached.type, reached.name, flow.value);
+        }
       }
     }
   });
 
   const chains = aliasChains(project, held);
-  const required = new Map<number, ReadonlySet<string>>();
-  const members = new Map<string, ReadonlyMap<string, readonly string[]>>();
+  const required = new Map<number, ReadonlyMap<string, readonly string[]>>();
+  const members = new Map<string, ReadonlyMap<string, Answering>>();
   const found: Evidence[] = [];
   const asking = [...pairs.values()];
   const assignable = queries.assignableEach(asking);
@@ -296,8 +320,11 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     }
     let names = required.get(pair.target.id);
     if (names === undefined) {
-      names = new Set(
-        must(queries.propertiesOf(pair.target)).map((property) => property.escapedName),
+      names = new Map(
+        must(queries.propertiesOf(pair.target)).map((property) => [
+          property.escapedName,
+          chains.declarationsOf(property),
+        ]),
       );
       required.set(pair.target.id, names);
     }
@@ -307,19 +334,24 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
       answering = new Map(
         must(queries.propertiesOf(instance)).map((property) => [
           property.escapedName,
-          chains.declarationsOf(property),
+          {
+            ids: chains.declarationsOf(property),
+            empty: emptyImplementation(project, property),
+          },
         ]),
       );
       members.set(pair.owner.id, answering);
     }
     const detail = `satisfies ${pair.name}`;
-    for (const name of names) {
-      for (const id of answering.get(name) ?? []) {
+    for (const [name, methods] of names) {
+      const member = answering.get(name);
+      for (const id of member?.ids ?? []) {
         for (const site of pair.sites) {
           found.push({
             id,
             detail,
             site: renderPosition(site.getSourceFile(), targetRoot, site.getStart()),
+            implementing: { methods, empty: member?.empty ?? false },
           });
         }
       }
@@ -327,3 +359,62 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
   }
   return found;
 }
+
+/** One project's interface-satisfaction records settled against the run's calls. */
+interface Settled {
+  readonly evidence: readonly Exemption[];
+  /** A reference from each uncalled interface method to each implementation it alone keeps. */
+  readonly references: readonly Reference[];
+}
+
+/**
+ * Each project's records with every record dropped whose member implements only interface
+ * methods nothing calls, unless every implementation of such a method is empty, and a
+ * reference from each such method to the member, which then falls with the method.
+ * `references` is every reference of the run, a consumer's included.
+ */
+export function settledSatisfaction(
+  projects: readonly { readonly evidence: readonly Exemption[]; readonly held: Inventory }[],
+  references: readonly Reference[],
+): readonly Settled[] {
+  const methods = new Set(
+    projects.flatMap((one) =>
+      one.held.symbols.filter((symbol) => symbol.kind === "interface-method").map((one) => one.id),
+    ),
+  );
+  const called = new Set(references.map((reference) => reference.to));
+  const bodies = new Map<string, boolean>();
+  for (const record of projects.flatMap((one) => one.evidence)) {
+    for (const method of record.implementing?.methods ?? []) {
+      bodies.set(method, (bodies.get(method) ?? true) && record.implementing?.empty === true);
+    }
+  }
+  const uncalled = (method: string): boolean =>
+    methods.has(method) && !called.has(method) && bodies.get(method) !== true;
+  return projects.map(({ evidence }) => {
+    const kept: Exemption[] = [];
+    const added: Reference[] = [];
+    for (const record of evidence) {
+      const implemented = record.implementing?.methods ?? [];
+      if (
+        record.class !== "interface-satisfaction" ||
+        implemented.length === 0 ||
+        !implemented.every(uncalled)
+      ) {
+        kept.push(record);
+        continue;
+      }
+      for (const method of implemented) {
+        added.push({
+          from: method,
+          to: record.id,
+          position: record.site,
+          use: "read",
+          resolution: "override",
+          test: false,
+        });
+      }
+    }
+    return { evidence: kept, references: added };
+  });
+}