AsyncDisposable should allow non-Promise returning implementations

[mfulton26]

⚙ Compilation target

esnext

⚙ Library

lib.esnext.disposable.d.ts

Missing / Incorrect Definition

AyncDisposable doe not allow for a non-Promise returning implementation.

Current:

interface AsyncDisposable {
    [Symbol.asyncDispose](): PromiseLike<void>;
}

Suggested:

interface AsyncDisposable {
    [Symbol.asyncDispose](): void | PromiseLike<void>;
}

Sample Code

// valid:
await using disposableAsync = { async [Symbol.asyncDispose]() {} };

// valid but flagged by TS as invalid:
await using disposable = { [Symbol.asyncDispose]() {} };
// The initializer of an 'await using' declaration must be either an object with a '[Symbol.asyncDispose]()' or '[Symbol.dispose]()' method, or be 'null' or 'undefined'.
//   Type '{ [Symbol.asyncDispose](): void; }' is not assignable to type 'AsyncDisposable'.
//     The types returned by '[Symbol.asyncDispose]()' are incompatible between these types.
//       Type 'void' is not assignable to type 'PromiseLike<void>'.

Documentation Link

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncDispose#:~:text=This%20method%20can%20return%20a%20promise%2C%20which%20will%20be%20awaited%20before%20continuing. ("can", not "must")

[MartinJohns]

This is intentional. See #54505:

Please note that while a [Symbol.asyncDispose]() method doesn't necessarily need to return a Promise in JavaScript, for TypeScript code we've opted to make it an error if the return type is not Promise-like to better surface potential typos or missing return statements.

[mfulton26]

This is intentional. See #54505:

Please note that while a [Symbol.asyncDispose]() method doesn't necessarily need to return a Promise in JavaScript, for TypeScript code we've opted to make it an error if the return type is not Promise-like to better surface potential typos or missing return statements.

I was not aware this was intentional. Thank you for sharing that. JavaScript is often very forgiving I find TypeScript to be so also in some places while not in others and I haven't figured out when to expect it to be forgiving and when to expect it to not be so. This may be one of those times. I see tradeoffs either way. Is there a way to disable (// @ts-expect-error does not appear to work)?

[MartinJohns]

(// @ts-expect-error does not appear to work)

It does work just fine.

[RyanCavanaugh]

What are real disposable objects out there that only sometimes return a Promise?

[RyanCavanaugh]

Motivating example fwiw:

class ForgotToDispose implements AsyncDisposable {
    async myDisposer() {
        // Dispose
    }

    [Symbol.asyncDispose]() {
        // Forgot to call or await
        return this.myDisposer;
    }
}