5.0: const-like inference is not preserved unless a mapped type is used

[conorbrandon]

Bug Report

🔎 Search Terms

const type, validator type

🕗 Version & Regression Information

5.0.2

• I was unable to test this on prior versions because const type parameters are a new feature

⏯ Playground Link

Playground link with relevant code

💻 Code

type NotEmpty<T extends Record<string, any>> = keyof T extends never ? never : T;
const thing = <const O extends Record<string, any>>(o: NotEmpty<O>) => {
  return o;
};
const t = thing({foo: ''});
// is inferred as { foo: string } ❌

// BUT, when adding a mapped type to NotEmpty it works
type NotEmptyMapped<T extends Record<string, any>> = keyof T extends never ? never : {
  [K in keyof T]: T[K] // ⬅️
};
const thingMapped = <const O extends Record<string, any>>(o: NotEmptyMapped<O>) => {
  return o;
};
const tMapped = thingMapped({foo: ''});
// is inferred as { foo: "" } ✅

🙁 Actual behavior

When using a non-mapped validator type, the "valid" branch does not preserve the const-like inference unless the type is mapped over.

🙂 Expected behavior

A mapped type is not needed to preserve const-like inference.

[Andarist]

Working case:

• the apparent type of contextual type for this object is { [K in keyof O]: O[K]; }
• thus the type for this property becomes O["foo"]
• isConstTypeParameterContext is able to return true based on this information

Not working case:

• the apparent type of contextual type for this object is Record<string, any>
• thus the type for this property becomes any
• isConstTypeParameterContext return false based on that

[conorbrandon]

Interesting! Thanks for taking a look.

I did find it a bit curious that NotEmptyMapped unfortunately doesn't seem to actually error for an empty object, and instead returns Record<string, any>. Is that possibly related?

Both correctly error if the check is instead changed to {} extends T, but have the same const-like inference mismatch.

Finally if the check is T extends Record<string, never>, both don't use const-like inference and NotEmptyMapped doesn't error on an empty object, but NotEmpty does.

I think that's all the ways I can think of to check for an empty object...

[ahejlsberg]

It looks like we need to probe types a little deeper in isConstTypeVariable.