Rule proposal: explicit-resource-management-literal-pair-using-dispose

[loynoir]

Before You File a Proposal Please Confirm You Have Done The Following...

• I have searched for related issues and found none that match my proposal.
• I have searched the current rule list and found no rules that match my proposal.
• I have read the FAQ and my problem is not listed.

My proposal is suitable for this project

• My proposal specifically checks TypeScript syntax, or it proposes a check that requires type information to be accurate.
• My proposal is not a "formatting rule"; meaning it does not just enforce how code is formatted (whitespace, brace placement, etc).
• I believe my proposal would be useful to the broader TypeScript community (meaning it is not a niche proposal).

Description

• When RHS literal object have literal property Symbol.dispose, LHS should have using

• When LHS have using, RHS should be literal object with literal property Symbol.dispose

Fail Cases

const x = {
  [Symbol.dispose]() {
    console.log(2, { x });
  },
};

console.log(1, { x });

using x = {
  dispose() {
    console.log(2, { x });
  },
};

console.log(1, { x });

const fn = () => {
  return {
    [Symbol.dispose]() {
      console.log(2, { x });
    },
  }
}

using x = fn();

console.log(1, { x });

Pass Cases

using x = {
  [Symbol.dispose]() {
    console.log(2, { x });
  },
};

console.log(1, { x });

Additional Info

https://github.com/tc39/proposal-explicit-resource-management

https://devblogs.microsoft.com/typescript/announcing-typescript-5-2-beta/#using-declarations-and-explicit-resource-management

microsoft/TypeScript#54505

evanw/esbuild#3191

[bradzacher]

Thanks for the suggestion!
First up - as this feature is implemented in the just announced 5.2 beta - we won't be accepting suggestions for it at this time.

That being said - TBH I think it's a bit early on in the proposal's lifecycle to be writing or proposing lint rules for it - given this is brand new syntax I think we should wait a few months for people to play around and use the feature to figure out the footguns and lint cases.

Based on my limited understanding of the feature - I don't think that you will want to always using a disposable. For example - imagine a utility method like

function returnsDisposable(): Disposable {
  const inner = { [Symbol.dispose]: () => {} };
  return inner;
}

using outer = returnsDisposable();

In this instance you 100% wouldn't want to have using inner instead of const inner because doing so would mean that inner is cleaned up before the disposable is returned!

This is why I think we need to wait some time before people sus out the patterns and pitfalls of the feature.

[loynoir]

Description updated in #7160 (comment)

[bradzacher]

There's lots of potential footguns with using - I can see that it's very easy to dispose an object multiple times:

const x = {[Symbol.dispose]() {}};
using one = x;
using two = x;
using three = one;

This code is valid and at the end x will get disposed 3 times!
There's also the case I mentioned before about returning a using value and thus returning a disposed object.

It's so hard to know exactly how people will want to use this feature and what the lint cases will be overall. I suspect a lot of these lint rules will probably not require types and will be able to live in eslint core as well.

We'll have to wait and see!