Alias type for indexing a generic object with transform breaking change in 4.2.2+

[iPherian]

Bug Report

🔎 Search Terms

index generic with alias, alias generic

🕗 Version & Regression Information

• This changed between versions 4.1.5 and 4.2.2
  • Still broken in 4.2.4 and nightly

⏯ Playground Link

Playground link

💻 Code

type ValOf<T> = T[keyof T];

const base = {
  color: "green",
} as const;

function getFromPropsNotShared<MoreProps extends {}>(
  combined: PropsNotShared<typeof base, MoreProps>,
  prop: keyof PropsNotShared<typeof base, MoreProps>
): /**
 * Produces error in typescript 4.2.x but succeeds in 4.1.5
 *
 * Succeeds if you replace the ValOf<...> type annotation with
 *
 * PropsNotShared<typeof base, MoreProps>[
 *     keyof PropsNotShared<typeof base, MoreProps>
 * ]
 *
 * (which seems like it means the same)
 */
ValOf<PropsNotShared<typeof base, MoreProps>> {
  return combined[prop];
}

type PropsNotShared<LHS extends {}, RHS extends {}> = Omit<RHS, keyof LHS> &
  Omit<LHS, keyof RHS>;

🙁 Actual behavior

Says the value returned by getFromPropsNotShared() is not assignable to the annotated return type. Works if you replace it with a similar annotation without using the ValOf generic. ValOf is awfully convenient though especially for longer type expressions.

🙂 Expected behavior

Would expect it to succeed, because the ValOf alias that fails seems like it means the same as what works ( manually write out T[keyof T] ) but cleaner to write. Also because it worked in 4.1.5.

[RyanCavanaugh]

A shorter repro would be appreciated; I'm sure this can be cut down quite a bit.

[iPherian]

@RyanCavanaugh okay shortened it

[RyanCavanaugh]

This example in 4.1 just returns any. I suspect we were incorrectly computing the type in a non-error-reporting context and the error didn't get reported:

type ValOf<T> = T[keyof T];

const base = {
  color: "green",
} as const;

function getFromPropsNotShared<MoreProps extends {}>(
  combined: PropsNotShared<typeof base, MoreProps>,
  prop: keyof PropsNotShared<typeof base, MoreProps>
): /**
 * Produces error in typescript 4.2.x but succeeds in 4.1.5
 *
 * Succeeds if you replace the ValOf<...> type annotation with
 *
 * PropsNotShared<typeof base, MoreProps>[
 *     keyof PropsNotShared<typeof base, MoreProps>
 * ]
 *
 * (which seems like it means the same)
 */
ValOf<PropsNotShared<typeof base, MoreProps>> {
  return combined[prop];
}

type PropsNotShared<LHS extends {}, RHS extends {}> = Omit<RHS, keyof LHS> &
  Omit<LHS, keyof RHS>;

const p = getFromPropsNotShared({length: 0, color: "green"}, "length");
p.asdf; // no error

[iPherian]

@RyanCavanaugh Hmm I think that's just because it wasn't inferring the generic type parameter exactly, if you change it to do so it does error there:

playground

type ValOf<T> = T[keyof T];

const base = {
  color: "green",
} as const;

function getFromPropsNotShared<MoreProps extends {}>(
  combined: PropsNotShared<typeof base, MoreProps>,
  prop: keyof PropsNotShared<typeof base, MoreProps>
): /**
 * Produces error in typescript 4.2.x but succeeds in 4.1.5
 *
 * Succeeds if you replace the ValOf<...> type annotation with
 *
 * PropsNotShared<typeof base, MoreProps>[ keyof PropsNotShared<typeof base, MoreProps> ]
 *
 * (which seems like it should mean the same)
 */
ValOf<PropsNotShared<typeof base, MoreProps>> {
  return combined[prop];
}

type PropsNotShared<LHS extends {}, RHS extends {}> = Omit<RHS, keyof LHS> &
  Omit<LHS, keyof RHS>;


const p = getFromPropsNotShared /* precise generic type param */ <{length: 0}>({length: 0, color: "green"}, "length");
p.asdf; // now error

Furthermore, given that:

type ValOf<T> = T[keyof T];

...the part that seems most strange to me is where in 4.2 (but not in 4.1), an error will be produced when getFromPropsNotShared() is annotated return:

ValOf< PropsNotShared<typeof base, MoreProps> >

but not when annotated with return (in either 4.2 or 4.1):

PropsNotShared<typeof base, MoreProps>[ keyof PropsNotShared<typeof base, MoreProps> ]

Which is weird, right? Because the only difference is Replacing T in ValOf with the actual expression of the parameter. In my mind at least it seems like they should do the same.

Between both 4.1 and 4.2 there are correctly errors (i.e. not any) in your example if explicit type params are given:

const p = getFromPropsNotShared /* precise generic type param */ <{length: 0}>({length: 0, color: "green"}, "length");
p.asdf; // now error

[RyanCavanaugh]

@iPherian can you reduce this to a minimal repro of what you think the bug is and log a new issue? Thanks!

[iPherian]

@RyanCavanaugh okay opened a new issue #44095