Promise<void> should not require to pass undefined

[tinganho]

One should only need to write:

function test(): Promise<void> {
    return Promise.resolve(); // error type '{}' is not assignable to type 'void'
}

Though this produces the error

type '{}' is not assignable to type 'void'.

The current solution to silence the compiler is to pass undefined:

function test(): Promise<void> {
    return Promise.resolve(undefined);
}

[jeffreymorlan]

Where are you getting your Promise type definition from?

In TypeScript's built-in Promise type definition you get from --target ES6, Promise.resolve() is already correctly typed as Promise<void>.

[tinganho]

I'm using https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/es6-promise/es6-promise.d.ts

[tinganho]

Though I think the real issue is that a type argument cannot infer the void or undefined type from an optional argument if the argument is not passed:

declare namespace Promise {
    /**
     * Make a new promise from the thenable.
     * A thenable is promise-like in as far as it has a "then" method.
     */
    function resolve<T>(value?: T | Thenable<T>): Promise<T>;
}
Promise.resolve(); // `T` should be inferred as `void` or `undefined` here not '{}'

[kitsonk]

Then clearly the title of this is inaccurate. The only thing the TypeScript team could deal with is the contextual typing, not non-core typings. So what you are really suggesting is that given this:

interface Foo<T> {
    (callback: (value: T) => void);
}

function foo<T>(value?: T): Foo<T> {
    return;
}

const result = foo();

result((value) => {
    value; // Of type {}
});

You would expect value in the callback to be inferred as void when not supplied.

[jeffreymorlan]

function resolve<T>(value?: T | Thenable<T>): Promise<T>;

This is a bad type definition. It makes the claim that for any type T, you can call the function with 0 arguments, and get a promise that resolves to T. Which is:

• generally not what one intends by calling Promise.resolve() with no arguments,
• just plain wrong if --strictNullChecks is enabled (since undefined will generally not be a member of an arbitrary type T)

It should be written with overloading instead:

function resolve<T>(value: T | Thenable<T>): Promise<T>;
function resolve(): Promise<void>;

[tinganho]

@jeffreymorlan yes you're right that's probably better.

[Arnavion]

See also #3356, #4260, DefinitelyTyped/DefinitelyTyped#6091