@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/src/exemptions/generated-file.ts

@@ -0,0 +1,318 @@
+/**
+ * The generated-file class on TypeScript: every declaration in a file that marks itself
+ * generated, below a directory an applied convention row names as generated, or minified,
+ * is retained, because a generator owns the file and a deletion there is undone at the next
+ * generation. The same decision is each `generated` entry of the facts document.
+ */
+
+import {
+  isIdentifier,
+  isImportDeclaration,
+  isPropertyAssignment,
+  isStringLiteralLikeNode,
+  isVariableStatement,
+  NodeFlags,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { GENERATORS } from "../contract/contract.generated.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { minifiedBy } from "../javascript-file.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
+import { satisfies } from "../version-range.ts";
+
+/** The generated-code header, matched against each line of a leading comment. */
+const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
+
+/** The documentation tag `@generated` as a word of a comment. */
+const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
+
+/** A first comment naming the tool that wrote the file. */
+const GENERATED_BY = /^\/\/ Generated by \S/u;
+
+/** The word a generator's notice holds, beside one of {@link KEEP_OUT}. */
+const GENERATED_WORD = /\bgenerated\b/iu;
+
+/** The phrases a generator's notice asks a reader not to edit the file by. */
+const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
+
+/** What decided a file generated, as the facts document's `evidence` names it. */
+type GeneratedEvidence = "header" | "tag" | "notice" | "convention" | "minified";
+
+/** The generator row one generated file matches, with the version and the schema files its output states. */
+interface GeneratorMatch {
+  readonly row: string;
+  readonly version?: string;
+  readonly schemaFiles: readonly string[];
+}
+
+/** Why one file is generated, and which generator wrote it. */
+export interface GeneratedFact {
+  readonly evidence: GeneratedEvidence;
+  /** The 1-based line of the comment line that marks the file; 1 for a row or a minified file. */
+  readonly line: number;
+  /** The marking line's text, the convention row's name, or what decided the file minified. */
+  readonly detail: string;
+  readonly generator?: GeneratorMatch;
+}
+
+/** One line of a leading comment, with its 1-based line in the file. */
+interface CommentLine {
+  readonly text: string;
+  readonly line: number;
+}
+
+/** The comments before a text's first token, a leading hashbang line skipped, each as its lines. */
+function leadingComments(text: string): readonly (readonly CommentLine[])[] {
+  const comments: CommentLine[][] = [];
+  const lineAt = (offset: number): number =>
+    text.slice(0, offset).split(/\r\n|[\n\r\u2028\u2029]/u).length;
+  const lines = (from: number, to: number): CommentLine[] => {
+    const first = lineAt(from);
+    return text
+      .slice(from, to)
+      .split(/\r\n|[\n\r\u2028\u2029]/u)
+      .map((one, index) => ({ text: one, line: first + index }));
+  };
+  let at = text.startsWith("\uFEFF") ? 1 : 0;
+  if (text.startsWith("#!", at)) {
+    const end = text.indexOf("\n", at);
+    at = end === -1 ? text.length : end + 1;
+  }
+  for (;;) {
+    while (at < text.length && /\s/u.test(text.charAt(at))) {
+      at++;
+    }
+    if (text.startsWith("//", at)) {
+      const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
+      const stop = end === -1 ? text.length : at + end;
+      comments.push(lines(at, stop));
+      at = stop;
+    } else if (text.startsWith("/*", at)) {
+      const end = text.indexOf("*/", at + 2);
+      if (end === -1) {
+        return comments;
+      }
+      comments.push(lines(at, end + 2));
+      at = end + 2;
+    } else {
+      return comments;
+    }
+  }
+}
+
+/** The mark one file's leading comments make it generated by, or undefined where they mark nothing. */
+export function generatedMark(text: string): Omit<GeneratedFact, "generator"> | undefined {
+  const lines = leadingComments(text).flat();
+  const header = lines.find((one) => HEADER_LINE.test(one.text));
+  if (header !== undefined) {
+    return { evidence: "header", line: header.line, detail: header.text };
+  }
+  const tag = lines.find((one) => GENERATED_TAG.test(one.text));
+  if (tag !== undefined) {
+    return { evidence: "tag", line: tag.line, detail: tag.text };
+  }
+  const [first] = lines;
+  if (first !== undefined && GENERATED_BY.test(first.text)) {
+    return { evidence: "notice", line: first.line, detail: first.text };
+  }
+  const notice = lines.map((one) => one.text).join("\n");
+  if (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice)) {
+    const marked = lines.find((one) => GENERATED_WORD.test(one.text) || KEEP_OUT.test(one.text));
+    return marked === undefined
+      ? undefined
+      : { evidence: "notice", line: marked.line, detail: marked.text };
+  }
+  return undefined;
+}
+
+/** What one form's first group captures, for each line the form matches. */
+function after(lines: readonly CommentLine[], form: RegExp): readonly string[] {
+  return lines.flatMap((one) => form.exec(one.text)?.[1] ?? []);
+}
+
+/**
+ * Where each plugin's output states its version and its schema files, as `references-ts.36`
+ * states: a plugin missing here states no version, and one with no schema form names none.
+ */
+const STATEMENTS: Readonly<Record<string, { version?: RegExp; schemaFiles?: RegExp }>> = {
+  "protoc-gen-es": {
+    version: /^\/\/ @generated by protoc-gen-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protoc-gen-connect-es": {
+    version: /^\/\/ @generated by protoc-gen-connect-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protobuf-ts": {
+    version: /^\/\/ @generated by protobuf-ts (\S+)/u,
+    schemaFiles: /^\/\/ @generated from protobuf file "([^"]+)"/u,
+  },
+  "ts-proto": {
+    version: /^\/\/\s+protoc-gen-ts_proto\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-grpc-web": {
+    version: /^\/\/\s+protoc-gen-grpc-web\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-js": { schemaFiles: /^\/\/ source: (.+)$/u },
+  "ts-protoc-gen": { schemaFiles: /^\/\/ file: (.+)$/u },
+};
+
+/** A ts-proto service path literal: `/<package>.<service>/<method>`. */
+const SERVICE_PATH = /^\/(?:\w+\.)+\w+\/\w+$/u;
+
+/** Whether one ts-proto file writes a service path, as `references-ts.36` reads one. */
+function writesServicePath(file: SourceFile): boolean {
+  const named = file.statements.some(
+    (statement) =>
+      isVariableStatement(statement) &&
+      (statement.declarationList.flags & NodeFlags.Const) !== 0 &&
+      statement.declarationList.declarations.some(
+        (one) =>
+          isIdentifier(one.name) &&
+          one.name.text.endsWith("ServiceName") &&
+          one.initializer !== undefined &&
+          isStringLiteralLikeNode(one.initializer),
+      ),
+  );
+  let found = named;
+  const visit = (node: Node): void => {
+    if (found) {
+      return;
+    }
+    if (
+      isPropertyAssignment(node) &&
+      isIdentifier(node.name) &&
+      node.name.text === "path" &&
+      isStringLiteralLikeNode(node.initializer) &&
+      SERVICE_PATH.test(node.initializer.text)
+    ) {
+      found = true;
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
+/** Whether one file imports a module by its specifier. */
+function imports(file: SourceFile, module: string): boolean {
+  return file.statements.some(
+    (statement) =>
+      isImportDeclaration(statement) &&
+      isStringLiteralLikeNode(statement.moduleSpecifier) &&
+      statement.moduleSpecifier.text === module,
+  );
+}
+
+/** The option sets the rows of `references-ts.36` name, by row; every other row's is met by any output. */
+const OPTION_SETS: Readonly<Record<string, (file: SourceFile) => boolean>> = {
+  "ts-proto-2-output-schema": (file) => imports(file, "ts-proto-descriptors"),
+  "ts-proto-2": writesServicePath,
+  "ts-proto-2-types": (file) => !writesServicePath(file),
+};
+
+/** The first generator row one file matches, in `generators.json`'s order, as `bindings.3` reads it. */
+export function generatorOf(file: SourceFile): GeneratorMatch | undefined {
+  const lines = leadingComments(file.text).flat();
+  for (const row of GENERATORS) {
+    const header = new RegExp(row.header, "u");
+    if (!lines.some((one) => header.test(one.text))) {
+      continue;
+    }
+    const statements = STATEMENTS[row.plugin] ?? {};
+    const [version] = statements.version === undefined ? [] : after(lines, statements.version);
+    if (
+      "versions" in row &&
+      (version === undefined ||
+        !satisfies(
+          version.replace(/^v/u, ""),
+          `>=${row.versions.min.replace(/^v/u, "")} <=${row.versions.max.replace(/^v/u, "")}`,
+        ))
+    ) {
+      continue;
+    }
+    if (OPTION_SETS[row.id]?.(file) === false) {
+      continue;
+    }
+    const schemaFiles =
+      statements.schemaFiles === undefined
+        ? []
+        : [
+            ...new Set(
+              after(lines, statements.schemaFiles).filter((one) => one.endsWith(".proto")),
+            ),
+          ].sort(bytewise);
+    return { row: row.id, ...(version === undefined ? {} : { version }), schemaFiles };
+  }
+  return undefined;
+}
+
+/**
+ * Every own file of one project that is generated, by its path below the target root, with
+ * what decided it: its leading comments' mark, else the row naming its directory as
+ * generated, else its minified name or text; and the generator row it matches.
+ */
+export function generatedFilesOf(
+  files: SourceFiles,
+  byRow: ReadonlyMap<string, string>,
+): ReadonlyMap<string, GeneratedFact> {
+  const found = new Map<string, GeneratedFact>();
+  for (const [path, file] of files.byPath) {
+    const row = byRow.get(path);
+    const minified = row === undefined ? minifiedBy(file.fileName, file.text) : undefined;
+    const fact =
+      generatedMark(file.text) ??
+      (row === undefined
+        ? minified === undefined
+          ? undefined
+          : { evidence: "minified" as const, line: 1, detail: minified }
+        : { evidence: "convention" as const, line: 1, detail: row });
+    if (fact === undefined) {
+      continue;
+    }
+    const generator = generatorOf(file);
+    found.set(path, generator === undefined ? fact : { ...fact, generator });
+  }
+  return found;
+}
+
+/** The detail a retention in a generated file names, from what decided the file. */
+function retentionDetail(fact: GeneratedFact): string {
+  switch (fact.evidence) {
+    case "header":
+      return "generated by the header line its leading comments hold";
+    case "tag":
+      return "generated by the @generated tag its leading comments hold";
+    case "notice":
+      return "generated by the notice its leading comments hold";
+    case "convention":
+      return `generated below a directory the convention row ${fact.detail} names`;
+    case "minified":
+      return "generated as a minified JavaScript file";
+  }
+}
+
+/** The generated-file detector, recording each file's first line. */
+export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
+  const generated = input.generated;
+  if (generated === undefined || generated.size === 0) {
+    return [];
+  }
+  return input.held.symbols.flatMap((symbol): Evidence[] => {
+    const fact = generated.get(symbol.position.path);
+    return symbol.kind === "file" || fact === undefined
+      ? []
+      : [
+          {
+            id: symbol.id,
+            detail: retentionDetail(fact),
+            site: { path: symbol.position.path, line: 1, column: 1 },
+          },
+        ];
+  });
+}

package/src/{injection-container.ts → exemptions/injection-container.ts}

@@ -8,8 +8,6 @@
  */
 
 import {
-  isClassDeclaration,
-  isClassExpression,
   isConstructorDeclaration,
   isGetAccessorDeclaration,
   isPropertyDeclaration,
@@ -18,19 +16,20 @@ import {
   type Decorator,
   type Node,
 } from "@typescript/native/ast";
-import { aliasChains } from "./alias-chain.ts";
-import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.ts";
-import { classMembers, type ClassMember } from "./class-members.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nameOf } from "../index/values.ts";
+import { classesPassed, decoratorsOf, spelledDecorator } from "./calls.ts";
+import { classMembers, type ClassMember } from "../class-members.ts";
 import {
   entriesAt,
   namesADeclaration,
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./configured-declarations.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { isParameterProperty, nodeKey } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
+} from "../roots/configured-declarations.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { isParameterProperty } from "../inventory.ts";
+import { renderPosition } from "../position.ts";
 
 /** One class a container constructs, by the registration that says so. */
 interface Registration {
@@ -52,32 +51,36 @@ function isInjected(node: Node): boolean {
 
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations<Brand>(input: DetectorInput<Brand>): readonly Registration[] {
-  const { project, held } = input;
-  const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+  const { project, held, sites } = input;
+  const resolved = resolveEntries(project, held, input.ts.injection_registrations);
   if (!resolved.some(namesADeclaration)) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const calls = callsOf(project);
+  const calls = sites.calls.map((one) => one.call);
+  const invoked = (call: CallExpression): Node | undefined =>
+    nameOf(sites.invocations.of(call).callee);
   const named = entriesAt(
     project,
     chains,
-    calls.flatMap((call) => calleeName(call.expression) ?? []),
+    calls.flatMap((call) => invoked(call) ?? []),
     resolved,
   );
   const matched = new Map<CallExpression, ResolvedEntry>();
   for (const call of calls) {
-    const name = calleeName(call.expression);
+    const name = invoked(call);
     const [entry] = name === undefined ? [] : (named.get(name) ?? []);
     if (entry !== undefined) {
       matched.set(call, entry);
     }
   }
-  return [...classesPassed(project, held, chains, [...matched.keys()])].flatMap(([call, uses]) => {
-    const entry = matched.get(call);
-    const detail = entry === undefined ? "" : `registered by ${spelledEntry(entry.entry, held)}`;
-    return uses.map((use) => ({ id: use.id, site: use.site, detail }));
-  });
+  return [...classesPassed(project, held, chains, sites, [...matched.keys()])].flatMap(
+    ([call, uses]) => {
+      const entry = matched.get(call);
+      const detail = entry === undefined ? "" : `registered by ${spelledEntry(entry.entry, held)}`;
+      return uses.map((use) => ({ id: use.id, site: use.site, detail }));
+    },
+  );
 }
 
 /**
@@ -87,22 +90,14 @@ function registrations<Brand>(input: DetectorInput<Brand>): readonly Registratio
 function constructedForParameters<Brand>(
   input: DetectorInput<Brand>,
 ): ReadonlyMap<string, Decorator> {
-  const { project, held } = input;
   const found = new Map<string, Decorator>();
-  for (const file of project.ownSourceFiles()) {
-    const visit = (node: Node): void => {
-      if (isClassDeclaration(node) || isClassExpression(node)) {
-        const id = held.declarations.get(nodeKey(file, node));
-        const [asks] = node.members.flatMap((member) =>
-          isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : [],
-        );
-        if (id !== undefined && asks !== undefined) {
-          found.set(id, asks);
-        }
-      }
-      node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+  for (const { id, node } of input.sites.classes) {
+    const [asks] = node.members.flatMap((member) =>
+      isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : [],
+    );
+    if (asks !== undefined) {
+      found.set(id, asks);
+    }
   }
   return found;
 }

package/src/exemptions/installed-globals.ts

@@ -0,0 +1,255 @@
+/**
+ * The classes a program installs as globals: a class value written into a property of
+ * the global object, which code outside the analysis that names the global constructs.
+ * The checker finds each write: the receiver's type is the global object's, the callee is
+ * the standard library's `Object.defineProperty` or a test runner's stub, and the
+ * property is the one of the key's name that `typeof globalThis` declares.
+ */
+
+import {
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isShorthandPropertyAssignment,
+  isStringLiteral,
+  type Expression,
+  type Node,
+} from "@typescript/native/ast";
+import {
+  SignatureKind,
+  SymbolFlags,
+  type Symbol as TSSymbol,
+  type Type,
+} from "@typescript/native/sync";
+import type { AliasChains } from "../alias-chain.ts";
+import { typesAt } from "../class-members.ts";
+import { packageOfPath } from "../dependencies.ts";
+import type { Inventory } from "../inventory.ts";
+import { must } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { parenthesesRemoved, unwrapped } from "../unwrap.ts";
+import { spansOf } from "./argument-places.ts";
+import { classesCarried } from "./calls.ts";
+import type { ProjectSites } from "./sites.ts";
+
+/** A call that writes a value into a property of an object, by the places of its arguments. */
+interface Writer {
+  /** The object's place, none where the object is the global one. */
+  readonly object: number | undefined;
+  readonly key: number;
+  readonly value: number;
+  /** Whether the value is the `value` member of a property descriptor. */
+  readonly described: boolean;
+}
+
+/**
+ * The test runners' stubs of a global, by method name and the packages that declare it:
+ * `vi.stubGlobal` of vitest, and `jest.replaceProperty`, which `@jest/environment` types
+ * for `@jest/globals` and `@types/jest` declares for the `jest` global.
+ */
+const STUBS: ReadonlyMap<string, Writer & { readonly packages: ReadonlySet<string> }> = new Map([
+  [
+    "stubGlobal",
+    { packages: new Set(["vitest"]), object: undefined, key: 0, value: 1, described: false },
+  ],
+  [
+    "replaceProperty",
+    {
+      packages: new Set(["@jest/environment", "@jest/globals", "@types/jest"]),
+      object: 0,
+      key: 1,
+      value: 2,
+      described: false,
+    },
+  ],
+]);
+
+/** `Object.defineProperty(object, key, descriptor)`. */
+const DEFINE: Writer = { object: 0, key: 1, value: 2, described: true };
+
+/** One write of a value into a property a written key names. */
+interface Write {
+  readonly site: Node;
+  /** The object written to, none where it is the global one. */
+  readonly receiver: Expression | undefined;
+  readonly key: string;
+  readonly value: Expression;
+}
+
+/** One class a write installs as a global, and the instance types the global constructs. */
+interface Installed {
+  readonly id: string;
+  readonly site: Node;
+  readonly global: string;
+  readonly instances: readonly Type[];
+}
+
+/** The text of a key written as a string literal. */
+function keyText(node: Expression | undefined): string | undefined {
+  const key = node === undefined ? undefined : parenthesesRemoved(node);
+  return key !== undefined && (isStringLiteral(key) || isNoSubstitutionTemplateLiteral(key))
+    ? key.text
+    : undefined;
+}
+
+/** Whether a property's name is `value`. */
+function named(name: Node): boolean {
+  return (isIdentifier(name) || isStringLiteral(name)) && name.text === "value";
+}
+
+/** The value a property descriptor written as an object literal gives. */
+function describedValue(node: Expression | undefined): Expression | undefined {
+  const descriptor = node === undefined ? undefined : parenthesesRemoved(node);
+  if (descriptor === undefined || !isObjectLiteralExpression(descriptor)) {
+    return undefined;
+  }
+  for (const property of descriptor.properties) {
+    if (isPropertyAssignment(property) && named(property.name)) {
+      return property.initializer;
+    }
+    if (
+      isShorthandPropertyAssignment(property) &&
+      isIdentifier(property.name) &&
+      named(property.name)
+    ) {
+      return property.name;
+    }
+  }
+  return undefined;
+}
+
+/** How a call's callee writes a property: the standard library's `Object.defineProperty` or a runner's stub. */
+function writerOf<Brand>(project: ProjectView<Brand>, method: TSSymbol): Writer | undefined {
+  if (method.name === "defineProperty") {
+    const standard = method.declarations.some(
+      (handle) => project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true,
+    );
+    return standard && must(project.queries.parentOf(method))?.name === "ObjectConstructor"
+      ? DEFINE
+      : undefined;
+  }
+  const stub = STUBS.get(method.name);
+  return stub !== undefined &&
+    method.declarations.some((handle) => stub.packages.has(packageOfPath(handle.path) ?? ""))
+    ? stub
+    : undefined;
+}
+
+/** Each write of one project's own files that may install a value as a global, read from syntax and the callee. */
+function writesOf<Brand>(project: ProjectView<Brand>, sites: ProjectSites): readonly Write[] {
+  const found: Write[] = sites.stores.map((store) => ({
+    site: store.store,
+    receiver: store.receiver,
+    key: store.key,
+    value: store.value,
+  }));
+  for (const { call } of sites.calls) {
+    const method = sites.invocations.callee(call);
+    const writer = method === undefined ? undefined : writerOf(project, method);
+    if (writer === undefined) {
+      continue;
+    }
+    const invoked = sites.invocations.of(call);
+    // With no types asked, a spread has no known length, so only a place no spread
+    // comes at or before is read.
+    const spans = spansOf(project, invoked.arguments, invoked.listed, []);
+    const at = (place: number): Expression | undefined => {
+      const span = spans.find((one) => !one.open && one.first === place);
+      return span === undefined ? undefined : invoked.arguments[span.argument];
+    };
+    const key = keyText(at(writer.key));
+    const receiver = writer.object === undefined ? undefined : at(writer.object);
+    const value = writer.described ? describedValue(at(writer.value)) : at(writer.value);
+    if (
+      key !== undefined &&
+      value !== undefined &&
+      (writer.object === undefined || receiver !== undefined)
+    ) {
+      found.push({ site: call, receiver, key, value });
+    }
+  }
+  return found;
+}
+
+/**
+ * The classes one project installs as globals. A write installs one where its object is
+ * the global object, as the checker types it (`window` and `self` are intersections that
+ * hold `typeof globalThis`, and an object asserted to `any` is read inside the
+ * assertion), and where the global object declares a property of the key's name with a
+ * construct signature, whose instances code outside the analysis makes.
+ */
+export function installedGlobals<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  sites: ProjectSites,
+): readonly Installed[] {
+  const { queries } = project;
+  const writes = writesOf(project, sites);
+  if (writes.length === 0) {
+    return [];
+  }
+  const global = must(queries.resolveName("globalThis", SymbolFlags.Value, undefined, false));
+  const globalType = global === undefined ? undefined : must(queries.typeOfSymbol(global));
+  if (global === undefined || globalType === undefined) {
+    return [];
+  }
+  const properties = new Map(
+    must(queries.propertiesOf(globalType)).map((property) => [property.name, property]),
+  );
+  const keyed = writes.filter((write) => properties.has(write.key));
+  const objects = keyed.flatMap((write) =>
+    write.receiver === undefined ? [] : [unwrapped(write.receiver)],
+  );
+  const objectTypes = new Map(
+    typesAt(project, objects).map((type, at) => [objects[at], type] as const),
+  );
+  const globals = new Map<number, boolean>();
+  const isGlobal = (type: Type | undefined): boolean => {
+    if (type === undefined) {
+      return false;
+    }
+    let known = globals.get(type.id);
+    if (known === undefined) {
+      const parts =
+        type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : [type];
+      known = parts.some((part) => must(queries.symbolOfType(part))?.id === global.id);
+      globals.set(type.id, known);
+    }
+    return known;
+  };
+  const installs = keyed.filter(
+    (write) => write.receiver === undefined || isGlobal(objectTypes.get(unwrapped(write.receiver))),
+  );
+  if (installs.length === 0) {
+    return [];
+  }
+  const instances = new Map<string, readonly Type[]>();
+  const instancesOf = (key: string): readonly Type[] => {
+    let made = instances.get(key);
+    if (made === undefined) {
+      const property = properties.get(key);
+      const type = property === undefined ? undefined : must(queries.typeOfSymbol(property));
+      made = (
+        type === undefined ? [] : must(queries.signaturesOf(type, SignatureKind.Construct))
+      ).flatMap((signature) => must(queries.returnTypeOf(signature)) ?? []);
+      instances.set(key, made);
+    }
+    return made;
+  };
+  const carried = classesCarried(
+    project,
+    held,
+    chains,
+    sites,
+    installs.map((write) => [write.value]),
+  );
+  return installs.flatMap((write, at) => {
+    const uses = carried[at] ?? [];
+    const made = uses.length === 0 ? [] : instancesOf(write.key);
+    return made.length === 0
+      ? []
+      : uses.map((use) => ({ id: use.id, site: write.site, global: write.key, instances: made }));
+  });
+}