add an option to report an error when `Symbol.dispose`/`Symbol.asyncDispose` objects are used without the `using` keyword

[DetachHead]

🔍 Search Terms

dispose using error

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

i was surprised to learn that using disposables without the using keyword are not reported as an error:

const foo = {
  [Symbol.dispose]: () => {
    console.log("disposed"); // never called
  },
};

{
  const bar = foo;
  console.log(bar);
}

📃 Motivating Example

the documentation compares it to python with statements. but the whole point of context managers is to enforce that an object is always properly cleaned up. if you forget to use with, then the object's setup is never run so its cleanup doesn't need to run either.

since this is not the case with the using keyword, it should be a type error to use it in an unsafe way

💻 Use Cases

i have an API that i need to log out of when i'm finished using it, otherwise the session remains active

const login = () => {
    // ...
    return {
        [Symbol.asyncDispose]: () => {
            // important cleanup code that MUST be run no matter what
        }
    }
}

in python i would do this with a context manager, and i'd be confident that the cleanup code would always be executed. it's not up to the caller to remember to use the with statement. however in typescript, the caller could easily do this by mistake:

const sesion = await login()
// cleanup code never gets called

this is extremely surprising behavior coming from a language with a similar feature. is this is intentional, the docs should have a clear warning that Symbol.dispose and Symbol.asyncDispose functions have no guarantee to actually be called.

[MartinJohns]

This sounds more like a linter job. It's perfectly reasonable and valid to not use the using statement, so I would not expect an error.

[DetachHead]

i don't understand how it's valid to not use using on objects with Symbol.dispose/Symbol.asyncDispose. these methods are what an object uses to define how it should be cleaned up. but if there's no guarantee that they are actually called, what's the point? sounds highly unsafe to me

i considered raising this as an issue on oxlint, but i was so shocked by this behavior that i wanted to raise it here first, because it's something that i would expect to be enforced either at runtime or by typescript.

[MartinJohns]

Because it's valid to do manual resource management. For example think of a database connection, you don't want to establish and dispose a new one for every single request, but re-use one for multiple requests. You may want to store several connections in a pool, and only release them once the entire application terminates. In cases like this you will manually dispose of these objects.

[DetachHead]

Because it's valid to do manual resource management.

i agree there are cases where that's valid, but if an object implements Symbol.dispose or Symbol.asyncDispose, doesn't that mean the author intends for their object to be managed with the using keyword? in python, if a library author exports a context manager, it can only be used as a context manger ie. using a with statement (unless they call the dunder methods directly, but that's difficult to do by accident).

i find it strange that this feature is documented as being similar to context managers, yet it doesn't provide this very important safety guarantee that people expect from context managers -- arguably their main purpose. so if this behavior is intentional, i think it should be mentioned prominently in its documentation

[MartinJohns]

if an object implements Symbol.dispose or Symbol.asyncDispose, doesn't that mean the author intends for their object to be managed with the using keyword?

I'd say that means the author wants to provide way to explicitly release resources. Whether this is done explicitly or manually is another topic.

I've always seen the feature more in line with C#s IDisposable interface.

---

Another point you have to consider is this: How would you prevent that error when it is intentionally not used with a using statement?