Change in inferred type in 3.6 for function call using generic union instantiated at string literal

[lukehoban]

TypeScript Version: 3.6.2

Search Terms: regression, string literal, union, 3.6, inference, generic.

Code

type NetworkProtocol = "TCP";
type Input<T> = Promise<T> | T;
function ifUndefined<T>(input:Input<T> | undefined, value: Input<T>): Promise<T> {
    throw new Error();   
}
const y = ifUndefined(new Promise<NetworkProtocol>(() => {}), "TCP") 
const z: Promise<NetworkProtocol> = y;

Expected behavior:
No error (3.5 and earlier).

Actual behavior:
A type error (3.6.2):

Type 'Promise<string>' is not assignable to type 'Promise<NetworkProtocol>'.
  Type 'string' is not assignable to type 'NetworkProtocol'.

Playground Link: Playground. The TypeScript Playground doesn't appear to yet use 3.6.2 though so this doesn't repro in the playground.

Note that this example does work as expected - and looks morally "the same":

type NetworkProtocol = "TCP";
function ifUndefined<T>(input:Promise<T> | undefined, value: T): Promise<T> {
    throw new Error();   
}
const y = ifUndefined(new Promise<NetworkProtocol>(() => {}), "TCP") 
const z: Promise<NetworkProtocol> = y;

[schlundus]

Yes, i can confirm there seems to be an issue in 3.6.2, simpler example here:

It shows the wrong type inference

Playground (3.5.1) ... looks good

[fatcerberus]

I think this probably has to do with #33131 (comment) and is therefore a bug.

The example above was a generic function with its argument typed as string | T. The call site passes in a string, it matches the string part of the union. The compiler then doesn't bother to infer T. T therefore defaults to unknown (its constraint), bar's type is instantiated to string | unknown which collapses to simply unknown by subtype reduction.

[sandersn]

Yeah, I think it's to do with the changes to naked type parameter inference. @weswigham mind taking a look to confirm before I close this as a duplicate?

[sandersn]

@lukehoban Here's a link to a build you can try to see if it fixes the problem:

https://typescript.visualstudio.com/cf7ac146-d525-443c-b23c-0d58337efebc/_apis/build/builds/42167/artifacts?artifactName=tgz&fileId=84FA9BD7390E9AE04ED6006D9E265FBCF309C643377CBBC8CB1CE445229AAB2B02&fileName=/typescript-3.7.0-insiders.20190830.tgz

Some install instructions

[ahejlsberg]

(Hi Luke! 👋)

This is an effect of #32460, and I would argue one that is intended. In the call to ifUndefined we make two inferences for T, in the first argument from Promise<NetworkProtocol> to T | Promise<T> | undefined, and in the second argument from string to T | Promise<T>. Previously we'd give lower priority to the second inference because we infer to a naked type parameter in a union, and thus we'd end up inferring NetworkProtocol for T. Now we give equal priority to the inferences (which really is the correct behavior) and we therefore end up with string.

The string literal "TCP" is widened to string in the second argument because there is nothing to indicate that it shouldn't be. It works as intended if you add a const assertion:

const y = ifUndefined(new Promise<NetworkProtocol>(() => {}), "TCP" as const);

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.