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

package/src/application/transform/document/template-key-match.ts

@@ -0,0 +1,183 @@
+/**
+ * Whether a key type is assignable to a template literal key type, decided the way TypeScript's
+ * checker decides it (`inferFromLiteralPartsToTemplateLiteral` and
+ * `isValidTypeForTemplateLiteralPlaceholder` in TypeScript 5 and 6). An index signature checks
+ * exactly the keys that are assignable to its key type, so the overlap check must match the
+ * checker, not the strings a template stands for: the checker matches each text of the target at
+ * its first occurrence, so it misses some keys a regular expression would match, and a key it
+ * misses is never checked against the signature.
+ */
+
+/** A placeholder type of a template, after `${boolean}` became the texts `true` and `false`. */
+export type TemplatePlaceholder = "string" | "number";
+
+/**
+ * A key type as TypeScript stores a template literal: texts around placeholders, one more text
+ * than placeholders. A string literal is one text and no placeholder.
+ */
+export interface TemplateShape {
+  readonly texts: readonly string[];
+  readonly types: readonly TemplatePlaceholder[];
+}
+
+/** The text at an index of the shape; every caller passes one of `0 .. types.length`. */
+function textAt(shape: TemplateShape, index: number): string {
+  return shape.texts[index] as string;
+}
+
+/** The type the checker infers for one target placeholder: a text, or a slice of the source. */
+type InferredMatch =
+  | { readonly kind: "text"; readonly text: string }
+  | { readonly kind: "template"; readonly shape: TemplateShape };
+
+/** TypeScript's `isValidNumberString(text, false)`: a text that converts to a finite number. */
+export function isNumberText(text: string): boolean {
+  return text !== "" && Number.isFinite(Number(text));
+}
+
+/** Whether the inferred type fits a placeholder: any string for `string`, a number for `number`. */
+function isValidMatch(match: InferredMatch, placeholder: TemplatePlaceholder): boolean {
+  if (placeholder === "string") {
+    return true;
+  }
+  if (match.kind === "text") {
+    return isNumberText(match.text);
+  }
+  const { texts, types } = match.shape;
+  return texts.length === 2 && texts[0] === "" && texts[1] === "" && types[0] === "number";
+}
+
+/** The state of the scan through the source: the current text and the position in it. */
+interface Cursor {
+  readonly segment: number;
+  readonly position: number;
+}
+
+/** The scan of `inferFromLiteralPartsToTemplateLiteral`, over one source and one target. */
+class LiteralPartsScan {
+  private readonly matches: InferredMatch[] = [];
+  private cursor: Cursor;
+  private readonly source: TemplateShape;
+  private readonly lastSourceIndex: number;
+  private readonly remainingEndText: string;
+
+  constructor(source: TemplateShape, startPosition: number, endTextLength: number) {
+    this.source = source;
+    this.lastSourceIndex = source.texts.length - 1;
+    const endText = textAt(source, this.lastSourceIndex);
+    this.remainingEndText = endText.slice(0, endText.length - endTextLength);
+    this.cursor = { segment: 0, position: startPosition };
+  }
+
+  /** The matches for the target's texts between its first and last; null when one is missing. */
+  run(delimiters: readonly string[]): readonly InferredMatch[] | null {
+    for (const delimiter of delimiters) {
+      if (!this.matchDelimiter(delimiter)) {
+        return null;
+      }
+    }
+    this.addMatch(this.lastSourceIndex, this.sourceText(this.lastSourceIndex).length);
+    return this.matches;
+  }
+
+  private matchDelimiter(delimiter: string): boolean {
+    const { segment, position } = this.cursor;
+    if (delimiter.length > 0) {
+      const found = this.find(delimiter);
+      if (found === null) {
+        return false;
+      }
+      this.addMatch(found.segment, found.position);
+      this.cursor = { ...this.cursor, position: this.cursor.position + delimiter.length };
+      return true;
+    }
+    if (position < this.sourceText(segment).length) {
+      this.addMatch(segment, position + 1);
+      return true;
+    }
+    if (segment < this.lastSourceIndex) {
+      this.addMatch(segment + 1, 0);
+      return true;
+    }
+    return false;
+  }
+
+  /** The first occurrence of the delimiter at or after the cursor, in this or a later text. */
+  private find(delimiter: string): Cursor | null {
+    let { segment, position } = this.cursor;
+    while (segment < this.source.texts.length) {
+      const index = this.sourceText(segment).indexOf(delimiter, position);
+      if (index >= 0) {
+        return { segment, position: index };
+      }
+      segment += 1;
+      position = 0;
+    }
+    return null;
+  }
+
+  private sourceText(index: number): string {
+    return index < this.lastSourceIndex ? textAt(this.source, index) : this.remainingEndText;
+  }
+
+  private addMatch(segment: number, position: number): void {
+    const start = this.cursor;
+    if (segment === start.segment) {
+      const text = this.sourceText(segment).slice(start.position, position);
+      this.matches.push({ kind: "text", text });
+    } else {
+      const texts = [
+        textAt(this.source, start.segment).slice(start.position),
+        ...this.source.texts.slice(start.segment + 1, segment),
+        this.sourceText(segment).slice(0, position),
+      ];
+      const types = this.source.types.slice(start.segment, segment);
+      this.matches.push({ kind: "template", shape: { texts, types } });
+    }
+    this.cursor = { segment, position };
+  }
+}
+
+/** The checker's inferences for the target's placeholders; null when the texts do not fit. */
+function inferMatches(
+  source: TemplateShape,
+  target: TemplateShape,
+): readonly InferredMatch[] | null {
+  const sourceStart = textAt(source, 0);
+  const sourceEnd = textAt(source, source.texts.length - 1);
+  const targetStart = textAt(target, 0);
+  const targetEnd = textAt(target, target.texts.length - 1);
+  const isTooShort =
+    source.texts.length === 1 && sourceStart.length < targetStart.length + targetEnd.length;
+  if (isTooShort || !sourceStart.startsWith(targetStart) || !sourceEnd.endsWith(targetEnd)) {
+    return null;
+  }
+  const scan = new LiteralPartsScan(source, targetStart.length, targetEnd.length);
+  return scan.run(target.texts.slice(1, -1));
+}
+
+function haveSameTexts(source: TemplateShape, target: TemplateShape): boolean {
+  return (
+    source.texts.length === target.texts.length &&
+    source.texts.every((text, index) => text === target.texts[index])
+  );
+}
+
+/**
+ * Whether the source key type is assignable to the target template. Templates with the same texts
+ * compare placeholder by placeholder (`inferTypesFromTemplateLiteralType`).
+ */
+export function isAssignableToTemplate(source: TemplateShape, target: TemplateShape): boolean {
+  if (source.types.length > 0 && haveSameTexts(source, target)) {
+    return source.types.every((type, index) => {
+      const placeholder = target.types[index];
+      return placeholder === "string" || type === placeholder;
+    });
+  }
+  const matches = inferMatches(source, target);
+  const isEveryMatchValid = matches?.every((match, index) => {
+    const placeholder = target.types[index];
+    return placeholder !== undefined && isValidMatch(match, placeholder);
+  });
+  return isEveryMatchValid === true;
+}

