`using.target` to detect when in the expression of a `using` declaration.

[Qard]

This is addressing the same issue as #159 but with a very different proposed solution so I figured a separate thread might make more sense.

My thinking is to have an equivalent to new.target but for detecting when executing within the expression given to a using declaration.

function makeUsable() {
  if (!using.target) {
    throw new Error('must be used!')
  }

  return {
    [Symbol.dispose]() {
      console.log('disposed')
    }
  }
}

using foo = makeUsable() // fine
const foo = makeUsable() // throws

Probably should only work for direct calls or constructions as there's a bunch of complications like what happens in nested calls or if there are branching expressions like a() && b() where it could be that both are producing a usable value but only one would actually reach the declaration. Probably lots more edge cases I'm not thinking of right now, but it's an idea anyway. Could help to at least make ERM a bit safer for those that opt to provide usable values.

This came up in reference to: nodejs/node#61674

[Jamesernator]

This doesn't really help when you want to use disposables in a stack, e.g. in a class.

Regarding the linked issue, there's already a proposal specifically for the purpose of avoiding extra closures in async variables: https://github.com/tc39/proposal-async-context-disposable

[Qard]

Yes, I'm aware of the AsyncContext disposable extension proposal. AsyncContext is not usable for Node.js though so we need an equivalent for AsyncLocalStorage.

[rbuckton]

I'd like to note that using.target cannot be used here. using is a "contextual keyword", in that in any other context aside from a using declaration, it is a normal expression and using.target is already legal JS.

[Qard]

Fair. I'm happy with whatever solution could enable more certainty that both initial and deferred logic happen together. I saw you mention [Symbol.enter]() in the Node.js PR and that would be a reasonable solution too. 🙂