Lazier typeof operator to enable limited "circular" references

Search Terms

• typeof referenced indirectly
• lazy typeof
• lazier typeof
• circular typeof

#25214 is very closely related but not exactly the same.

Suggestion

If typeof operators were resolved slightly lazier, certain "circular" type definitions could be typed more automatically. Then the following could be made to compile:

type Place = keyof typeof building;
function room(doors: Place[]): {doors: Place[]} {
  return { doors };
}
const building = {
  foyer: room(["dining", "kitchen"]),
  dining: room(["foyer", "bedroom"]),
  kitchen: room(["foyer", "bedroom"]),
  bedroom: room(["dining", "kitchen"]),
};

Currently, you get

Type alias 'Place' circularly references itself.ts(2456)

However, Place doesn't actually reference itself since you don't need to know what Place is to evaluate keyof typeof building, only to evaluate typeof building in its entirety. If typeof building were resolved lazily (as it was needed) then its keys could be found without needing Place, breaking the reference cycle.

Specifically, we can resolve type Place = "foyer" | "dining" | "kitchen" | "bedroom" without needing to know what building's properties are specifically typed. Then, we can proceed with any inferences as needed for the building, getting the complete inferred type

type Place = "foyer" | "dining" | "kitchen" | "bedroom";
const building: Record<Place, {doors: Place[]}>; // or something equivalent, e.g. an actual object

Downsides/Tradeoffs

• More complexity in type-checker
• Relatively fringe use-case
• Possibly brittle (small changes to variable definition or type definition may cause circularity to reappear, limiting possible use)

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start by reproducing the TypeScript example in the issue and compare it with the related discussion in #25214. Investigate the type-checker behavior for keyof typeof and circular type aliases; done means the example compiles while preserving correct inference and avoiding regressions.