openapi-typesafe 1.0.0-rc.0 → 1.0.0-rc.2

package/src/application/transform/document/path-key-overlaps.ts

@@ -6,6 +6,8 @@
  * TS2413). These functions find the signatures that cover another key the checker rejects.
  */
 
+import { isAssignableToTemplate, type TemplateShape } from "./template-key-match.js";
+
 /** A placeholder of a template literal type, by the type it stands for. */
 export type PathPlaceholder = "string" | "number" | "boolean";
 
@@ -21,89 +23,176 @@ export type PathKey =
 
 const BOOLEAN_TEXTS: readonly string[] = ["true", "false"];
 
-/** The text one placeholder stands for in a sample of a template key. */
-const SAMPLE_TEXTS: Readonly<Record<PathPlaceholder, string>> = {
-  string: "",
-  number: "0",
-  boolean: "true",
-};
-
-/** TypeScript's rule for `${number}`: a text that converts to a finite number. */
-function isNumberText(text: string): boolean {
-  return text !== "" && Number.isFinite(Number(text));
+/** The shapes after one more part; a boolean placeholder doubles them, as TypeScript does. */
+function withPart(shapes: readonly TemplateShape[], part: PathKeyPart): TemplateShape[] {
+  return shapes.flatMap((shape): TemplateShape[] => {
+    const lead = shape.texts.slice(0, -1);
+    // A shape has one text more than it has placeholders, so it always has a last text.
+    const last = shape.texts[shape.texts.length - 1] as string;
+    if (part.kind === "text") {
+      return [{ texts: [...lead, last + part.text], types: shape.types }];
+    }
+    if (part.type === "boolean") {
+      return BOOLEAN_TEXTS.map((text) => ({ texts: [...lead, last + text], types: shape.types }));
+    }
+    return [{ texts: [...shape.texts, ""], types: [...shape.types, part.type] }];
+  });
 }
 
-function isPlaceholderText(type: PathPlaceholder, text: string): boolean {
-  if (type === "number") {
-    return isNumberText(text);
+/**
+ * The key types TypeScript makes of a key: a literal is one text; a template is one shape, or a
+ * union of shapes when `${boolean}` is in it (`` `/a/${boolean}` `` is `"/a/true" | "/a/false"`).
+ */
+function shapesOf(key: PathKey): readonly TemplateShape[] {
+  if (key.kind === "literal") {
+    return [{ texts: [key.url], types: [] }];
   }
-  return type === "boolean" ? BOOLEAN_TEXTS.includes(text) : true;
+  return key.parts.reduce<TemplateShape[]>(withPart, [{ texts: [""], types: [] }]);
 }
 
-/** Whether `text` from `start` on is one of the strings the parts from `index` on describe. */
-function matchesFrom(
-  text: string,
-  start: number,
-  parts: readonly PathKeyPart[],
-  index: number,
+/**
+ * Whether a signature checks the covered key: every type of the covered key is assignable to one
+ * of the signature's types. A shape without placeholders (a boolean-only template) is a string
+ * literal, which is no signature, so the targets leave it out.
+ */
+function isCoveredBy(
+  sources: readonly TemplateShape[],
+  targets: readonly TemplateShape[],
 ): boolean {
-  const part = parts[index];
-  if (part === undefined) {
-    return start === text.length;
-  }
-  if (part.kind === "text") {
-    return (
-      text.startsWith(part.text, start) &&
-      matchesFrom(text, start + part.text.length, parts, index + 1)
-    );
-  }
-  for (let end = start; end <= text.length; end += 1) {
-    if (
-      isPlaceholderText(part.type, text.slice(start, end)) &&
-      matchesFrom(text, end, parts, index + 1)
-    ) {
-      return true;
+  return (
+    sources.length > 0 &&
+    sources.every((source) => targets.some((target) => isAssignableToTemplate(source, target)))
+  );
+}
+
+/** Whether TypeScript rejects the key at `covered` for the signature at `covering`. */
+export type CoverRejection = (covering: number, covered: number) => boolean;
+
+/** Without type information every covered key counts. */
+const EVERY_COVER_REJECTED: CoverRejection = () => true;
+
+/**
+ * The key types TypeScript checks against a signature: a literal's, or a template's signature
+ * types. A boolean-only template is no signature (TS1337), so the checker neither checks it nor
+ * checks anything against it; a repeated one is still reported (TS2374, see `repeatedTemplates`).
+ */
+function checkedShapes(key: PathKey): readonly TemplateShape[] {
+  const shapes = shapesOf(key);
+  return key.kind === "literal" ? shapes : shapes.filter((shape) => shape.types.length > 0);
+}
+
+/** A checked key: the key, the shapes TypeScript checks, and its template identity. */
+interface CheckedKey {
+  readonly key: PathKey;
+  readonly shapes: readonly TemplateShape[];
+  /** The key types written as one string, for templates; null for a literal. */
+  readonly template: string | null;
+}
+
+function checkedKeyOf(key: PathKey): CheckedKey {
+  const template = key.kind === "template" ? JSON.stringify(shapesOf(key)) : null;
+  return { key, shapes: checkedShapes(key), template };
+}
+
+/**
+ * The templates written more than once, as paths that differ only in parameter names give
+ * (`/a/{id}`, `/a/{name}`). OpenAPI forbids such paths, and one object with both signatures fails
+ * to compile whatever their types (TS2374), so each always counts as covering the other.
+ */
+function repeatedTemplates(checked: readonly CheckedKey[]): ReadonlySet<string> {
+  const seen = new Set<string>();
+  const repeated = new Set<string>();
+  for (const { template } of checked) {
+    if (template !== null) {
+      (seen.has(template) ? repeated : seen).add(template);
     }
   }
-  return false;
+  return repeated;
 }
 
 /**
- * One string of the key. If a template key is covered, every string of it is, so a sample that is
- * not covered proves the key is not; a sample that is covered may over-report, which only moves a
- * signature that did not need it (the types stay the same, see `pathsObjectType`).
+ * The checked keys by the first text of each of their shapes, sorted. A key type is assignable to
+ * a template only when its first text starts with the template's first text (both branches of
+ * `isAssignableToTemplate`), so the keys a template can cover are one run of this list. Without
+ * it the check compares every pair of keys, which takes minutes for 10 000 paths.
  */
-function sampleOf(key: PathKey): string {
-  if (key.kind === "literal") {
-    return key.url;
+interface StartTextIndex {
+  readonly starts: readonly string[];
+  readonly keyIndexes: readonly number[];
+}
+
+/** Code unit order: in it the strings that start with one prefix are adjacent. */
+function compareCodeUnits(left: string, right: string): number {
+  if (left === right) {
+    return 0;
   }
-  return key.parts
-    .map((part) => (part.kind === "text" ? part.text : SAMPLE_TEXTS[part.type]))
-    .join("");
+  return left < right ? -1 : 1;
 }
 
-/** Whether TypeScript rejects the key at `covered` for the signature at `covering`. */
-export type CoverRejection = (covering: number, covered: number) => boolean;
+function startTextIndexOf(checked: readonly CheckedKey[]): StartTextIndex {
+  const entries = checked.flatMap(({ shapes }, keyIndex) =>
+    shapes.map((shape) => ({ start: shape.texts[0] as string, keyIndex })),
+  );
+  entries.sort((left, right) => compareCodeUnits(left.start, right.start));
+  return {
+    starts: entries.map((entry) => entry.start),
+    keyIndexes: entries.map((entry) => entry.keyIndex),
+  };
+}
 
-/** Without type information every covered key counts. */
-const EVERY_COVER_REJECTED: CoverRejection = () => true;
+/** The indexes of the keys with a shape whose first text starts with one of the prefixes. */
+function keysStartingWith(index: StartTextIndex, prefixes: readonly string[]): Set<number> {
+  const found = new Set<number>();
+  for (const prefix of prefixes) {
+    let low = 0;
+    let high = index.starts.length;
+    while (low < high) {
+      const middle = (low + high) >> 1;
+      if ((index.starts[middle] as string) < prefix) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    for (let at = low; at < index.starts.length; at += 1) {
+      if (!(index.starts[at] as string).startsWith(prefix)) {
+        break;
+      }
+      found.add(index.keyIndexes[at] as number);
+    }
+  }
+  return found;
+}
 
-/** The indexes of the template keys that cover another key of the list, where it is rejected. */
+/**
+ * The indexes of the template keys that cover another key of the list, where it is rejected, or
+ * that repeat another template key. A template covers the keys TypeScript checks against it, the
+ * ones its own matching accepts (see `template-key-match.ts`), not every string it stands for:
+ * `` `/a/b/${number}` `` is no `` `/${string}/${number}` `` to the checker, which does not
+ * backtrack, so that pair is never checked.
+ */
 export function coveringTemplateKeys(
   keys: readonly PathKey[],
   isRejected: CoverRejection = EVERY_COVER_REJECTED,
 ): ReadonlySet<number> {
+  const checked = keys.map(checkedKeyOf);
+  const repeated = repeatedTemplates(checked);
+  const startTexts = startTextIndexOf(checked);
   const covering = new Set<number>();
-  keys.forEach((key, index) => {
-    if (key.kind !== "template") {
+  checked.forEach(({ template, shapes: targets }, index) => {
+    if (template === null) {
       return;
     }
-    const isCovering = keys.some(
-      (other, otherIndex) =>
-        otherIndex !== index &&
-        matchesFrom(sampleOf(other), 0, key.parts, 0) &&
-        isRejected(index, otherIndex),
-    );
+    const prefixes = targets.map((target) => target.texts[0] as string);
+    const candidates = [...keysStartingWith(startTexts, prefixes)].sort((a, b) => a - b);
+    const isCovering =
+      repeated.has(template) ||
+      candidates.some(
+        (otherIndex) =>
+          otherIndex !== index &&
+          isCoveredBy((checked[otherIndex] as CheckedKey).shapes, targets) &&
+          isRejected(index, otherIndex),
+      );
     if (isCovering) {
       covering.add(index);
     }

package/src/application/transform/document/path-template-replace.ts

@@ -0,0 +1,90 @@
+import type { PathKeyPart, PathPlaceholder } from "./path-key-overlaps.js";
+
+/**
+ * The `--path-params-as-types` key as the original builds it: each `{name}` match, in URL order,
+ * replaces the first occurrence of its text in the key so far. A parameter named `number`,
+ * `string` or `boolean` can so hit the `${number}` an earlier parameter got: of
+ * `/a/{id}/b/{number}` the original makes `/a/$${number}/b/{number}`. That output compiles, so it
+ * stays the default (ADR-021); the `path-param-type-names` fix gives every match its own
+ * placeholder.
+ */
+
+/** One `{name}` of the URL and the placeholder of its parameter's type. */
+export interface PathParameterMatch {
+  readonly match: string;
+  readonly type: PathPlaceholder;
+}
+
+/**
+ * One UTF-16 code unit of the key so far (`indexOf` counts those): URL text, or a unit of the
+ * placeholder that the match at `owner` inserted.
+ */
+interface KeyUnit {
+  readonly unit: string;
+  readonly owner: number | null;
+}
+
+const URL_TEXT = null;
+
+/** `${type}`: the text of a template literal type placeholder. */
+export function placeholderText(type: PathPlaceholder): string {
+  return `\${${type}}`;
+}
+
+/** The key's units after each match replaced the first occurrence of its text. */
+function replacedUnits(url: string, matches: readonly PathParameterMatch[]): readonly KeyUnit[] {
+  const units: KeyUnit[] = url.split("").map((unit) => ({ unit, owner: URL_TEXT }));
+  matches.forEach(({ match, type }, owner) => {
+    const at = units
+      .map(({ unit }) => unit)
+      .join("")
+      .indexOf(match);
+    if (at >= 0) {
+      const inserted = placeholderText(type)
+        .split("")
+        .map((unit) => ({ unit, owner }));
+      units.splice(at, match.length, ...inserted);
+    }
+  });
+  return units;
+}
+
+/** The placeholders, by match, that no later match cut into. */
+function intactPlaceholders(
+  units: readonly KeyUnit[],
+  matches: readonly PathParameterMatch[],
+): ReadonlyMap<number, PathPlaceholder> {
+  const intact = new Map<number, PathPlaceholder>();
+  matches.forEach(({ type }, owner) => {
+    const left = units.filter((unit) => unit.owner === owner).length;
+    if (left === placeholderText(type).length) {
+      intact.set(owner, type);
+    }
+  });
+  return intact;
+}
+
+/**
+ * The key as parts. What is left of a placeholder that a later match cut into (the `$` of
+ * `$${number}`) is text, as TypeScript reads it.
+ */
+export function replacedTemplateParts(
+  url: string,
+  matches: readonly PathParameterMatch[],
+): PathKeyPart[] {
+  const units = replacedUnits(url, matches);
+  const intact = intactPlaceholders(units, matches);
+  const parts: PathKeyPart[] = [];
+  let text = "";
+  units.forEach(({ unit, owner }, index) => {
+    const type = owner === URL_TEXT ? undefined : intact.get(owner);
+    if (type === undefined) {
+      text += unit;
+    } else if (units[index - 1]?.owner !== owner) {
+      parts.push({ kind: "text", text }, { kind: "placeholder", type });
+      text = "";
+    }
+  });
+  parts.push({ kind: "text", text });
+  return parts;
+}

package/src/application/transform/document/paths.ts

@@ -14,20 +14,29 @@ import {
   pathItemOperations,
 } from "../../../domain/openapi/path-item-object.js";
 import type { ReferenceSchema, SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { OutputFix } from "../../../domain/output-fixes.js";
 import { documentEntries } from "../document-entries.js";
 import { refType } from "../ref-type.js";
 import type { TransformContext } from "../transform-context.js";
+import { type DeclaredTypeLookup, NO_DECLARED_TYPES } from "./declared-types.js";
 import { documentMember } from "./document-member.js";
 import { pathItemType } from "./path-item.js";
-import { isCoveredPathItemRejected } from "./path-item-conflicts.js";
 import {
+  type CoverRejection,
   coveringTemplateKeys,
   type PathKey,
   type PathKeyPart,
   type PathPlaceholder,
 } from "./path-key-overlaps.js";
+import {
+  type PathParameterMatch,
+  placeholderText,
+  replacedTemplateParts,
+} from "./path-template-replace.js";
+import { assignabilityProof } from "./type-assignability.js";
 
-const PATH_PARAMETER_RE = /\{[^}]+\}/g;
+/** `[^{}]` keeps the scan linear: `[^}]` retried from every `{` of a long run of them. */
+const PATH_PARAMETER_RE = /\{[^{}]+\}/g;
 
 /** Placeholders by parameter schema type; anything else is a string placeholder. */
 const PLACEHOLDERS: ReadonlyMap<unknown, PathPlaceholder> = new Map([
@@ -37,11 +46,6 @@ const PLACEHOLDERS: ReadonlyMap<unknown, PathPlaceholder> = new Map([
 ]);
 const STRING_PLACEHOLDER: PathPlaceholder = "string";
 
-/** `${type}`: the text of a template literal type placeholder. */
-function placeholderText(type: PathPlaceholder): string {
-  return `\${${type}}`;
-}
-
 function resolvedParameter(
   parameter: ParameterOrReference,
   context: TransformContext,
@@ -80,29 +84,37 @@ function pathParameters(
   return byName;
 }
 
+/** Each `{name}` of the URL and its own placeholder, from the URL split at the matches. */
+function splitTemplateParts(url: string, matches: readonly PathParameterMatch[]): PathKeyPart[] {
+  return url.split(PATH_PARAMETER_RE).flatMap((text, index): PathKeyPart[] => {
+    const type = matches[index]?.type;
+    const textPart: PathKeyPart = { kind: "text", text };
+    return type === undefined ? [textPart] : [textPart, { kind: "placeholder", type }];
+  });
+}
+
 /**
  * `--path-params-as-types`: the URL as template parts, each `{name}` replaced by a placeholder for
- * its parameter's type. Null when the URL has no complete `{…}` placeholder.
+ * its parameter's type, the way the original replaces them unless the `path-param-type-names` fix
+ * is on (see `replacedTemplateParts`). Null when the URL has no complete `{…}` placeholder.
  */
 function pathTemplateParts(
   url: string,
   pathItem: PathItemObject,
   context: TransformContext,
 ): PathKeyPart[] | null {
-  const matches = url.match(PATH_PARAMETER_RE);
-  if (!matches) {
+  const found = url.match(PATH_PARAMETER_RE);
+  if (!found) {
     return null;
   }
   const parameters = pathParameters(pathItem, context);
-  const placeholders = matches.map((match) => {
+  const matches = found.map((match): PathParameterMatch => {
     const schema = parameters.get(match.slice(1, -1))?.schema as SchemaObject | undefined;
-    return PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER;
-  });
-  return url.split(PATH_PARAMETER_RE).flatMap((text, index): PathKeyPart[] => {
-    const type = placeholders[index];
-    const textPart: PathKeyPart = { kind: "text", text };
-    return type === undefined ? [textPart] : [textPart, { kind: "placeholder", type }];
+    return { match, type: PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER };
   });
+  return context.options.fixes.has(OutputFix.PATH_PARAM_TYPE_NAMES)
+    ? splitTemplateParts(url, matches)
+    : replacedTemplateParts(url, matches);
 }
 
 /**
@@ -120,7 +132,8 @@ function templateText(parts: readonly PathKeyPart[]): string {
 }
 
 /** A path's member, its key and its path item type for the overlap check. */
-interface PathMember {
+export interface PathMember {
+  readonly url: string;
   readonly member: IrMember;
   readonly key: PathKey;
   readonly type: IrType;
@@ -139,7 +152,7 @@ function pathItemMember(
       : null;
   if (parts === null) {
     const member = irProperty(toPropertyName(url), type, { isReadonly });
-    return { member, key: literalKey(url), type };
+    return { url, member, key: literalKey(url), type };
   }
   const member: IrMember = {
     kind: "indexSignature",
@@ -149,33 +162,75 @@ function pathItemMember(
     isReadonly,
     comments: [],
   };
-  return { member, key: { kind: "template", parts }, type };
+  return { url, member, key: { kind: "template", parts }, type };
 }
 
 function literalKey(url: string): PathKey {
   return { kind: "literal", url };
 }
 
+const PATHS_TYPE_NAME = "paths";
+
+/** The URL of `paths["/apps/{id}"]`, or null for any other type. */
+function pathsIndexOf(type: IrType): string | null {
+  if (type.kind !== "indexedAccess" || type.index.kind !== "stringLiteral") {
+    return null;
+  }
+  const { object } = type;
+  const isPaths =
+    object.kind === "reference" &&
+    object.name === PATHS_TYPE_NAME &&
+    object.typeArguments.length === 0;
+  return isPaths ? type.index.value : null;
+}
+
+/**
+ * The lookup, and `paths["/apps/{id}"]` as that path's item. The declarations cannot read it: a
+ * templated path is no property of `paths`, and TypeScript finds it through the signature.
+ */
+function withPathItems(
+  paths: readonly PathMember[],
+  lookup: DeclaredTypeLookup,
+): DeclaredTypeLookup {
+  const byUrl = new Map(paths.map((path) => [path.url, path.type]));
+  return (type) => {
+    const url = pathsIndexOf(type);
+    return (url === null ? undefined : byUrl.get(url)) ?? lookup(type);
+  };
+}
+
+/**
+ * The rejection of a covered path item: only one proven not assignable to the signature's type
+ * counts (ADR-028). A pair the proof cannot decide keeps the original output, which may well
+ * compile (`Record<string, never>` fits `{ [key: string]: unknown }`).
+ */
+function rejectionOf(paths: readonly PathMember[], lookup: DeclaredTypeLookup): CoverRejection {
+  const relate = assignabilityProof(withPathItems(paths, lookup));
+  return (coveringIndex, coveredIndex) => {
+    const coveringPath = paths[coveringIndex];
+    const coveredPath = paths[coveredIndex];
+    return (
+      coveringPath !== undefined &&
+      coveredPath !== undefined &&
+      relate(coveredPath.type, coveringPath.type) === "rejected"
+    );
+  };
+}
+
 /**
  * The members as one object type. When an index signature covers another key, TypeScript checks
  * the covered key's type against it. Where that check surely fails (TS2411, TS2413), each such
  * signature gets an object of its own in an intersection: an intersection does not check its parts
  * against each other, and every key has the type it had in the one object. Output that compiles
- * keeps the one object.
+ * keeps the one object. The lookup reads the types that path items reference; without it, a
+ * reference decides nothing.
  */
-function pathsObjectType(paths: readonly PathMember[]): IrType {
-  const covering = coveringTemplateKeys(
-    paths.map(({ key }) => key),
-    (coveringIndex, coveredIndex) => {
-      const coveringPath = paths[coveringIndex];
-      const coveredPath = paths[coveredIndex];
-      return (
-        coveringPath !== undefined &&
-        coveredPath !== undefined &&
-        isCoveredPathItemRejected(coveredPath.type, coveringPath.type)
-      );
-    },
-  );
+export function pathsObjectType(
+  paths: readonly PathMember[],
+  lookup: DeclaredTypeLookup = NO_DECLARED_TYPES,
+): IrType {
+  const keys = paths.map(({ key }) => key);
+  const covering = coveringTemplateKeys(keys, rejectionOf(paths, lookup));
   if (covering.size === 0) {
     return irObject(paths.map(({ member }) => member));
   }
@@ -186,8 +241,8 @@ function pathsObjectType(paths: readonly PathMember[]): IrType {
   return irIntersection([irObject(rest), ...own]);
 }
 
-/** The `paths` interface body (OpenAPI 3.1 §4.8.8): one member per path, by URL. */
-export function pathsType(paths: PathsObject, context: TransformContext): IrType {
+/** The members of the `paths` interface (OpenAPI 3.1 §4.8.8): one per path, by URL. */
+export function pathMembers(paths: PathsObject, context: TransformContext): PathMember[] {
   const members: PathMember[] = [];
   for (const [url, pathItem] of documentEntries(paths, context.options)) {
     if (!pathItem || typeof pathItem !== "object") {
@@ -196,7 +251,7 @@ export function pathsType(paths: PathsObject, context: TransformContext): IrType
     if ("$ref" in pathItem) {
       const options = { isReadonly: context.options.immutable };
       const member = documentMember(url, refType(pathItem.$ref), pathItem, options);
-      members.push({ member, key: literalKey(url), type: member.type });
+      members.push({ url, member, key: literalKey(url), type: member.type });
       continue;
     }
     const startedAt = context.diagnostics.now();
@@ -207,5 +262,13 @@ export function pathsType(paths: PathsObject, context: TransformContext): IrType
       context.diagnostics.debug(`Transformed path "${url}"`, context.diagnostics.now() - startedAt);
     }
   }
-  return pathsObjectType(members);
+  return members;
+}
+
+/**
+ * The `paths` interface body, with only the path items' own types for the overlap check. The
+ * document transform checks the overlaps again once the referenced types are declared.
+ */
+export function pathsType(paths: PathsObject, context: TransformContext): IrType {
+  return pathsObjectType(pathMembers(paths, context));
 }

package/src/application/transform/document/root-type-aliases.ts

@@ -2,6 +2,7 @@ import { irRaw } from "../../../domain/ir/constructors.js";
 import type { IrDeclaration, IrTypeAliasDeclaration } from "../../../domain/ir/nodes.js";
 import { escapeSingleQuotedText } from "../../../domain/ir/raw-text-escapes.js";
 import type { ComponentKind } from "../../../domain/openapi/components-object.js";
+import { globalTypeReferences } from "./global-type-references.js";
 
 /** The `--root-types` aliases: `export type Pet = components['schemas']['Pet'];`. */
 
@@ -66,37 +67,37 @@ function freeName(name: string, taken: ReadonlySet<string>): string {
 }
 
 /**
- * With the `root-type-numbering` fix (ADR-021, roadmap R13, backlog 30): the aliases that a later
- * schema of one exported name took the name from, numbered `Name_2`, `Name_3`, … in document order
- * with the next free number. The later schema keeps the name, so the fix only adds exports.
+ * Rename each root alias whose name an enum or a helper type of the footer also declares, or that
+ * shadows a TypeScript global type the output refers to (`Record` in `Record<string, never>`), to
+ * the next free `Name_2`, `Name_3`, … (the suffix `--root-types` uses for its own conflicts). The
+ * footer and the globals keep their names, because the generated types refer to them. Before, the
+ * output did not compile (enums: upstream #2099, #2341, #2206; helpers: a schema named
+ * `WithRequired`, roadmap R11; globals: TS2315). Other declarations are returned unchanged.
+ *
+ * With the `root-type-numbering` fix (ADR-021, roadmap R13, backlog 30) the body also holds the
+ * aliases a later schema of one exported name took the name from, after the other aliases and
+ * under that same name. Each gets the next free number in body order, after the alias that kept
+ * the name got its own: so the fix only adds exports, and every other alias keeps the name it has
+ * without the fix.
  */
-export function numberDisplacedAliases(
-  displaced: readonly IrTypeAliasDeclaration[],
-  kept: readonly IrTypeAliasDeclaration[],
-): IrTypeAliasDeclaration[] {
-  const taken = new Set(kept.map((alias) => alias.name));
-  return displaced.map((alias) => {
-    const name = freeName(alias.name, taken);
-    taken.add(name);
-    return { ...alias, name };
-  });
-}
-
-/**
- * Rename each root alias whose name an enum or a helper type of the footer also declares, to the
- * next free `Name_2`, `Name_3`, … (the suffix `--root-types` uses for its own conflicts). The
- * footer keeps its names, because the generated types refer to them. Before, both were declared
- * under one name, which does not compile (enums: upstream #2099, #2341, #2206; helpers: a schema
- * named `WithRequired`, roadmap R11). Other declarations are returned unchanged.
- */
-export function renameAliasesTakenByFooter(
-  body: readonly IrDeclaration[],
+export function renameTakenAliases<T extends IrDeclaration>(
+  body: readonly T[],
   footer: readonly IrDeclaration[],
-): IrDeclaration[] {
-  const footerNames = footerTypeNames(footer);
-  const taken = declaredNames([...body, ...footer]);
+  closing: readonly IrDeclaration[] = [],
+): T[] {
+  const reserved = footerTypeNames(footer);
+  for (const name of globalTypeReferences([...body, ...footer, ...closing])) {
+    reserved.add(name);
+  }
+  const taken = declaredNames([...body, ...footer, ...closing]);
+  const aliasNames = new Set<string>();
   return body.map((declaration) => {
-    if (!isRootTypeAlias(declaration) || !footerNames.has(declaration.name)) {
+    if (!isRootTypeAlias(declaration)) {
+      return declaration;
+    }
+    const isRepeated = aliasNames.has(declaration.name);
+    aliasNames.add(declaration.name);
+    if (!isRepeated && !reserved.has(declaration.name)) {
       return declaration;
     }
     const name = freeName(declaration.name, taken);