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

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;
+  }
+}

package/src/application/transform/footer/document-footer.ts

@@ -1,5 +1,10 @@
 import { irReference } from "../../../domain/ir/constructors.js";
-import type { IrDeclaration, IrPropertySignature, IrType } from "../../../domain/ir/nodes.js";
+import type {
+  IrDeclaration,
+  IrEnumDeclaration,
+  IrPropertySignature,
+  IrType,
+} from "../../../domain/ir/nodes.js";
 import { HELPER_TYPES, type HelperType } from "../helper-types.js";
 import type {
   EnumDeclarationRequest,
@@ -7,7 +12,13 @@ import type {
   EnumValuesRequest,
 } from "../schema/schema-context.js";
 import type { DocumentFooter } from "../transform-context.js";
-import { EnumNaming, enumDeclaration } from "./enum-naming.js";
+import {
+  type DeclaredMembers,
+  EnumNaming,
+  enumDeclaration,
+  withoutDeclaredMembers,
+} from "./enum-naming.js";
+import { FIRST_SCHEMA_NAMES, type SharedEnumNames } from "./shared-enum-names.js";
 
 /** Where footer declarations go, in order: the run's `ctx.injectFooter`, open to user code. */
 export interface FooterSink {
@@ -43,6 +54,9 @@ function metadataKey(value: string, metadata: EnumMemberMetadata | undefined): s
   return `${metadata?.name ?? value}:${metadata?.description || ""}`;
 }
 
+/** Separates a repeated `--enum-values` array name from its number, as root type aliases do. */
+const ENUM_VALUES_NUMBER_SEPARATOR = "_";
+
 /** The whole declaration: an equal key means the same enum, member for member. */
 function declarationKey(name: string, request: EnumDeclarationRequest): string {
   return JSON.stringify([name, request.values, request.metadata]);
@@ -58,18 +72,34 @@ export class RunFooter implements DocumentFooter {
   private readonly enumNamesByKey = new Map<string, string>();
   /** Declarations added already: the same one twice fails with "Duplicate identifier". */
   private readonly declaredEnums = new Set<string>();
+  /** The member names of each declared enum, by value. */
+  private readonly membersByEnum = new Map<string, Map<string | number, string>>();
+  /** The members of each declared enum name, by member name. */
+  private readonly declaredMembers = new Map<string, Map<string, string | number>>();
+  /** `--enum-values` arrays added already: their declared name by name, type and values. */
+  private readonly declaredEnumValues = new Map<string, string>();
+  /** The declared `--enum-values` array names. */
+  private readonly enumValuesNames = new Set<string>();
   private readonly sink: FooterSink;
   private readonly isDedupingEnums: boolean;
+  private readonly sharedNames: SharedEnumNames;
 
-  constructor(sink: FooterSink, isDedupingEnums: boolean) {
+  constructor(
+    sink: FooterSink,
+    isDedupingEnums: boolean,
+    sharedNames: SharedEnumNames = FIRST_SCHEMA_NAMES,
+  ) {
     this.sink = sink;
     this.isDedupingEnums = isDedupingEnums;
+    this.sharedNames = sharedNames;
   }
 
   addEnum(request: EnumDeclarationRequest): string {
     // The name is built before the cache lookup: it advances the naming state either way.
-    const name = this.naming.enumName(request.name);
+    const ownName = this.naming.enumName(request.name);
     const key = this.isDedupingEnums ? dedupeKey(request) : null;
+    // Every schema of a shared enum goes to `sharedNames`, the later ones too.
+    const name = key === null ? ownName : this.sharedNames.nameOf(key, ownName, request);
     const known = key === null ? undefined : this.enumNamesByKey.get(key);
     if (known !== undefined) {
       return known;
@@ -82,15 +112,56 @@ export class RunFooter implements DocumentFooter {
     if (declared !== null) {
       this.declaredEnums.add(declared);
     }
-    this.sink.add(enumDeclaration(name, request, this.naming));
+    const declaration = this.withoutRepeats(enumDeclaration(name, request, this.naming));
+    if (declaration !== null) {
+      this.record(declaration);
+      this.sink.add(declaration);
+    }
     if (key !== null) {
       this.enumNamesByKey.set(key, name);
     }
     return name;
   }
 
+  /** The declaration without members an earlier one of the name has; null when none is left. */
+  private withoutRepeats(declaration: IrEnumDeclaration): IrEnumDeclaration | null {
+    const earlier: DeclaredMembers | undefined = this.declaredMembers.get(declaration.name);
+    if (earlier === undefined) {
+      return declaration;
+    }
+    const merged = withoutDeclaredMembers(declaration, earlier);
+    // Two empty declarations merge into one empty enum, which compiles, so the second stays.
+    return merged.members.length === 0 && declaration.members.length > 0 ? null : merged;
+  }
+
+  /** The members of a declaration; the first member of a value names it. */
+  private record(declaration: IrEnumDeclaration): void {
+    const byName = this.declaredMembers.get(declaration.name) ?? new Map();
+    const byValue = this.membersByEnum.get(declaration.name) ?? new Map();
+    for (const member of declaration.members) {
+      byName.set(member.name, member.value);
+      if (!byValue.has(member.value)) {
+        byValue.set(member.value, member.name);
+      }
+    }
+    this.declaredMembers.set(declaration.name, byName);
+    this.membersByEnum.set(declaration.name, byValue);
+  }
+
+  enumMembers(name: string): ReadonlyMap<string | number, string> {
+    return this.membersByEnum.get(name) ?? new Map();
+  }
+
   addEnumValues(request: EnumValuesRequest): void {
-    const name = this.naming.arrayName(request.name);
+    const baseName = this.naming.arrayName(request.name);
+    // The same array twice fails with "Cannot redeclare"; a schema typed twice adds it twice.
+    const declared = JSON.stringify([baseName, request.type, request.values]);
+    if (this.declaredEnumValues.has(declared)) {
+      return;
+    }
+    const name = this.freeEnumValuesName(baseName);
+    this.declaredEnumValues.set(declared, name);
+    this.enumValuesNames.add(name);
     this.require(HELPER_TYPES.flattenedDeepRequired);
     this.require(HELPER_TYPES.readonlyArray);
     this.sink.add({
@@ -103,6 +174,20 @@ export class RunFooter implements DocumentFooter {
     });
   }
 
+  /**
+   * Another array may have the name: `Discount/type` and `discount/type`, or a property and an
+   * inline `allOf` item of one schema, typed at one location. A redeclared `const` does not
+   * compile, so a later one gets the next number (`discountTypeValues_2`). Every unnumbered name
+   * ends with `Values`, so a number never takes a name that a later array needs.
+   */
+  private freeEnumValuesName(name: string): string {
+    let candidate = name;
+    for (let count = 2; this.enumValuesNames.has(candidate); count++) {
+      candidate = `${name}${ENUM_VALUES_NUMBER_SEPARATOR}${count}`;
+    }
+    return candidate;
+  }
+
   requireWithRequired(): void {
     this.require(HELPER_TYPES.withRequired);
   }