Explicit resource management (`using`) transform improvements

[overlookmotel]

#9310 implemented explicit resource management (using declarations) transform.

A few tasks for us as follow-ups:

• Document enter_program visitor. Which statements are moved into new block, and which aren't? Why?
• Improve perf, by avoiding re-visiting statements (feat(transformer): transform explicit resource management #9310 (comment)).
  • perf(transformer/using): only do work to a static block if it has a using decl #9714
  • perf(transformer/using): only do work to a switch stmt if it contains a using decl #9715
  • perf(transformer/using): only transform block statements if needed #9716
• Add an option to enable/disable the transform. Currently it's always enabled.
• Fix scope of using declarations (Bindings declared with using should be block scoped and const #9666).
• Fix semantic errors in transform after that change.
• Add test cases for scope re-parenting (feat(transformer): transform explicit resource management #9310 (comment)).
• Remove reliance on SemanticBuilder::with_scope_tree_child_ids (hopefully). Then remove from example.
  • transformer: using crashes #9744
  • fix(transfomer/using): remove use of child ids #9961
• Investigate span mismatch in transform conformance tests for this transform. @overlookmotel

cc @camc314.

[overlookmotel]

@camc314 has pointed out a problem with moving transform into exit phase to improve perf - there's an incorrect interaction with async-to-generator transform.

Currently transforming this works fine:

async function fn() {
    await using x = whatever();
}

But if we move transforming the function into exit_function or exit_statements, then the output is:

function fn() {
  return _fn.apply(this, arguments);
}
function _fn() {
  _fn = babelHelpers.asyncToGenerator(function*() {
    try {
      var _usingCtx = babelHelpers.usingCtx();
      const x = _usingCtx.a(y);
    } catch (_) {
      _usingCtx.e = _;
    } finally {
      await _usingCtx.d(); // <-- `await` invalid here. Should be `yield`.
    }
  });
  return _fn.apply(this, arguments);
}

Problem is that using transform adds await _usingCtx.d() after async-to-generator has transformed the function, so it doesn't convert the await to yield.

Unclear what best way to solve this is.

[overlookmotel]

@camc314 I See you closed the PR stack up to #9716. Sorry I was slow to get to it. I was reviewing it when you closed it!

I am guessing the reason for the perf regression was the number of stacks. I would have thought that a single stack would be sufficient. I assume that it's either a static block or a statement block or a switch statement that has to handle the using statements, so they could all use the same stack.

Or, as you suggested previously, an FxHashSet<Address> containing the Addresses of nodes (statement block/program/etc) which contain a using declaration would work too, and might be more performant when the hashmap is empty (no using declarations).

[camc314]

all good, i'm going to fix the semantic issues first and get it correct, then. come back to perf. the changes to the soping in oxc_semantic cause the semantic stuff to no longer match