package/src/application/transform/document/type-assignability.ts

@@ -0,0 +1,268 @@
+import { irBoolean } from "../../../domain/ir/constructors.js";
+import type {
+  IrIndexSignature,
+  IrObjectType,
+  IrPropertySignature,
+  IrType,
+  IrUnionType,
+} from "../../../domain/ir/nodes.js";
+import {
+  type Assignability,
+  crossCategoryRelation,
+  everyOf,
+  primitiveRelation,
+  someOf,
+} from "./assignability.js";
+import type { DeclaredTypeLookup } from "./declared-types.js";
+import { type IrListType, relateLists } from "./list-assignability.js";
+import { createTypeKey } from "./type-key.js";
+import {
+  indexSignaturesOf,
+  nameOf,
+  propertiesOf,
+  readType,
+  TypeResolution,
+} from "./type-resolution.js";
+
+/**
+ * Whether TypeScript accepts one type where another is expected (`strict`, without
+ * `exactOptionalPropertyTypes`), for the `--path-params-as-types` overlap check. It follows the
+ * checker's rules for the types the generator writes: unions, intersections, objects with optional
+ * properties and index signatures, weak types, arrays, tuples, literals and keywords, and the
+ * references to declarations of the document. A pair it does not model (a utility type, raw text)
+ * is undecided unless both are the same type, and an undecided pair keeps the original output.
+ */
+
+/** Results by source type, then by target type. */
+type PairResults = Map<IrType, Map<IrType, Assignability>>;
+
+function resultOf(results: PairResults, source: IrType, target: IrType): Assignability | undefined {
+  return results.get(source)?.get(target);
+}
+
+function setResult(
+  results: PairResults,
+  pair: { readonly source: IrType; readonly target: IrType },
+  value: Assignability,
+): void {
+  const byTarget = results.get(pair.source) ?? new Map<IrType, Assignability>();
+  byTarget.set(pair.target, value);
+  results.set(pair.source, byTarget);
+}
+
+/** A weak type has only optional properties; TypeScript rejects a source sharing none (TS2559). */
+function isWeakTypeRejected(source: IrObjectType, target: IrObjectType): boolean {
+  const targetProperties = [...propertiesOf(target).values()];
+  const isWeak =
+    targetProperties.length > 0 &&
+    indexSignaturesOf(target).length === 0 &&
+    targetProperties.every((property) => property.isOptional);
+  const sourceNames = [...propertiesOf(source).keys()];
+  return (
+    isWeak &&
+    sourceNames.length > 0 &&
+    !sourceNames.some((name) => targetProperties.some((property) => nameOf(property) === name))
+  );
+}
+
+function isStringIndex(signature: IrIndexSignature): boolean {
+  return signature.parameterType.kind === "keyword" && signature.parameterType.keyword === "string";
+}
+
+/** `boolean` as the checker stores it: the union `true | false`. */
+const BOOLEAN_MEMBERS: readonly IrType[] = [irBoolean(true), irBoolean(false)];
+
+/**
+ * The members a source is compared by, one by one, or null for a source compared as a whole.
+ * `boolean` counts as `true | false` against a union, which it fits though it fits neither member
+ * alone; `string` and `number` are no finite unions, so no literal union holds all their values.
+ */
+function sourceUnionMembers(source: IrType, target: IrType): readonly IrType[] | null {
+  if (source.kind === "union") {
+    return source.types;
+  }
+  const isBoolean = source.kind === "keyword" && source.keyword === "boolean";
+  return isBoolean && target.kind === "union" ? BOOLEAN_MEMBERS : null;
+}
+
+/** The memoized check over the declarations of one generated file. */
+class AssignabilityCheck {
+  private readonly inProgress: PairResults = new Map();
+  private readonly results: PairResults = new Map();
+  private readonly typeKeyOf = createTypeKey();
+  private readonly resolution: TypeResolution;
+  /** How often a pair being compared was assumed related, and how deep the comparison is. */
+  private assumptions = 0;
+  private depth = 0;
+
+  constructor(lookup: DeclaredTypeLookup) {
+    this.resolution = new TypeResolution(lookup);
+  }
+
+  relate(source: IrType, target: IrType): Assignability {
+    const pair = {
+      source: this.resolution.resolved(source),
+      target: this.resolution.resolved(target),
+    };
+    if (
+      pair.source === pair.target ||
+      this.typeKeyOf(pair.source) === this.typeKeyOf(pair.target)
+    ) {
+      return "assignable";
+    }
+    const known = resultOf(this.results, pair.source, pair.target);
+    if (known !== undefined) {
+      return known;
+    }
+    // A pair being compared is assumed related, as the checker does for recursive types.
+    if (resultOf(this.inProgress, pair.source, pair.target) !== undefined) {
+      this.assumptions += 1;
+      return "assignable";
+    }
+    const assumedBefore = this.assumptions;
+    setResult(this.inProgress, pair, "assignable");
+    this.depth += 1;
+    const result = this.compare(pair.source, pair.target);
+    this.depth -= 1;
+    this.inProgress.get(pair.source)?.delete(pair.target);
+    // "Assignable" that rests on an assumption about an outer pair holds only if that pair does,
+    // so it is kept only once no outer pair is open. The assumption can only make a pair more
+    // related, so a rejection or an undecided pair reached under it is safe to keep.
+    if (result !== "assignable" || this.assumptions === assumedBefore || this.depth === 0) {
+      setResult(this.results, pair, result);
+    }
+    return result;
+  }
+
+  private compare(source: IrType, target: IrType): Assignability {
+    if (target.kind === "keyword" && target.keyword === "unknown") {
+      return "assignable";
+    }
+    if (source.kind === "keyword" && source.keyword === "never") {
+      return "assignable";
+    }
+    const sourceMembers = sourceUnionMembers(source, target);
+    if (sourceMembers !== null) {
+      return everyOf(sourceMembers, (member) => this.relate(member, target));
+    }
+    if (target.kind === "intersection") {
+      return everyOf(target.types, (member) => this.relateToIntersectionPart(source, member));
+    }
+    if (target.kind === "union") {
+      return this.relateToUnion(source, target);
+    }
+    if (source.kind === "intersection") {
+      // A part that fits is enough; the parts as one type are not modelled (see `merged`).
+      const fits = source.types.some((part) => this.relate(part, target) === "assignable");
+      return fits ? "assignable" : "undecided";
+    }
+    return this.compareSingle(source, target);
+  }
+
+  /**
+   * A part of an intersection the check cannot merge into one object. The checker skips the weak
+   * type check for such a part, so a rejection that may rest on it decides nothing.
+   */
+  private relateToIntersectionPart(source: IrType, part: IrType): Assignability {
+    const result = this.relate(source, part);
+    const from = this.resolution.resolved(source);
+    const to = this.resolution.resolved(part);
+    const isWeakRejection =
+      from.kind === "object" && to.kind === "object" && isWeakTypeRejected(from, to);
+    return result === "rejected" && isWeakRejection ? "undecided" : result;
+  }
+
+  /**
+   * An object may fit a union of objects that none of its members accepts alone, through a
+   * discriminant property (`{ k: "a" | "b" }` fits `{ k: "a" } | { k: "b" }`); not modelled.
+   */
+  private relateToUnion(source: IrType, target: IrUnionType): Assignability {
+    const result = someOf(target.types, (member) => this.relate(source, member));
+    const objectMembers = target.types.filter(
+      (member) => this.resolution.resolved(member).kind === "object",
+    );
+    const mayBeDiscriminated = source.kind === "object" && objectMembers.length > 1;
+    return result === "rejected" && mayBeDiscriminated ? "undecided" : result;
+  }
+
+  private compareSingle(source: IrType, target: IrType): Assignability {
+    const crossCategory = crossCategoryRelation(source, target);
+    if (crossCategory !== null) {
+      return crossCategory;
+    }
+    switch (source.kind) {
+      case "array":
+      case "tuple":
+      case "readonly":
+        return relateLists(source, target as IrListType, (from, to) => this.relate(from, to));
+      case "object":
+        return this.relateObjects(source, target as IrObjectType);
+      default:
+        return primitiveRelation(source, target);
+    }
+  }
+
+  private relateObjects(source: IrObjectType, target: IrObjectType): Assignability {
+    if (isWeakTypeRejected(source, target)) {
+      return "rejected";
+    }
+    const sourceProperties = propertiesOf(source);
+    const indexes = everyOf(indexSignaturesOf(target), (signature) =>
+      this.relateToIndex(source, signature),
+    );
+    if (indexes === "rejected") {
+      return indexes;
+    }
+    const properties = everyOf([...propertiesOf(target).values()], (property) =>
+      this.relateProperty(sourceProperties.get(nameOf(property)), property),
+    );
+    return everyOf([indexes, properties], (result) => result);
+  }
+
+  /**
+   * A string index signature of the target. A string index of the source is compared with it;
+   * without one, every property and index signature of the source is. An optional property is
+   * compared without the `undefined` its optionality adds, as the checker does.
+   */
+  private relateToIndex(source: IrObjectType, signature: IrIndexSignature): Assignability {
+    if (!isStringIndex(signature)) {
+      return "undecided";
+    }
+    const indexes = indexSignaturesOf(source);
+    const own = indexes.find(isStringIndex);
+    if (own !== undefined) {
+      return this.relate(own.type, signature.type);
+    }
+    const types = [
+      ...[...propertiesOf(source).values()].map((property) => property.type),
+      ...indexes.map((index) => index.type),
+    ];
+    return everyOf(types, (type) => this.relate(type, signature.type));
+  }
+
+  /**
+   * A property of the target. A missing optional one is not checked, not even against a string
+   * index of the source; a missing or optional source property fails a required one (TS2741).
+   */
+  private relateProperty(
+    source: IrPropertySignature | undefined,
+    target: IrPropertySignature,
+  ): Assignability {
+    if (source === undefined) {
+      return target.isOptional ? "assignable" : "rejected";
+    }
+    if (source.isOptional && !target.isOptional) {
+      return "rejected";
+    }
+    return this.relate(readType(source), readType(target));
+  }
+}
+
+/** What the check proves about a source type where a target is expected. */
+export type AssignabilityProof = (source: IrType, target: IrType) => Assignability;
+
+/** One memoized check, for all the comparisons of a `paths` type. */
+export function assignabilityProof(lookup: DeclaredTypeLookup): AssignabilityProof {
+  const check = new AssignabilityCheck(lookup);
+  return (source, target) => check.relate(source, target);
+}

