Type unification not working for nested types

**TypeScript Version:** 3.7.2, 3.6.3, 3.5.1 (but not 3.3.3) **Search Terms:** type unification **Explanation for the code:** We have a collection of different document types (think Firebase's Cloud Firestore if you're familiar with that). Each document type of which has a type associated with it which contains a few fields like the document type, the backend return type, etc. Then we have a number of functions in our store that take in one of these types and use the specific fields that they need. (Some functions will look at the `foo` field, some will not.) It's not at all uncommon for these to be passed through lots of wrapping functions until the last level pulls out the field that it needs. It is nice sometimes to be able to share code between two different (but similar) collection types. We can do if say their document type is the same (when two different endpoints return the same document). With recent versions of TypeScript we can only do that sharing if we expand the types at the place of definition. **Code** ```ts // A type that just pulls the foo field out of the type type JustFoo<T extends { foo: any }> = T['foo']; // This type is unused, but we have types like this too. type JustOtherField<T extends { otherField: any }> = T['otherField']; // We then wrap this in another type type WrappedJustFoo<T extends { foo: any }> = { wrapped: JustFoo<T> }; // We then have a lot of types that have a `foo` field and `otherField` fields. // These types will be passed into a lot of other functions, some of which // will only use the `foo` field, where as other function may use other parts. type Alpha = { foo: number; otherField: string }; type Beta = { foo: number; otherField: boolean }; // We can define variables then using `WrappedJustFoo`. const alpha: WrappedJustFoo<Alpha> = { wrapped: 3 }; const beta: WrappedJustFoo<Beta> = { wrapped: 3 }; // Sadly we can't share them even though ` WrappedJustFoo<Alpha>` and // `WrappedJustFoo<Beta>` actually resolve to the same t…