@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.3

package/src/references.ts

@@ -15,7 +15,10 @@ import {
   isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
+  isInterfaceDeclaration,
   isMetaProperty,
+  isModuleBlock,
+  isModuleDeclaration,
   isNewExpression,
   isNamespaceExport,
   isNoSubstitutionTemplateLiteral,
@@ -49,7 +52,7 @@ import {
   type Inventory,
   type InventorySymbol,
 } from "./inventory.ts";
-import { augmentationReferences } from "./augmentations.ts";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.ts";
 import { elementAccessReferences } from "./element-access.ts";
 import { indexedAccessReferences } from "./indexed-access.ts";
 import { keyofComparisonReferences } from "./keyof-comparisons.ts";
@@ -1610,6 +1613,39 @@ export function references<Brand>(
     }
   }
 
+  /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+  const libraryMerged = (scripts: ReadonlySet<string>): ReadonlySet<string> => {
+    const names = new Map<string, Node>();
+    const visit = (node: Node): void => {
+      if (isInterfaceDeclaration(node)) {
+        const id = declaredAt(node);
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      } else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+        node.forEachChild(visit);
+      }
+    };
+    for (const { file } of walked) {
+      file.forEachChild(visit);
+    }
+    const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+    const asked = [...names].filter(([id]) => global.has(id));
+    if (asked.length === 0) {
+      return new Set();
+    }
+    const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+    return new Set(
+      asked.flatMap(([id], at) => {
+        const symbol = answers[at];
+        return typeof symbol === "object" &&
+          symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+          ? [id]
+          : [];
+      }),
+    );
+  };
+
   const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
   for (const [file, writes] of valued) {
     const uses = usesOf.get(file) ?? [];
@@ -1637,7 +1673,7 @@ export function references<Brand>(
   const scripts = new Set(
     walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId),
   );
-  found.push(...augmentationReferences(held, found, scripts));
+  found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||

package/src/report.ts

@@ -81,11 +81,6 @@ export interface WireFinding {
     readonly root: boolean;
     readonly symbol_count: number;
     readonly deletable_lines: number;
-    readonly members?: readonly {
-      readonly ref: string;
-      readonly name: string;
-      readonly position: WirePosition;
-    }[];
   };
   readonly retained_by: readonly string[];
   readonly configurations: readonly string[];
@@ -96,6 +91,16 @@ export interface WireFinding {
   readonly details: WireDetails;
 }
 
+/** One dead component a finding names, with its members, as the report lists it once. */
+export interface WireComponent {
+  readonly id: string;
+  readonly members: readonly {
+    readonly ref: string;
+    readonly name: string;
+    readonly position: WirePosition;
+  }[];
+}
+
 interface WireEdgeEvaluation {
   readonly edge: string;
   readonly side: string;
@@ -218,6 +223,8 @@ export interface Report {
     }[];
   };
   readonly findings: readonly WireFinding[];
+  /** Present where the run lists each component in full. */
+  readonly components?: readonly WireComponent[];
   readonly edge_evaluations: readonly WireEdgeEvaluation[];
   readonly stale_suppressions: readonly WireStaleSuppression[];
   readonly declared_gaps: readonly WireDeclaredGap[];
@@ -231,13 +238,20 @@ export interface Report {
 }
 
 /** One hint about the run's setup, as the report schema's `notes` spells it. */
-export interface ReportNote {
-  readonly kind: "unmapped-entry";
-  /** The directory of the manifest the note is about, below the target root. */
-  readonly path: string;
-  readonly key: "ts.entry_files";
-  readonly message: string;
-}
+export type ReportNote =
+  | {
+      readonly kind: "unmapped-entry";
+      /** The directory of the manifest the note is about, below the target root. */
+      readonly path: string;
+      readonly key: "ts.entry_files";
+      readonly message: string;
+    }
+  | {
+      readonly kind: "computed-load";
+      /** The directory of the file that writes the load, below the target root. */
+      readonly path: string;
+      readonly message: string;
+    };
 
 /** What one run answered, from which its report is built. */
 export interface ReportInput {
@@ -258,6 +272,26 @@ export interface ReportInput {
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The notes the run states, in any order. */
   readonly notes?: readonly ReportNote[];
+  /** Whether the run lists each component in full, which `reporters.cascade: full` asks for. */
+  readonly listsComponents?: boolean;
+}
+
+/**
+ * Each component the findings name, once, with the members the first finding naming it
+ * carries, in the order the findings are: `findings` paired with their wire forms and
+ * sorted, then the edge evaluations' findings.
+ */
+function componentsOf(
+  findings: readonly (readonly [WireFinding, CompletedFinding])[],
+): readonly WireComponent[] {
+  const listed = new Map<string, WireComponent>();
+  for (const [wire, finding] of findings) {
+    const { members } = finding.component;
+    if (members !== undefined && !listed.has(wire.component.id)) {
+      listed.set(wire.component.id, { id: wire.component.id, members: members.map(wireSymbol) });
+    }
+  }
+  return [...listed.values()];
 }
 
 /** Two strings ordered bytewise. */
@@ -342,9 +376,6 @@ export function wireFinding(finding: CompletedFinding): WireFinding {
       root: finding.component.root,
       symbol_count: finding.component.symbolCount,
       deletable_lines: finding.component.deletableLines,
-      ...(finding.component.members === undefined
-        ? {}
-        : { members: finding.component.members.map(wireSymbol) }),
     },
     retained_by: finding.retainedBy,
     configurations: finding.configurations,
@@ -470,7 +501,13 @@ function totalsOf(findings: readonly WireFinding[], result: PassResult): WireTot
 
 /** Builds the report of one run, every array in the order the Contract fixes for it. */
 export function buildReport(input: ReportInput): Report {
-  const findings = input.result.findings.map(wireFinding).sort(canonical);
+  const paired = input.result.findings
+    .map((finding) => [wireFinding(finding), finding] as const)
+    .sort(([a], [b]) => canonical(a, b));
+  const findings = paired.map(([wire]) => wire);
+  const evaluated = input.result.edgeEvaluations.flatMap((one) =>
+    one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding] as const],
+  );
   const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
     .sort((a, b) => compare(a.id, b.id))
     .map((one) => ({ id: one.id, role: "consumer" as const, reason: one.reason }));
@@ -500,6 +537,9 @@ export function buildReport(input: ReportInput): Report {
       .map((one) => ({ id: one.id, project: one.project, error: one.error })),
     consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
     findings,
+    ...(input.listsComponents === true
+      ? { components: componentsOf([...paired, ...evaluated]) }
+      : {}),
     edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),
     stale_suppressions: input.result.staleSuppressions.map(wireStale).sort(canonicalStale),
     // Every gap shares the one component of the canonical key a gap supplies, the analyzer's

package/src/reporters/sarif.ts

@@ -2,7 +2,7 @@ import type { Confidence, Severity } from "../config.ts";
 import { jsonChunks } from "../json-chunks.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
 import { declarationKey } from "../ref.ts";
-import type { Report, WireFinding, WireStaleSuppression } from "../report.ts";
+import type { Report, WireComponent, WireFinding, WireStaleSuppression } from "../report.ts";
 import { lineHashes, symbolFingerprint } from "./fingerprint.ts";
 import { RenderError, type RenderOptions } from "./reporter.ts";
 import { utf8Bytes } from "./sha256.ts";
@@ -151,8 +151,11 @@ interface Related {
   readonly endLine: number;
 }
 
+/** The members the report lists for one component, none where it lists none. */
+type MembersOf = (id: string) => WireComponent["members"];
+
 /** Every position a finding names beyond its own, in the mapping's order, the first hundred. */
-function relatedOf(found: WireFinding): readonly Related[] {
+function relatedOf(found: WireFinding, members: MembersOf): readonly Related[] {
   const related: Related[] = [];
   for (const one of found.details.implementations ?? []) {
     related.push({ label: "implementation", at: one.position, endLine: one.position.end_line });
@@ -164,7 +167,7 @@ function relatedOf(found: WireFinding): readonly Related[] {
     const at = found.details.name_literal;
     related.push({ label: "name", at, endLine: at.end_line });
   }
-  for (const one of found.component.members ?? []) {
+  for (const one of members(found.component.id)) {
     if (
       declarationKey(one.ref, one.position.path) !==
       declarationKey(found.symbol.ref, found.position.path)
@@ -188,7 +191,9 @@ function messageWithLinks(message: string, related: readonly Related[]): string
 }
 
 /** Every member of the finding the mapping places nowhere else, under its schema name. */
-function propertiesOf(found: WireFinding): Record<string, unknown> {
+/** A result's member bag, its component holding the members the report lists for it once. */
+function propertiesOf(found: WireFinding, members: MembersOf): Record<string, unknown> {
+  const listed = members(found.component.id);
   return {
     language: found.language,
     symbol: found.symbol,
@@ -199,7 +204,7 @@ function propertiesOf(found: WireFinding): Record<string, unknown> {
       : { liveness_relation: found.liveness_relation }),
     test_only: found.test_only,
     generated: found.generated,
-    component: found.component,
+    component: listed.length === 0 ? found.component : { ...found.component, members: listed },
     retained_by: found.retained_by,
     configurations: found.configurations,
     consumers_loaded: found.consumers_loaded,
@@ -220,8 +225,9 @@ function findingResult(
   found: WireFinding,
   index: ReadonlyMap<string, number>,
   hashOf: (at: Located) => string,
+  members: MembersOf,
 ): Record<string, unknown> {
-  const related = relatedOf(found);
+  const related = relatedOf(found, members);
   return {
     ruleId: found.code,
     ruleIndex: ruleIndex(index, found.code),
@@ -241,7 +247,7 @@ function findingResult(
       primaryLocationLineHash: hashOf(found.position),
       "deadsetSymbolRef/v1": symbolFingerprint(found.code, found.symbol.ref),
     },
-    properties: propertiesOf(found),
+    properties: propertiesOf(found, members),
   };
 }
 
@@ -275,8 +281,10 @@ export function sarif(report: Report, options: RenderOptions): Iterable<string>
   const ruleList = rules(kinds);
   const index = new Map(kinds.map((kind, at) => [kind.code, at]));
   const hashOf = lineHashCache(options.readSource);
+  const listed = new Map((report.components ?? []).map((one) => [one.id, one.members]));
+  const members: MembersOf = (id) => listed.get(id) ?? [];
   const results = [
-    ...report.findings.map((found) => findingResult(found, index, hashOf)),
+    ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
     ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
   ];
   const languages = [...report.analyzer.languages].sort().join("+");

package/src/roots.ts

@@ -9,8 +9,17 @@
  */
 
 import {
+  isArrowFunction,
+  isAssertionExpression,
   isExpressionWithTypeArguments,
   isFunctionLikeDeclaration,
+  isIdentifier,
+  isMethodDeclaration,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAssignment,
+  isReturnStatement,
+  isSatisfiesExpression,
   isPropertyAccessExpression,
   isQualifiedName,
   isTypeQueryNode,
@@ -18,7 +27,10 @@ import {
   isPropertyDeclaration,
   isVariableDeclaration,
   isVariableStatement,
+  SyntaxKind,
+  type Expression,
   type Node,
+  type ObjectLiteralExpression,
   type SourceFile,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
@@ -67,6 +79,8 @@ export type RootKind =
   | "pattern"
   /** A declaration of a function or statement a type error skipped, and what it may have selected. */
   | "type-error"
+  /** An ambient global interface merging into one declared outside the target, and its holders. */
+  | "global-augmentation"
   /** A file a tool or the platform enters by its own convention, and what it exports where the tool reads it. */
   | EntryRule;
 
@@ -446,6 +460,12 @@ export function roots<Brand>(
       published.push(...entryFiles(entry));
     }
   }
+  if (options.publishedAPI) {
+    // A library's bundle hands what its entry exports to every program that loads it.
+    published.push(
+      ...points.filter((point) => point.rule === "bundler-entry").map((point) => point.file),
+    );
+  }
   const publishedNames = new Set(published.map((file) => file.fileName));
   const patterned: { file: SourceFile; pattern: string }[] = [];
   for (const pattern of options.entryFiles) {
@@ -713,17 +733,26 @@ function publishedAPI<Brand>(
       const symbol = byId.get(id);
       return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
     });
-    for (const symbol of inferredTypeSymbols(
+    const inferred = inferredTypeSymbols(
       project,
       round.flatMap((id) => {
         const symbol = byId.get(id);
         return symbol === undefined ? [] : nodes.nodesOf(symbol);
       }),
-    )) {
+    );
+    for (const symbol of inferred.types) {
       for (const target of chains.chainOf(symbol)) {
         reach(target.id);
       }
     }
+    for (const symbol of inferred.members) {
+      for (const target of chains.chainOf(symbol)) {
+        const member = byId.get(target.id);
+        if (member?.visibility === "public" || member?.visibility === "protected") {
+          reach(target.id);
+        }
+      }
+    }
     project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
       if (symbol === UNANSWERED) {
         for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
@@ -783,30 +812,139 @@ function declarationNodes(
 const INFERRED_DEPTH = 4;
 
 /**
- * The declarations of the types the compiler infers where a declaration writes none: the
- * type of a variable or a property with no annotation, and the result of a function or a
- * method with no result annotation, each with the types its type arguments and its union
- * or intersection constituents name, to a fixed depth. A question the checker leaves
- * unanswered names nothing.
+ * The values one function body returns, each through the type assertions around it: the
+ * value a caller receives carries the operand's type whatever type the assertion or the
+ * signature names. A nested function's returns are its own.
+ */
+function returnedValues(body: Node): readonly Expression[] {
+  const found: Expression[] = [];
+  const add = (value: Expression): void => {
+    for (let at: Expression | undefined = value; at !== undefined;) {
+      found.push(at);
+      at =
+        isAssertionExpression(at) || isSatisfiesExpression(at) || isParenthesizedExpression(at)
+          ? at.expression
+          : undefined;
+    }
+  };
+  if (!isFunctionLikeDeclaration(body.parent) || body.parent.body !== body) {
+    return found;
+  }
+  if (isArrowFunction(body.parent) && body.kind !== SyntaxKind.Block) {
+    add(body as Expression);
+    return found;
+  }
+  const visit = (node: Node): void => {
+    if (isFunctionLikeDeclaration(node)) {
+      return;
+    }
+    if (isReturnStatement(node) && node.expression !== undefined) {
+      add(node.expression);
+    }
+    node.forEachChild(visit);
+  };
+  body.forEachChild(visit);
+  return found;
+}
+
+/** The object literal one returned value is, written there or as the initializer of a variable `body` declares. */
+function returnedLiteral(value: Expression, body: Node): ObjectLiteralExpression | undefined {
+  if (isObjectLiteralExpression(value)) {
+    return value;
+  }
+  if (!isIdentifier(value)) {
+    return undefined;
+  }
+  let found: ObjectLiteralExpression | undefined;
+  const visit = (node: Node): void => {
+    if (
+      isVariableDeclaration(node) &&
+      isIdentifier(node.name) &&
+      node.name.text === value.text &&
+      node.initializer !== undefined
+    ) {
+      let at: Expression = node.initializer;
+      while (
+        isAssertionExpression(at) ||
+        isSatisfiesExpression(at) ||
+        isParenthesizedExpression(at)
+      ) {
+        at = at.expression;
+      }
+      found = isObjectLiteralExpression(at) ? at : found;
+    }
+    if (!isFunctionLikeDeclaration(node)) {
+      node.forEachChild(visit);
+    }
+  };
+  body.forEachChild(visit);
+  return found;
+}
+
+/**
+ * The values one function body returns, and those each method of an object literal it
+ * returns returns, to a fixed depth: a caller holding the literal calls its methods, and
+ * receives what they return.
+ */
+function returnedThroughLiterals(body: Node, depth = 0): readonly Expression[] {
+  const values = returnedValues(body);
+  if (depth >= INFERRED_DEPTH) {
+    return values;
+  }
+  const found = [...values];
+  for (const value of values) {
+    for (const property of returnedLiteral(value, body)?.properties ?? []) {
+      const fn = isMethodDeclaration(property)
+        ? property
+        : isPropertyAssignment(property) && isFunctionLikeDeclaration(property.initializer)
+          ? property.initializer
+          : undefined;
+      if (fn?.body !== undefined) {
+        found.push(...returnedThroughLiterals(fn.body, depth + 1));
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * The declarations of the types the compiler infers where a declaration writes none, and
+ * of the values a function returns: the type of a variable or a property with no
+ * annotation, the result of a function or a method with no result annotation, and the type
+ * of each value its body returns, each with the types its type arguments and its union or
+ * intersection constituents name, to a fixed depth; and as `members` the properties of each
+ * returned value's type. A question the checker leaves unanswered names nothing.
  */
 function inferredTypeSymbols<Brand>(
   project: ProjectView<Brand>,
   declarations: readonly Node[],
-): readonly TSSymbol[] {
+): { readonly types: readonly TSSymbol[]; readonly members: readonly TSSymbol[] } {
   const { queries } = project;
-  const valued = declarations.flatMap((node) =>
+  const valued: Node[] = declarations.flatMap((node) =>
     (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
     node.type === undefined &&
     !isFunctionLikeDeclaration(node.initializer ?? node)
       ? [node.name]
       : [],
   );
+  const returned = declarations.flatMap((node) => {
+    const signature = isFunctionLikeDeclaration(node)
+      ? node
+      : isVariableDeclaration(node) &&
+          node.initializer !== undefined &&
+          isFunctionLikeDeclaration(node.initializer)
+        ? node.initializer
+        : undefined;
+    return signature?.body === undefined ? [] : returnedThroughLiterals(signature.body);
+  });
   const types: Type[] = [];
-  queries.typesAt(valued).forEach((type) => {
+  const returnedTypes: Type[] = [];
+  queries.typesAt([...valued, ...returned]).forEach((type, at) => {
     if (type !== UNANSWERED && type !== undefined) {
-      types.push(type);
+      (at < valued.length ? types : returnedTypes).push(type);
     }
   });
+  types.push(...returnedTypes);
   for (const node of declarations) {
     const signature = isFunctionLikeDeclaration(node)
       ? node
@@ -849,7 +987,19 @@ function inferredTypeSymbols<Brand>(
   types.forEach((type) => {
     visit(type, 0);
   });
-  return [...found.values()];
+  // A returned value carries each property of its type, one an anonymous type declares or
+  // an intersection merges included, which no type name reaches.
+  const members = new Map<number, TSSymbol>();
+  for (const type of returnedTypes) {
+    const parts = queries.constituents(type);
+    for (const one of [type, ...(parts === UNANSWERED ? [] : parts)]) {
+      const properties = queries.propertiesOf(one);
+      for (const property of properties === UNANSWERED ? [] : properties) {
+        members.set(property.id, property);
+      }
+    }
+  }
+  return { types: [...found.values()], members: [...members.values()] };
 }
 
 /**