package/src/application/transform/document/type-key.ts

@@ -0,0 +1,80 @@
+import { assertNever } from "../../../domain/assert-never.js";
+import type { IrMember, IrPropertyName, IrTupleElement, IrType } from "../../../domain/ir/nodes.js";
+
+/**
+ * A text that is the same for two types exactly when they are written the same, comments left
+ * out: the overlap check accepts a type it does not model when it is the same as the other.
+ */
+
+function nameKey(name: IrPropertyName): string {
+  return JSON.stringify(name.kind === "string" ? name.value : name.text);
+}
+
+function memberKey(member: IrMember, typeKeyOf: TypeKey): string {
+  if (member.kind === "indexSignature") {
+    const readonly = member.isReadonly ? "readonly " : "";
+    return `${readonly}[${typeKeyOf(member.parameterType)}]:${typeKeyOf(member.type)}`;
+  }
+  const readonly = member.isReadonly ? "readonly " : "";
+  const optional = member.isOptional ? "?" : "";
+  return `${readonly}${nameKey(member.name)}${optional}:${typeKeyOf(member.type)}`;
+}
+
+function listKey(types: readonly IrType[], typeKeyOf: TypeKey): string {
+  return types.map(typeKeyOf).join(",");
+}
+
+function elementKey(element: IrTupleElement, typeKeyOf: TypeKey): string {
+  const prefix = element.isRest ? "..." : "";
+  return `${prefix}${typeKeyOf(element.type)}${element.isOptional ? "?" : ""}`;
+}
+
+function computeKey(type: IrType, typeKeyOf: TypeKey): string {
+  switch (type.kind) {
+    case "keyword":
+      return type.keyword;
+    case "stringLiteral":
+      return JSON.stringify(type.value);
+    case "numberLiteral":
+    case "booleanLiteral":
+      return String(type.value);
+    case "reference":
+      return `${type.name}<${listKey(type.typeArguments, typeKeyOf)}>`;
+    case "array":
+      return `(${typeKeyOf(type.element)})[]`;
+    case "tuple":
+      return `[${type.elements.map((element) => elementKey(element, typeKeyOf)).join(",")}]`;
+    case "union":
+      return `union(${listKey(type.types, typeKeyOf)})`;
+    case "intersection":
+      return `intersection(${listKey(type.types, typeKeyOf)})`;
+    case "object":
+      return `{${type.members.map((member) => memberKey(member, typeKeyOf)).join(";")}}`;
+    case "indexedAccess":
+      return `${typeKeyOf(type.object)}[${typeKeyOf(type.index)}]`;
+    case "readonly":
+      return `readonly(${typeKeyOf(type.type)})`;
+    case "raw":
+      return `raw(${type.text})`;
+    default:
+      return assertNever(type);
+  }
+}
+
+/** The key of a type. */
+export type TypeKey = (type: IrType) => string;
+
+/** A key function that computes each node's key once; one per comparison, not shared. */
+export function createTypeKey(): TypeKey {
+  const keys = new WeakMap<IrType, string>();
+  const typeKeyOf: TypeKey = (type) => {
+    const known = keys.get(type);
+    if (known !== undefined) {
+      return known;
+    }
+    const key = computeKey(type, typeKeyOf);
+    keys.set(type, key);
+    return key;
+  };
+  return typeKeyOf;
+}

