Type inference is lose inside a promise

[michaeljota]

TypeScript Version: 3.1.0-dev.201xxxxx

Search Terms:

• type literal promises
• type inferred promises

Code

interface ResponseA {
    type: 'A',
    payload: any,
}

interface ResponseB {
    type: 'B',
    payload: any,
}

type ResponseKind = ResponseA | ResponseB;

// Does not work in strict mode
async function returnResponseAsync(): Promise<ResponseKind> {
    const type = 'A';
    const payload = {};

    return await {
        type, // type is 'string' type
        payload
    }
}

// Works in strict mode
function returnResponse(): ResponseKind {
    const type = 'A';
    const payload = {};

    return {
        type, // type is 'A' type
        payload
    }
}

This is a minimum reproducible code but I found this working with a complex scenario of observables and promises. However, the bug is still reproducible, because the type is being lose.

Expected behavior:

Inside the promise type type should be inferred as well.

Actual behavior:

Throws because string is not assignable to neither A or B.

Playground Link:

Link using async/await

Link with Promise.resolve

Link with Observable

Related Issues:

Workaround:

Just type the variable with a literal type.

async function returnResponseAsync(): Promise<ResponseKind> {
    const type: 'A' = 'A';
    const payload = {};

    return await {
        type, // type is 'A' type
        payload
    }
}

[ajafff]

Just remove the await from return await. It causes the returned object literal to not be contextually typed.

Also note: you shouldn't use return await unless you have one of the rare cases where it's really necessary

[michaeljota]

I mean that. As I said, I just wanted to recreate the escenario, but actually I'm not just return await. Just returing an object inside an promise, and then the type is lose.

[michaeljota]

@ajafff I update the issue with another reproducible scenario using Promise.resolve.

[RyanCavanaugh]

We should unwrap a Promise through an await expression to create a contextual type

[Curious72]

Hey , can i work on this issue ?

[DanielRosenwasser]

Absolutely! I believe what you'll want to do is start at getContextualType in checker.ts. From there, you'll want to handle the case for AwaitExpression. In that case I think you'll want to retrieve the contextual type from the AwaitExpression itself. Let's call that T. You'll want to contextually type it as T | PromiseLike<T>

[michaeljota]

Update here: I notice that in my case I was using an observable, and then returning it as a promise, but even in the Observable the literal type of type was being loss.

I create an scenario that resemble more my use case, and may help to find the bug.

with Observable

Also, this would not be directly about Promises anymore, but maybe how Typescript pass literal types as arguments to generic types.

@DanielRosenwasser @RyanCavanaugh