package/src/application/transform/document/type-resolution.ts

@@ -0,0 +1,163 @@
+import type {
+  IrIndexSignature,
+  IrMember,
+  IrObjectType,
+  IrPropertySignature,
+  IrType,
+} from "../../../domain/ir/nodes.js";
+import type { DeclaredTypeLookup } from "./declared-types.js";
+
+/**
+ * The types the `--path-params-as-types` overlap check compares, as TypeScript sees them:
+ * references followed to the declarations of the document, `T["key"]` and `T[number]` read from
+ * `T`, and an intersection of object types merged into one object.
+ */
+
+const UNDEFINED: IrType = { kind: "keyword", keyword: "undefined" };
+
+export function nameOf(member: IrPropertySignature): string {
+  return member.name.kind === "string" ? member.name.value : member.name.text;
+}
+
+export function propertiesOf(type: IrObjectType): Map<string, IrPropertySignature> {
+  const properties = type.members.filter(
+    (member: IrMember): member is IrPropertySignature => member.kind === "property",
+  );
+  return new Map(properties.map((property) => [nameOf(property), property]));
+}
+
+export function indexSignaturesOf(type: IrObjectType): IrIndexSignature[] {
+  return type.members.filter(
+    (member: IrMember): member is IrIndexSignature => member.kind === "indexSignature",
+  );
+}
+
+/** The type read from a property: an optional one may be `undefined`. */
+export function readType(property: IrPropertySignature): IrType {
+  return property.isOptional ? { kind: "union", types: [property.type, UNDEFINED] } : property.type;
+}
+
+/**
+ * `T[number]` for an array `T`, as the generator writes for an item of an array response: the
+ * element type, readonly or not. A tuple's is the union of its elements, which is not modelled.
+ */
+function arrayElement(type: IrType): IrType | null {
+  const list = type.kind === "readonly" ? type.type : type;
+  return list.kind === "array" ? list.element : null;
+}
+
+/** One property for two of the same name in an intersection. */
+function mergedProperty(
+  first: IrPropertySignature,
+  second: IrPropertySignature,
+): IrPropertySignature {
+  return {
+    ...first,
+    type: { kind: "intersection", types: [first.type, second.type] },
+    isOptional: first.isOptional && second.isOptional,
+    isReadonly: first.isReadonly || second.isReadonly,
+  };
+}
+
+/** Resolves types once each, for one comparison. */
+export class TypeResolution {
+  private readonly lookup: DeclaredTypeLookup;
+  private readonly resolvedTypes = new Map<IrType, IrType>();
+
+  constructor(lookup: DeclaredTypeLookup) {
+    this.lookup = lookup;
+  }
+
+  /** The type a reference names, followed through references to references; computed once. */
+  resolved(type: IrType): IrType {
+    const known = this.resolvedTypes.get(type);
+    if (known !== undefined) {
+      return known;
+    }
+    // A type that reaches itself while it is resolved stays as it is written there.
+    this.resolvedTypes.set(type, type);
+    const seen = new Set<IrType>();
+    let current = type;
+    while (!seen.has(current)) {
+      seen.add(current);
+      const named = this.lookup(current) ?? this.indexedProperty(current);
+      if (named === null) {
+        break;
+      }
+      current = named;
+    }
+    const result = current.kind === "intersection" ? (this.merged(current) ?? current) : current;
+    this.resolvedTypes.set(type, result);
+    return result;
+  }
+
+  /**
+   * `T["key"]` read from the object type `T` resolves to, which the lookup does not do for an
+   * object it reached through another lookup (`paths["/a/{id}"]["get"]`). An optional property
+   * reads as `T | undefined`; `T[number]` is the element of the array `T`.
+   */
+  private indexedProperty(type: IrType): IrType | null {
+    if (type.kind !== "indexedAccess") {
+      return null;
+    }
+    const { index } = type;
+    if (index.kind === "keyword" && index.keyword === "number") {
+      return arrayElement(this.resolved(type.object));
+    }
+    const object = this.resolved(type.object);
+    if (index.kind !== "stringLiteral" || object.kind !== "object") {
+      return null;
+    }
+    const property = propertiesOf(object).get(index.value);
+    return property === undefined ? null : readType(property);
+  }
+
+  /**
+   * An intersection of object types as the one object TypeScript makes of it: a property in
+   * several parts has the intersection of their types, and is optional only when it is in each.
+   * Null when a part is no object type.
+   */
+  private merged(type: IrType): IrObjectType | null {
+    const parts = this.objectParts(type);
+    if (parts === null) {
+      return null;
+    }
+    const properties = new Map<string, IrPropertySignature>();
+    const indexes: IrIndexSignature[] = [];
+    for (const member of parts.flatMap((part) => part.members)) {
+      if (member.kind === "indexSignature") {
+        indexes.push(member);
+        continue;
+      }
+      const name = nameOf(member);
+      const other = properties.get(name);
+      properties.set(name, other === undefined ? member : mergedProperty(other, member));
+    }
+    return { kind: "object", members: [...properties.values(), ...indexes] };
+  }
+
+  /**
+   * The object types an intersection is made of, nested ones flattened; null for any other, and
+   * for an intersection that contains itself, which TypeScript does not merge either.
+   */
+  private objectParts(
+    type: IrType,
+    visiting: ReadonlySet<IrType> = new Set(),
+  ): IrObjectType[] | null {
+    if (type.kind === "object") {
+      return [type];
+    }
+    if (type.kind !== "intersection" || visiting.has(type)) {
+      return null;
+    }
+    const parts: IrObjectType[] = [];
+    for (const part of type.types) {
+      const objects = this.objectParts(this.resolved(part), new Set([...visiting, type]));
+      if (objects === null) {
+        return null;
+      }
+      parts.push(...objects);
+    }
+    return parts;
+  }
+}