build(cargo): Update rustc to nightly-2024-04-03 (#8821)

Cargo.lock

@@ -3110,12 +3110,13 @@ dependencies = [
 
 [[package]]
 name = "rkyv"
-version = "0.7.42"
+version = "0.7.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58"
+checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0"
 dependencies = [
  "bitvec",
  "bytecheck",
+ "bytes",
  "hashbrown 0.12.3",
  "indexmap 1.9.3",
  "ptr_meta",
@@ -3128,9 +3129,9 @@ dependencies = [
 
 [[package]]
 name = "rkyv_derive"
-version = "0.7.43"
+version = "0.7.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5c462a1328c8e67e4d6dbad1eb0355dd43e8ab432c6e227a43657f16ade5033"
+checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65"
 dependencies = [
  "proc-macro2",
  "quote",

README.md

@@ -46,7 +46,7 @@ Also, SWC tries to ensure that
 
 for rust users.
 
-MSRV of crates is currently nightly, but we will support stable rustc again in the future.
+MSRV of crates is currently `1.71`.
 
 To update all SWC crates you use, you can run `curl https://raw.githubusercontent.com/swc-project/swc/main/scripts/update-all-swc-crates.sh | bash -s`. This script will update all dependencies to the latest version and run `cargo build` to ensure that everything works.
 Note that you need

clippy.toml

@@ -22,5 +22,5 @@ ignore-interior-mutability = [
   "swc_atoms::JsWord",
   "swc_ecma_ast::Id",
 ]
-msrv = "1.58"
+msrv = "1.71"
 type-complexity-threshold = 25000

crates/ast_node/src/ast_node_macro.rs

@@ -1,6 +1,5 @@
 use swc_macros_common::prelude::*;
 use syn::{
-    self,
     parse::{Parse, ParseStream},
     *,
 };

crates/ast_node/src/enum_deserialize.rs

@@ -1,6 +1,5 @@
 use swc_macros_common::prelude::*;
 use syn::{
-    self,
     parse::{Parse, ParseStream},
     *,
 };

crates/ast_node/src/lib.rs

@@ -5,7 +5,7 @@ extern crate proc_macro;
 
 use quote::quote;
 use swc_macros_common::prelude::*;
-use syn::{self, visit_mut::VisitMut, *};
+use syn::{visit_mut::VisitMut, *};
 
 mod ast_node_macro;
 mod enum_deserialize;

crates/string_enum/src/lib.rs

@@ -4,7 +4,7 @@ extern crate proc_macro;
 
 use quote::quote_spanned;
 use swc_macros_common::prelude::*;
-use syn::{self, parse::Parse, *};
+use syn::{parse::Parse, *};
 
 /// Creates `.as_str()` and then implements `Debug` and `Display` using it.
 ///

crates/swc/examples/minify.rs

@@ -1,7 +1,7 @@
 use std::{path::Path, sync::Arc};
 
 use anyhow::Context;
-use swc::{self, config::JsMinifyOptions, try_with_handler, BoolOrDataConfig};
+use swc::{config::JsMinifyOptions, try_with_handler, BoolOrDataConfig};
 use swc_common::{SourceMap, GLOBALS};
 
 fn main() {

crates/swc/examples/transform.rs

@@ -1,7 +1,7 @@
 use std::{path::Path, sync::Arc};
 
 use anyhow::Context;
-use swc::{self, try_with_handler};
+use swc::try_with_handler;
 use swc_common::{SourceMap, GLOBALS};
 
 fn main() {

crates/swc/examples/transform_error.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use anyhow::Context;
-use swc::{self, try_with_handler};
+use swc::try_with_handler;
 use swc_common::{errors::ColorConfig, FileName, SourceMap, GLOBALS};
 
 fn main() {

crates/swc/src/config/mod.rs

@@ -783,8 +783,9 @@ impl Options {
     }
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub enum RootMode {
+    #[default]
     #[serde(rename = "root")]
     Root,
     #[serde(rename = "upward")]
@@ -793,11 +794,6 @@ pub enum RootMode {
     UpwardOptional,
 }
 
-impl Default for RootMode {
-    fn default() -> Self {
-        RootMode::Root
-    }
-}
 const fn default_swcrc() -> bool {
     true
 }
@@ -1179,21 +1175,16 @@ pub struct JscOutputConfig {
     pub preamble: String,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub enum OutputCharset {
+    #[default]
     #[serde(rename = "utf8")]
     Utf8,
     #[serde(rename = "ascii")]
     Ascii,
 }
 
-impl Default for OutputCharset {
-    fn default() -> Self {
-        OutputCharset::Utf8
-    }
-}
-
 /// `jsc.experimental` in `.swcrc`
 #[derive(Debug, Default, Clone, Serialize, Deserialize, Merge)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]

crates/swc/src/lib.rs

@@ -132,7 +132,7 @@ use swc_common::{
 pub use swc_compiler_base::{PrintArgs, TransformOutput};
 pub use swc_config::config_types::{BoolConfig, BoolOr, BoolOrDataConfig};
 use swc_ecma_ast::{EsVersion, Program};
-use swc_ecma_codegen::{self, Node};
+use swc_ecma_codegen::Node;
 use swc_ecma_loader::resolvers::{
     lru::CachingResolver, node::NodeModulesResolver, tsc::TsConfigResolver,
 };

crates/swc/tests/fixture/issues-8xxx/8020/output/1.js

@@ -1,16 +1,14 @@
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function baz() {
     return bar;
 }
 try {
-    var _stack = [];
-    var foo = _using(_stack, null);
-    var bar = 1;
+    var _usingCtx = _using_ctx();
+    var foo = _usingCtx.u(null);
+    const bar = 1;
     console.log(baz());
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }

crates/swc/tests/fixture/issues-8xxx/8629/output/1.js

@@ -1,8 +1,7 @@
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 var _Disposable;
 try {
-    var _stack = [];
+    var _usingCtx = _using_ctx();
     var _computedKey;
     _computedKey = Symbol.dispose;
     class Disposable {
@@ -11,12 +10,11 @@ try {
         }
     }
     _Disposable = Disposable;
-    var _disposable = _using(_stack, new Disposable());
+    var _disposable = _usingCtx.u(new Disposable());
     console.log('ok');
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }
 export { _Disposable as Disposable };

crates/swc/tests/fixture/issues-8xxx/8629/output/2.js

@@ -1,16 +1,14 @@
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 var _Disposable;
 try {
-    var _stack = [];
+    var _usingCtx = _using_ctx();
     var Disposable = 1334;
     _Disposable = Disposable;
-    var _disposable = _using(_stack, new Disposable());
+    var _disposable = _usingCtx.u(new Disposable());
     console.log('ok');
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }
 export { _Disposable as Disposable };

crates/swc/tests/fixture/issues-8xxx/8774/output/index.js

@@ -1,5 +1,4 @@
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 const logClean = function() {
     return {
         [Symbol.dispose] () {
@@ -12,21 +11,20 @@ const logClean = function() {
 };
 async function foo() {
     try {
-        var _stack = [];
-        var a = _using(_stack, logClean());
-        var b = _using(_stack, logClean(), true);
+        var _usingCtx = _using_ctx();
+        const a = _usingCtx.u(logClean());
+        const b = _usingCtx.a(logClean());
         for (const a of [
             logClean(),
             logClean()
         ]){
             try {
-                var _stack1 = [];
+                var _usingCtx1 = _using_ctx();
                 {}
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx1.e = _;
             } finally{
-                _dispose(_stack1, _error, _hasError);
+                _usingCtx1.d();
             }
         }
         for (const a of [
@@ -34,20 +32,18 @@ async function foo() {
             logClean()
         ]){
             try {
-                var _stack2 = [];
+                var _usingCtx2 = _using_ctx();
                 {}
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         }
     } catch (_) {
-        var _error2 = _;
-        var _hasError2 = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error2, _hasError2);
+        await _usingCtx.d();
     }
 }
 foo();

crates/swc/tests/projects.rs

@@ -21,7 +21,7 @@ use swc_common::{
     BytePos, FileName, Globals, SourceMap, GLOBALS,
 };
 use swc_compiler_base::PrintArgs;
-use swc_ecma_ast::{EsVersion, *};
+use swc_ecma_ast::*;
 use swc_ecma_minifier::option::MangleOptions;
 use swc_ecma_parser::{EsConfig, Syntax, TsConfig};
 use swc_ecma_transforms::{

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2015).1.normal.js

@@ -2,26 +2,24 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _await_async_generator } from "@swc/helpers/_/_await_async_generator";
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function af() {
     return _af.apply(this, arguments);
 }
 function _af() {
     _af = _async_to_generator(function*() {
         try {
-            var _stack = [];
-            var d3 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d3 = _usingCtx.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
             yield null;
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            yield _dispose(_stack, _error, _hasError);
+            yield _usingCtx.d();
         }
     });
     return _af.apply(this, arguments);
@@ -32,44 +30,42 @@ function ag() {
 function _ag() {
     _ag = _wrap_async_generator(function*() {
         try {
-            var _stack = [];
-            var d5 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d5 = _usingCtx.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
             yield;
             yield _await_async_generator(null);
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            yield _await_async_generator(_dispose(_stack, _error, _hasError));
+            yield _await_async_generator(_usingCtx.d());
         }
     });
     return _ag.apply(this, arguments);
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.a({
         [Symbol.asyncDispose] () {
             return _async_to_generator(function*() {})();
         }
-    }, true);
-    var a = function() {
+    });
+    const a = function() {
         var _ref = _async_to_generator(function*() {
             try {
-                var _stack = [];
-                var d6 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d6 = _usingCtx.a({
                     [Symbol.asyncDispose] () {
                         return _async_to_generator(function*() {})();
                     }
-                }, true);
+                });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                yield _dispose(_stack, _error, _hasError);
+                yield _usingCtx.d();
             }
         });
         return function a() {
@@ -80,276 +76,258 @@ try {
         am() {
             return _async_to_generator(function*() {
                 try {
-                    var _stack = [];
-                    var d13 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d13 = _usingCtx.a({
                         [Symbol.asyncDispose] () {
                             return _async_to_generator(function*() {})();
                         }
-                    }, true);
+                    });
                     yield null;
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    yield _dispose(_stack, _error, _hasError);
+                    yield _usingCtx.d();
                 }
             })();
         }
         ag() {
             return _wrap_async_generator(function*() {
                 try {
-                    var _stack = [];
-                    var d15 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d15 = _usingCtx.a({
                         [Symbol.asyncDispose] () {
                             return _async_to_generator(function*() {})();
                         }
-                    }, true);
+                    });
                     yield;
                     yield _await_async_generator(null);
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    yield _await_async_generator(_dispose(_stack, _error, _hasError));
+                    yield _await_async_generator(_usingCtx.d());
                 }
             })();
         }
         constructor(){
             this.a = /*#__PURE__*/ _async_to_generator(function*() {
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.a({
                         [Symbol.asyncDispose] () {
                             return _async_to_generator(function*() {})();
                         }
-                    }, true);
+                    });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    yield _dispose(_stack, _error, _hasError);
+                    yield _usingCtx.d();
                 }
             });
         }
     }
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            await _dispose(_stack1, _error, _hasError);
+            await _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.a({
                     [Symbol.asyncDispose] () {
                         return _async_to_generator(function*() {})();
                     }
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.a({
                     [Symbol.asyncDispose] () {
                         return _async_to_generator(function*() {})();
                     }
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.a({
                     [Symbol.asyncDispose] () {
                         return _async_to_generator(function*() {})();
                     }
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                await _dispose(_stack4, _error3, _hasError3);
+                await _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            await _dispose(_stack8, _error7, _hasError7);
+            await _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            await _dispose(_stack9, _error8, _hasError8);
+            await _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            await _dispose(_stack10, _error9, _hasError9);
+            await _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            await _dispose(_stack11, _error10, _hasError10);
+            await _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            await _dispose(_stack12, _error11, _hasError11);
+            await _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            await _dispose(_stack13, _error12, _hasError12);
+            await _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.a({
                 [Symbol.asyncDispose] () {
                     return _async_to_generator(function*() {})();
                 }
-            }, true);
+            });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2015).2.minified.js

@@ -2,168 +2,167 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import "@swc/helpers/_/_await_async_generator";
 import "@swc/helpers/_/_wrap_async_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-    }, !0), _async_to_generator(function*() {
+    }), _async_to_generator(function*() {
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.a({
                 [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-            }, !0);
+            });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            yield _dispose(_stack, _error, _hasError);
+            yield _usingCtx.d();
         }
     });
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        await _dispose(_stack1, _error, _hasError);
+        await _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.a({
                     [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-                }, !0);
+                });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.a({
                     [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-                }, !0);
+                });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        await _dispose(_stack4, _error3, _hasError3);
+        await _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.a({
                 [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-            }, !0);
+            });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.a({
                 [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-            }, !0);
+            });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.a({
                 [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-            }, !0);
+            });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        await _dispose(_stack8, _error7, _hasError7);
+        await _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        await _dispose(_stack10, _error9, _hasError9);
+        await _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        await _dispose(_stack11, _error10, _hasError10);
+        await _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        await _dispose(_stack12, _error11, _hasError11);
+        await _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        await _dispose(_stack13, _error12, _hasError12);
+        await _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.a({
             [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-        }, !0);
+        });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        await _dispose(_stack14, _error13, _hasError13);
+        await _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2017).1.normal.js

@@ -1,289 +1,267 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, true);
-    var a = async ()=>{
+    });
+    const a = async ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            await _dispose(_stack, _error, _hasError);
+            await _usingCtx.d();
         }
     };
     class C1 {
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         constructor(){
             this.a = async ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.a({
                         async [Symbol.asyncDispose] () {}
-                    }, true);
+                    });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    await _dispose(_stack, _error, _hasError);
+                    await _usingCtx.d();
                 }
             };
         }
     }
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            await _dispose(_stack1, _error, _hasError);
+            await _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                await _dispose(_stack4, _error3, _hasError3);
+                await _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            await _dispose(_stack8, _error7, _hasError7);
+            await _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            await _dispose(_stack9, _error8, _hasError8);
+            await _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            await _dispose(_stack10, _error9, _hasError9);
+            await _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            await _dispose(_stack11, _error10, _hasError10);
+            await _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            await _dispose(_stack12, _error11, _hasError11);
+            await _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            await _dispose(_stack13, _error12, _hasError12);
+            await _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2017).2.minified.js

@@ -1,155 +1,154 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        await _dispose(_stack1, _error, _hasError);
+        await _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        await _dispose(_stack4, _error3, _hasError3);
+        await _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        await _dispose(_stack8, _error7, _hasError7);
+        await _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        await _dispose(_stack10, _error9, _hasError9);
+        await _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        await _dispose(_stack11, _error10, _hasError10);
+        await _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        await _dispose(_stack12, _error11, _hasError11);
+        await _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        await _dispose(_stack13, _error12, _hasError12);
+        await _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        await _dispose(_stack14, _error13, _hasError13);
+        await _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2022).1.normal.js

@@ -1,289 +1,267 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, true);
-    var a = async ()=>{
+    });
+    const a = async ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            await _dispose(_stack, _error, _hasError);
+            await _usingCtx.d();
         }
     };
     class C1 {
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         constructor(){
             this.a = async ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.a({
                         async [Symbol.asyncDispose] () {}
-                    }, true);
+                    });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    await _dispose(_stack, _error, _hasError);
+                    await _usingCtx.d();
                 }
             };
         }
     }
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            await _dispose(_stack1, _error, _hasError);
+            await _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                await _dispose(_stack4, _error3, _hasError3);
+                await _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            await _dispose(_stack8, _error7, _hasError7);
+            await _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            await _dispose(_stack9, _error8, _hasError8);
+            await _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            await _dispose(_stack10, _error9, _hasError9);
+            await _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            await _dispose(_stack11, _error10, _hasError10);
+            await _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            await _dispose(_stack12, _error11, _hasError11);
+            await _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            await _dispose(_stack13, _error12, _hasError12);
+            await _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es2022).2.minified.js

@@ -1,155 +1,154 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        await _dispose(_stack1, _error, _hasError);
+        await _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        await _dispose(_stack4, _error3, _hasError3);
+        await _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        await _dispose(_stack8, _error7, _hasError7);
+        await _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        await _dispose(_stack10, _error9, _hasError9);
+        await _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        await _dispose(_stack11, _error10, _hasError10);
+        await _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        await _dispose(_stack12, _error11, _hasError11);
+        await _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        await _dispose(_stack13, _error12, _hasError12);
+        await _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        await _dispose(_stack14, _error13, _hasError13);
+        await _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es5).1.normal.js

@@ -5,14 +5,13 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function af() {
     return _af.apply(this, arguments);
 }
 function _af() {
     _af = _async_to_generator(function() {
-        var _stack, d3, _, _error, _hasError;
+        var _usingCtx, d3, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -22,8 +21,8 @@ function _af() {
                         3,
                         5
                     ]);
-                    _stack = [];
-                    d3 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                    _usingCtx = _using_ctx();
+                    d3 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                         return _async_to_generator(function() {
                             return _ts_generator(this, function(_state) {
                                 return [
@@ -31,7 +30,7 @@ function _af() {
                                 ];
                             });
                         })();
-                    }), true);
+                    }));
                     return [
                         4,
                         null
@@ -44,8 +43,7 @@ function _af() {
                     ];
                 case 2:
                     _ = _state.sent();
-                    _error = _;
-                    _hasError = true;
+                    _usingCtx.e = _;
                     return [
                         3,
                         5
@@ -53,7 +51,7 @@ function _af() {
                 case 3:
                     return [
                         4,
-                        _dispose(_stack, _error, _hasError)
+                        _usingCtx.d()
                     ];
                 case 4:
                     _state.sent();
@@ -74,7 +72,7 @@ function ag() {
 }
 function _ag() {
     _ag = _wrap_async_generator(function() {
-        var _stack, d5, _, _error, _hasError;
+        var _usingCtx, d5, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -84,8 +82,8 @@ function _ag() {
                         4,
                         6
                     ]);
-                    _stack = [];
-                    d5 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                    _usingCtx = _using_ctx();
+                    d5 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                         return _async_to_generator(function() {
                             return _ts_generator(this, function(_state) {
                                 return [
@@ -93,7 +91,7 @@ function _ag() {
                                 ];
                             });
                         })();
-                    }), true);
+                    }));
                     return [
                         4
                     ];
@@ -111,8 +109,7 @@ function _ag() {
                     ];
                 case 3:
                     _ = _state.sent();
-                    _error = _;
-                    _hasError = true;
+                    _usingCtx.e = _;
                     return [
                         3,
                         6
@@ -120,7 +117,7 @@ function _ag() {
                 case 4:
                     return [
                         4,
-                        _await_async_generator(_dispose(_stack, _error, _hasError))
+                        _await_async_generator(_usingCtx.d())
                     ];
                 case 5:
                     _state.sent();
@@ -137,8 +134,8 @@ function _ag() {
     return _ag.apply(this, arguments);
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
         return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {
                 return [
@@ -146,10 +143,10 @@ try {
                 ];
             });
         })();
-    }), true);
+    }));
     var a = function() {
         var _ref = _async_to_generator(function() {
-            var _stack, d6, _, _error, _hasError;
+            var _usingCtx, d6, _;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -159,8 +156,8 @@ try {
                             2,
                             4
                         ]);
-                        _stack = [];
-                        d6 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                        _usingCtx = _using_ctx();
+                        d6 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                             return _async_to_generator(function() {
                                 return _ts_generator(this, function(_state) {
                                     return [
@@ -168,15 +165,14 @@ try {
                                     ];
                                 });
                             })();
-                        }), true);
+                        }));
                         return [
                             3,
                             4
                         ];
                     case 1:
                         _ = _state.sent();
-                        _error = _;
-                        _hasError = true;
+                        _usingCtx.e = _;
                         return [
                             3,
                             4
@@ -184,7 +180,7 @@ try {
                     case 2:
                         return [
                             4,
-                            _dispose(_stack, _error, _hasError)
+                            _usingCtx.d()
                         ];
                     case 3:
                         _state.sent();
@@ -207,7 +203,7 @@ try {
         function C1() {
             _class_call_check(this, C1);
             this.a = /*#__PURE__*/ _async_to_generator(function() {
-                var _stack, d7, _, _error, _hasError;
+                var _usingCtx, d7, _;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -217,8 +213,8 @@ try {
                                 2,
                                 4
                             ]);
-                            _stack = [];
-                            d7 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                            _usingCtx = _using_ctx();
+                            d7 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                                 return _async_to_generator(function() {
                                     return _ts_generator(this, function(_state) {
                                         return [
@@ -226,15 +222,14 @@ try {
                                         ];
                                     });
                                 })();
-                            }), true);
+                            }));
                             return [
                                 3,
                                 4
                             ];
                         case 1:
                             _ = _state.sent();
-                            _error = _;
-                            _hasError = true;
+                            _usingCtx.e = _;
                             return [
                                 3,
                                 4
@@ -242,7 +237,7 @@ try {
                         case 2:
                             return [
                                 4,
-                                _dispose(_stack, _error, _hasError)
+                                _usingCtx.d()
                             ];
                         case 3:
                             _state.sent();
@@ -260,7 +255,7 @@ try {
         var _proto = C1.prototype;
         _proto.am = function am() {
             return _async_to_generator(function() {
-                var _stack, d13, _, _error, _hasError;
+                var _usingCtx, d13, _;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -270,8 +265,8 @@ try {
                                 3,
                                 5
                             ]);
-                            _stack = [];
-                            d13 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                            _usingCtx = _using_ctx();
+                            d13 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                                 return _async_to_generator(function() {
                                     return _ts_generator(this, function(_state) {
                                         return [
@@ -279,7 +274,7 @@ try {
                                         ];
                                     });
                                 })();
-                            }), true);
+                            }));
                             return [
                                 4,
                                 null
@@ -292,8 +287,7 @@ try {
                             ];
                         case 2:
                             _ = _state.sent();
-                            _error = _;
-                            _hasError = true;
+                            _usingCtx.e = _;
                             return [
                                 3,
                                 5
@@ -301,7 +295,7 @@ try {
                         case 3:
                             return [
                                 4,
-                                _dispose(_stack, _error, _hasError)
+                                _usingCtx.d()
                             ];
                         case 4:
                             _state.sent();
@@ -318,7 +312,7 @@ try {
         };
         _proto.ag = function ag() {
             return _wrap_async_generator(function() {
-                var _stack, d15, _, _error, _hasError;
+                var _usingCtx, d15, _;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -328,8 +322,8 @@ try {
                                 4,
                                 6
                             ]);
-                            _stack = [];
-                            d15 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                            _usingCtx = _using_ctx();
+                            d15 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
                                 return _async_to_generator(function() {
                                     return _ts_generator(this, function(_state) {
                                         return [
@@ -337,7 +331,7 @@ try {
                                         ];
                                     });
                                 })();
-                            }), true);
+                            }));
                             return [
                                 4
                             ];
@@ -355,8 +349,7 @@ try {
                             ];
                         case 3:
                             _ = _state.sent();
-                            _error = _;
-                            _hasError = true;
+                            _usingCtx.e = _;
                             return [
                                 3,
                                 6
@@ -364,7 +357,7 @@ try {
                         case 4:
                             return [
                                 4,
-                                _await_async_generator(_dispose(_stack, _error, _hasError))
+                                _await_async_generator(_usingCtx.d())
                             ];
                         case 5:
                             _state.sent();
@@ -383,8 +376,8 @@ try {
     }();
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx1 = _using_ctx();
+            var d19 = _usingCtx1.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -392,19 +385,18 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            await _dispose(_stack1, _error, _hasError);
+            await _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, _define_property({}, Symbol.asyncDispose, function() {
+                var _usingCtx2 = _using_ctx();
+                var d20 = _usingCtx2.a(_define_property({}, Symbol.asyncDispose, function() {
                     return _async_to_generator(function() {
                         return _ts_generator(this, function(_state) {
                             return [
@@ -412,18 +404,17 @@ try {
                             ];
                         });
                     })();
-                }), true);
+                }));
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, _define_property({}, Symbol.asyncDispose, function() {
+                var _usingCtx3 = _using_ctx();
+                var d21 = _usingCtx3.a(_define_property({}, Symbol.asyncDispose, function() {
                     return _async_to_generator(function() {
                         return _ts_generator(this, function(_state) {
                             return [
@@ -431,20 +422,19 @@ try {
                             ];
                         });
                     })();
-                }), true);
+                }));
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, _define_property({}, Symbol.asyncDispose, function() {
+                var _usingCtx4 = _using_ctx();
+                var d22 = _usingCtx4.a(_define_property({}, Symbol.asyncDispose, function() {
                     return _async_to_generator(function() {
                         return _ts_generator(this, function(_state) {
                             return [
@@ -452,19 +442,18 @@ try {
                             ];
                         });
                     })();
-                }), true);
+                }));
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                await _dispose(_stack4, _error3, _hasError3);
+                await _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx5 = _using_ctx();
+            var d23 = _usingCtx5.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -472,17 +461,16 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx6 = _using_ctx();
+            var d24 = _usingCtx6.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -490,17 +478,16 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx7 = _using_ctx();
+            var d25 = _usingCtx7.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -508,18 +495,17 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx8 = _using_ctx();
+            var d26 = _usingCtx8.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -527,17 +513,16 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            await _dispose(_stack8, _error7, _hasError7);
+            await _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx9 = _using_ctx();
+            var d27 = _usingCtx9.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -545,18 +530,17 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            await _dispose(_stack9, _error8, _hasError8);
+            await _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx10 = _using_ctx();
+            var d28 = _usingCtx10.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -564,19 +548,18 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            await _dispose(_stack10, _error9, _hasError9);
+            await _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx11 = _using_ctx();
+            var d29 = _usingCtx11.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -584,19 +567,18 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            await _dispose(_stack11, _error10, _hasError10);
+            await _usingCtx11.d();
         }
     }while (true);
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx12 = _using_ctx();
+            var d30 = _usingCtx12.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -604,19 +586,18 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            await _dispose(_stack12, _error11, _hasError11);
+            await _usingCtx12.d();
         }
     }
     for(var x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx13 = _using_ctx();
+            var d31 = _usingCtx13.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -624,19 +605,18 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            await _dispose(_stack13, _error12, _hasError12);
+            await _usingCtx13.d();
         }
     }
     for(var _i = 0, _iter = []; _i < _iter.length; _i++){
         var x1 = _iter[_i];
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx14 = _using_ctx();
+            var d32 = _usingCtx14.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -644,18 +624,16 @@ try {
                         ];
                     });
                 })();
-            }), true);
+            }));
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=es5).2.minified.js

@@ -5,11 +5,10 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
         return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {
                 return [
@@ -17,8 +16,8 @@ try {
                 ];
             });
         })();
-    }), !0), _async_to_generator(function() {
-        var _stack, _error, _hasError;
+    })), _async_to_generator(function() {
+        var _usingCtx, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -27,7 +26,7 @@ try {
                         1,
                         2,
                         4
-                    ]), _stack = [], _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+                    ]), (_usingCtx = _using_ctx()).a(_define_property({}, Symbol.asyncDispose, function() {
                         return _async_to_generator(function() {
                             return _ts_generator(this, function(_state) {
                                 return [
@@ -35,19 +34,19 @@ try {
                                 ];
                             });
                         })();
-                    }), !0), [
+                    })), [
                         3,
                         4
                     ];
                 case 1:
-                    return _error = _state.sent(), _hasError = !0, [
+                    return _ = _state.sent(), _usingCtx.e = _, [
                         3,
                         4
                     ];
                 case 2:
                     return [
                         4,
-                        _dispose(_stack, _error, _hasError)
+                        _usingCtx.d()
                     ];
                 case 3:
                     return _state.sent(), [
@@ -61,8 +60,8 @@ try {
         });
     });
     try {
-        var _stack1 = [];
-        _using(_stack1, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -70,17 +69,17 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        await _dispose(_stack1, _error, _hasError);
+        await _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, _define_property({}, Symbol.asyncDispose, function() {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.a(_define_property({}, Symbol.asyncDispose, function() {
                     return _async_to_generator(function() {
                         return _ts_generator(this, function(_state) {
                             return [
@@ -88,17 +87,17 @@ try {
                             ];
                         });
                     })();
-                }), !0);
+                }));
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, _define_property({}, Symbol.asyncDispose, function() {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.a(_define_property({}, Symbol.asyncDispose, function() {
                     return _async_to_generator(function() {
                         return _ts_generator(this, function(_state) {
                             return [
@@ -106,16 +105,16 @@ try {
                             ];
                         });
                     })();
-                }), !0);
+                }));
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -123,16 +122,16 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        await _dispose(_stack4, _error3, _hasError3);
+        await _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -140,16 +139,16 @@ try {
                         ];
                     });
                 })();
-            }), !0);
+            }));
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -157,16 +156,16 @@ try {
                         ];
                     });
                 })();
-            }), !0);
+            }));
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -174,16 +173,16 @@ try {
                         ];
                     });
                 })();
-            }), !0);
+            }));
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -191,15 +190,15 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        await _dispose(_stack8, _error7, _hasError7);
+        await _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -207,16 +206,16 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        await _dispose(_stack10, _error9, _hasError9);
+        await _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -224,16 +223,16 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        await _dispose(_stack11, _error10, _hasError10);
+        await _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -241,16 +240,16 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        await _dispose(_stack12, _error11, _hasError11);
+        await _usingCtx12.d();
     }
     for(var x in {})try {
-        var _stack13 = [];
-        _using(_stack13, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -258,17 +257,17 @@ try {
                     ];
                 });
             })();
-        }), !0);
+        }));
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        await _dispose(_stack13, _error12, _hasError12);
+        await _usingCtx13.d();
     }
     for(var _i = 0, _iter = []; _i < _iter.length; _i++){
         _iter[_i];
         try {
-            var _stack14 = [];
-            _using(_stack14, _define_property({}, Symbol.asyncDispose, function() {
+            var _usingCtx14 = _using_ctx();
+            _usingCtx14.a(_define_property({}, Symbol.asyncDispose, function() {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
@@ -276,15 +275,15 @@ try {
                         ];
                     });
                 })();
-            }), !0);
+            }));
         } catch (_) {
-            var _error13 = _, _hasError13 = !0;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=esnext).1.normal.js

@@ -1,289 +1,267 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, true);
-    var a = async ()=>{
+    });
+    const a = async ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            await _dispose(_stack, _error, _hasError);
+            await _usingCtx.d();
         }
     };
     class C1 {
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
         constructor(){
             this.a = async ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.a({
                         async [Symbol.asyncDispose] () {}
-                    }, true);
+                    });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    await _dispose(_stack, _error, _hasError);
+                    await _usingCtx.d();
                 }
             };
         }
     }
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            await _dispose(_stack1, _error, _hasError);
+            await _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
+                });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                await _dispose(_stack4, _error3, _hasError3);
+                await _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            await _dispose(_stack8, _error7, _hasError7);
+            await _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            await _dispose(_stack9, _error8, _hasError8);
+            await _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            await _dispose(_stack10, _error9, _hasError9);
+            await _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            await _dispose(_stack11, _error10, _hasError10);
+            await _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            await _dispose(_stack12, _error11, _hasError11);
+            await _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            await _dispose(_stack13, _error12, _hasError12);
+            await _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.a({
                 async [Symbol.asyncDispose] () {}
-            }, true);
+            });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            await _dispose(_stack14, _error13, _hasError13);
+            await _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.1(target=esnext).2.minified.js

@@ -1,155 +1,154 @@
 //// [awaitUsingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        await _dispose(_stack1, _error, _hasError);
+        await _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                await _dispose(_stack2, _error1, _hasError1);
+                await _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                await _dispose(_stack3, _error2, _hasError2);
+                await _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        await _dispose(_stack4, _error3, _hasError3);
+        await _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            await _dispose(_stack5, _error4, _hasError4);
+            await _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            await _dispose(_stack6, _error5, _hasError5);
+            await _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.a({
                 async [Symbol.asyncDispose] () {}
-            }, !0);
+            });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            await _dispose(_stack7, _error6, _hasError6);
+            await _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        await _dispose(_stack8, _error7, _hasError7);
+        await _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        await _dispose(_stack10, _error9, _hasError9);
+        await _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        await _dispose(_stack11, _error10, _hasError10);
+        await _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        await _dispose(_stack12, _error11, _hasError11);
+        await _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        await _dispose(_stack13, _error12, _hasError12);
+        await _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.a({
             async [Symbol.asyncDispose] () {}
-        }, !0);
+        });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        await _dispose(_stack14, _error13, _hasError13);
+        await _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error14, _hasError14);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.12.1.normal.js

@@ -1,14 +1,12 @@
 //// [awaitUsingDeclarations.12.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function f() {
     try {
-        var _stack = [];
-        var x = _using(_stack, {}, true);
+        var _usingCtx = _using_ctx();
+        const x = _usingCtx.a({});
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.12.2.minified.js

@@ -1,3 +1,2 @@
 //// [awaitUsingDeclarations.12.ts]
-import "@swc/helpers/_/_dispose";
-import "@swc/helpers/_/_using";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarations.13.1.normal.js

@@ -1,23 +1,20 @@
 //// [awaitUsingDeclarations.13.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var x = _using(_stack, null, true);
+        var _usingCtx = _using_ctx();
+        const x = _usingCtx.a(null);
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var x = _using(_stack, null, true);
+    var _usingCtx = _using_ctx();
+    var x = _usingCtx.a(null);
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.13.2.minified.js

@@ -1,11 +1,10 @@
 //// [awaitUsingDeclarations.13.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, null, !0);
+    var _usingCtx = _using_ctx();
+    _usingCtx.a(null);
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.15.1.normal.js

@@ -1,16 +1,14 @@
 //// [awaitUsingDeclarations.15.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function f() {
     try {
-        var _stack = [];
-        var _ = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const _ = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.15.2.minified.js

@@ -1,3 +1,2 @@
 //// [awaitUsingDeclarations.15.ts]
-import "@swc/helpers/_/_dispose";
-import "@swc/helpers/_/_using";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2015).1.normal.js

@@ -1,23 +1,21 @@
 //// [awaitUsingDeclarations.2.ts]
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             [Symbol.asyncDispose] () {
                 return _async_to_generator(function*() {})();
             }
-        }, true), d2 = _using(_stack, {
+        }), d2 = _usingCtx.a({
             [Symbol.asyncDispose] () {
                 return _async_to_generator(function*() {})();
             }
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2015).2.minified.js

@@ -1,16 +1,15 @@
 //// [awaitUsingDeclarations.2.ts]
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-    }, !0), _using(_stack, {
+    }), _usingCtx.a({
         [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2017).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, {
+        }), d2 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2017).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, {
+    }), _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2022).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, {
+        }), d2 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es2022).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, {
+    }), _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es5).1.normal.js

@@ -2,12 +2,11 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx = _using_ctx();
+        var d1 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -15,7 +14,7 @@ import { _ as _using } from "@swc/helpers/_/_using";
                     ];
                 });
             })();
-        }), true), d2 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+        })), d2 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -23,11 +22,10 @@ import { _ as _using } from "@swc/helpers/_/_using";
                     ];
                 });
             })();
-        }), true);
+        }));
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=es5).2.minified.js

@@ -2,11 +2,10 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
         return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {
                 return [
@@ -14,7 +13,7 @@ try {
                 ];
             });
         })();
-    }), !0), _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+    })), _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
         return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {
                 return [
@@ -22,9 +21,9 @@ try {
                 ];
             });
         })();
-    }), !0);
+    }));
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=esnext).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, {
+        }), d2 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.2(target=esnext).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, {
+    }), _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2015).1.normal.js

@@ -1,21 +1,19 @@
 //// [awaitUsingDeclarations.3.ts]
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             [Symbol.asyncDispose] () {
                 return _async_to_generator(function*() {})();
             }
-        }, true), d2 = _using(_stack, null, true), d3 = _using(_stack, undefined, true), d4 = _using(_stack, {
+        }), d2 = _usingCtx.a(null), d3 = _usingCtx.a(undefined), d4 = _usingCtx.a({
             [Symbol.dispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2015).2.minified.js

@@ -1,16 +1,15 @@
 //// [awaitUsingDeclarations.3.ts]
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         [Symbol.asyncDispose]: ()=>_async_to_generator(function*() {})()
-    }, !0), _using(_stack, null, !0), _using(_stack, void 0, !0), _using(_stack, {
+    }), _usingCtx.a(null), _usingCtx.a(void 0), _usingCtx.a({
         [Symbol.dispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2017).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, null, true), d3 = _using(_stack, undefined, true), d4 = _using(_stack, {
+        }), d2 = _usingCtx.a(null), d3 = _usingCtx.a(undefined), d4 = _usingCtx.a({
             [Symbol.dispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2017).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, null, !0), _using(_stack, void 0, !0), _using(_stack, {
+    }), _usingCtx.a(null), _usingCtx.a(void 0), _usingCtx.a({
         [Symbol.dispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2022).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, null, true), d3 = _using(_stack, undefined, true), d4 = _using(_stack, {
+        }), d2 = _usingCtx.a(null), d3 = _usingCtx.a(undefined), d4 = _usingCtx.a({
             [Symbol.dispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es2022).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, null, !0), _using(_stack, void 0, !0), _using(_stack, {
+    }), _usingCtx.a(null), _usingCtx.a(void 0), _usingCtx.a({
         [Symbol.dispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es5).1.normal.js

@@ -2,12 +2,11 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+        var _usingCtx = _using_ctx();
+        var d1 = _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
                     return [
@@ -15,11 +14,10 @@ import { _ as _using } from "@swc/helpers/_/_using";
                     ];
                 });
             })();
-        }), true), d2 = _using(_stack, null, true), d3 = _using(_stack, undefined, true), d4 = _using(_stack, _define_property({}, Symbol.dispose, function() {}), true);
+        })), d2 = _usingCtx.a(null), d3 = _usingCtx.a(undefined), d4 = _usingCtx.a(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=es5).2.minified.js

@@ -2,11 +2,10 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, _define_property({}, Symbol.asyncDispose, function() {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a(_define_property({}, Symbol.asyncDispose, function() {
         return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {
                 return [
@@ -14,9 +13,9 @@ try {
                 ];
             });
         })();
-    }), !0), _using(_stack, null, !0), _using(_stack, void 0, !0), _using(_stack, _define_property({}, Symbol.dispose, function() {}), !0);
+    })), _usingCtx.a(null), _usingCtx.a(void 0), _usingCtx.a(_define_property({}, Symbol.dispose, function() {}));
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=esnext).1.normal.js

@@ -1,18 +1,16 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.a({
             async [Symbol.asyncDispose] () {}
-        }, true), d2 = _using(_stack, null, true), d3 = _using(_stack, undefined, true), d4 = _using(_stack, {
+        }), d2 = _usingCtx.a(null), d3 = _usingCtx.a(undefined), d4 = _usingCtx.a({
             [Symbol.dispose] () {}
-        }, true);
+        });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.3(target=esnext).2.minified.js

@@ -1,15 +1,14 @@
 //// [awaitUsingDeclarations.3.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), _using(_stack, null, !0), _using(_stack, void 0, !0), _using(_stack, {
+    }), _usingCtx.a(null), _usingCtx.a(void 0), _usingCtx.a({
         [Symbol.dispose] () {}
-    }, !0);
+    });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarations.9.1.normal.js

@@ -1,14 +1,12 @@
 //// [awaitUsingDeclarations.9.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var a = _using(_stack, null, true);
+        var _usingCtx = _using_ctx();
+        const a = _usingCtx.a(null);
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }export { };

crates/swc/tests/tsc-references/awaitUsingDeclarations.9.2.minified.js

@@ -1,11 +1,10 @@
 //// [awaitUsingDeclarations.9.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, null, !0);
+    var _usingCtx = _using_ctx();
+    _usingCtx.a(null);
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2015).1.normal.js

@@ -1,7 +1,7 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
 import { _ as _async_iterator } from "@swc/helpers/_/_async_iterator";
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function main() {
     return _main.apply(this, arguments);
 }
@@ -25,13 +25,12 @@ function _main() {
                     let _value = _step.value;
                     const d1 = _value;
                     try {
-                        var _stack = [];
+                        var _usingCtx = _using_ctx();
                         {}
                     } catch (_) {
-                        var _error = _;
-                        var _hasError = true;
+                        _usingCtx.e = _;
                     } finally{
-                        _dispose(_stack, _error, _hasError);
+                        _usingCtx.d();
                     }
                 }
             } catch (err) {

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2015).2.minified.js

@@ -1,4 +1,4 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
 import "@swc/helpers/_/_async_iterator";
 import "@swc/helpers/_/_async_to_generator";
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2017).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for await (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2017).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2022).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for await (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es2022).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es5).1.normal.js

@@ -3,13 +3,13 @@ import { _ as _async_iterator } from "@swc/helpers/_/_async_iterator";
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function main() {
     return _main.apply(this, arguments);
 }
 function _main() {
     _main = _async_to_generator(function() {
-        var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, d1, _stack, _error, _hasError, err;
+        var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, d1, _usingCtx, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -50,13 +50,12 @@ function _main() {
                     _value = _step.value;
                     d1 = _value;
                     try {
-                        _stack = [];
+                        _usingCtx = _using_ctx();
                         {}
                     } catch (_) {
-                        _error = _;
-                        _hasError = true;
+                        _usingCtx.e = _;
                     } finally{
-                        _dispose(_stack, _error, _hasError);
+                        _usingCtx.d();
                     }
                     _state.label = 4;
                 case 4:

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=es5).2.minified.js

@@ -3,4 +3,4 @@ import "@swc/helpers/_/_async_iterator";
 import "@swc/helpers/_/_async_to_generator";
 import "@swc/helpers/_/_define_property";
 import "@swc/helpers/_/_ts_generator";
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=esnext).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for await (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForAwaitOf(target=esnext).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForAwaitOf.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2015).1.normal.js

@@ -1,6 +1,6 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function main() {
     return _main.apply(this, arguments);
 }
@@ -19,13 +19,12 @@ function _main() {
             undefined
         ]){
             try {
-                var _stack = [];
+                var _usingCtx = _using_ctx();
                 {}
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     });

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2015).2.minified.js

@@ -1,3 +1,3 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
 import "@swc/helpers/_/_async_to_generator";
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2017).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2017).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2022).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es2022).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es5).1.normal.js

@@ -2,13 +2,13 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function main() {
     return _main.apply(this, arguments);
 }
 function _main() {
     _main = _async_to_generator(function() {
-        var _i, _iter, d1, _stack, _error, _hasError;
+        var _i, _iter, d1, _usingCtx;
         return _ts_generator(this, function(_state) {
             for(_i = 0, _iter = [
                 _define_property({}, Symbol.asyncDispose, function() {
@@ -26,13 +26,12 @@ function _main() {
             ]; _i < _iter.length; _i++){
                 d1 = _iter[_i];
                 try {
-                    _stack = [];
+                    _usingCtx = _using_ctx();
                     {}
                 } catch (_) {
-                    _error = _;
-                    _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             }
             return [

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=es5).2.minified.js

@@ -2,4 +2,4 @@
 import "@swc/helpers/_/_async_to_generator";
 import "@swc/helpers/_/_define_property";
 import "@swc/helpers/_/_ts_generator";
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=esnext).1.normal.js

@@ -1,5 +1,5 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function main() {
     for (const d1 of [
         {
@@ -12,13 +12,12 @@ async function main() {
         undefined
     ]){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             {}
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/awaitUsingDeclarationsInForOf.1(target=esnext).2.minified.js

@@ -1,2 +1,2 @@
 //// [awaitUsingDeclarationsInForOf.1.ts]
-import "@swc/helpers/_/_dispose";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/awaitUsingDeclarationsTopLevelOfModule.1(module=es6).1.normal.js

@@ -1,27 +1,25 @@
 //// [awaitUsingDeclarationsTopLevelOfModule.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 var _x;
 export { y };
 var _w;
 export { _default as default };
 try {
-    var _stack = [];
+    var _usingCtx = _using_ctx();
     const x = 1;
     _x = x;
-    var z = _using(_stack, {
+    var z = _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, true);
-    var y = 2;
+    });
+    const y = 2;
     const w = 3;
     _w = w;
     var _default = 4;
     console.log(w, x, y, z);
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }
 export { _x as x };
 export { _w as w };

crates/swc/tests/tsc-references/awaitUsingDeclarationsTopLevelOfModule.1(module=es6).2.minified.js

@@ -1,18 +1,17 @@
 //// [awaitUsingDeclarationsTopLevelOfModule.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _x, _w, _stack = [];
+    var _x, _w, _usingCtx = _using_ctx();
     _x = 1;
-    var z = _using(_stack, {
+    var z = _usingCtx.a({
         async [Symbol.asyncDispose] () {}
-    }, !0), y = 2;
+    });
     _w = 3;
     var _default = 4;
-    console.log(3, 1, y, z);
+    console.log(3, 1, 2, z);
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    await _dispose(_stack, _error, _hasError);
+    await _usingCtx.d();
 }
 export { y, _default as default, _x as x, _w as w };

crates/swc/tests/tsc-references/awaitUsingDeclarationsTopLevelOfModule.1(module=system).1.normal.js

@@ -1,41 +1,36 @@
 //// [awaitUsingDeclarationsTopLevelOfModule.1.ts]
 System.register([
-    "@swc/helpers/_/_dispose",
-    "@swc/helpers/_/_using"
+    "@swc/helpers/_/_using_ctx"
 ], function(_export, _context) {
     "use strict";
-    var _dispose, _using, _x, _w;
+    var _using_ctx, _x, _w;
     _export({
         x: void 0,
         w: void 0
     });
     return {
         setters: [
-            function(_dispose1) {
-                _dispose = _dispose1._;
-            },
-            function(_using1) {
-                _using = _using1._;
+            function(_using_ctx1) {
+                _using_ctx = _using_ctx1._;
             }
         ],
         execute: async function() {
             try {
-                var _stack = [];
+                var _usingCtx = _using_ctx();
                 const x = 1;
                 _export("x", _x = x);
-                var z = _using(_stack, {
+                var z = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, true);
-                var y = 2;
+                });
+                const y = 2;
                 const w = 3;
                 _export("w", _w = w);
                 var _default = 4;
                 console.log(w, x, y, z);
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
     };

crates/swc/tests/tsc-references/awaitUsingDeclarationsTopLevelOfModule.1(module=system).2.minified.js

@@ -1,33 +1,29 @@
 //// [awaitUsingDeclarationsTopLevelOfModule.1.ts]
 System.register([
-    "@swc/helpers/_/_dispose",
-    "@swc/helpers/_/_using"
+    "@swc/helpers/_/_using_ctx"
 ], function(_export, _context) {
-    var _dispose, _using;
+    var _using_ctx;
     return _export({
         x: void 0,
         w: void 0
     }), {
         setters: [
-            function(_dispose1) {
-                _dispose = _dispose1._;
-            },
-            function(_using1) {
-                _using = _using1._;
+            function(_using_ctx1) {
+                _using_ctx = _using_ctx1._;
             }
         ],
         execute: async function() {
             try {
-                var _stack = [];
+                var _usingCtx = _using_ctx();
                 _export("x", 1);
-                var z = _using(_stack, {
+                var z = _usingCtx.a({
                     async [Symbol.asyncDispose] () {}
-                }, !0);
+                });
                 _export("w", 3), console.log(3, 1, 2, z);
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                await _dispose(_stack, _error, _hasError);
+                await _usingCtx.d();
             }
         }
     };

crates/swc/tests/tsc-references/awaitUsingDeclarationsWithImportHelpers.1.normal.js

@@ -1,15 +1,13 @@
 //// [awaitUsingDeclarationsWithImportHelpers.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 async function f() {
     try {
-        var _stack = [];
-        var a = _using(_stack, null, true);
+        var _usingCtx = _using_ctx();
+        const a = _usingCtx.a(null);
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        await _dispose(_stack, _error, _hasError);
+        await _usingCtx.d();
     }
 }
 export { };

crates/swc/tests/tsc-references/awaitUsingDeclarationsWithImportHelpers.2.minified.js

@@ -1,3 +1,2 @@
 //// [awaitUsingDeclarationsWithImportHelpers.ts]
-import "@swc/helpers/_/_dispose";
-import "@swc/helpers/_/_using";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2015).1.normal.js

@@ -2,19 +2,17 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _await_async_generator } from "@swc/helpers/_/_await_async_generator";
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var d2 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d2 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function af() {
@@ -23,32 +21,30 @@ function af() {
 function _af() {
     _af = _async_to_generator(function*() {
         try {
-            var _stack = [];
-            var d3 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d3 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
             yield null;
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     });
     return _af.apply(this, arguments);
 }
 function* g() {
     try {
-        var _stack = [];
-        var d4 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d4 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function ag() {
@@ -57,404 +53,375 @@ function ag() {
 function _ag() {
     _ag = _wrap_async_generator(function*() {
         try {
-            var _stack = [];
-            var d5 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d5 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
             yield;
             yield _await_async_generator(null);
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     });
     return _ag.apply(this, arguments);
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.u({
         [Symbol.dispose] () {}
     });
-    var a = ()=>{
+    const a = ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     };
     class C1 {
         m() {
             try {
-                var _stack = [];
-                var d10 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d10 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                var d11 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d11 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 return 0;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                var d12 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d12 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         am() {
             return _async_to_generator(function*() {
                 try {
-                    var _stack = [];
-                    var d13 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d13 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                     yield null;
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             })();
         }
         *g() {
             try {
-                var _stack = [];
-                var d14 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d14 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         ag() {
             return _wrap_async_generator(function*() {
                 try {
-                    var _stack = [];
-                    var d15 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d15 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                     yield;
                     yield _await_async_generator(null);
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             })();
         }
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                var d8 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d8 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     (()=>{
         try {
-            var _stack = [];
-            var d9 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d9 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })();
     class C2 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d16 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d16 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C3 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d17 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d17 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
                 this.y = 1;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     var N;
     (function(N) {
         try {
-            var _stack = [];
-            var d18 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            var d18 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(N || (N = {}));
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            _dispose(_stack1, _error, _hasError);
+            _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                _dispose(_stack4, _error3, _hasError3);
+                _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            _dispose(_stack8, _error7, _hasError7);
+            _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            _dispose(_stack9, _error8, _hasError8);
+            _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            _dispose(_stack10, _error9, _hasError9);
+            _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            _dispose(_stack11, _error10, _hasError10);
+            _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            _dispose(_stack12, _error11, _hasError11);
+            _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            _dispose(_stack13, _error12, _hasError12);
+            _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2015).2.minified.js

@@ -2,179 +2,178 @@
 import "@swc/helpers/_/_async_to_generator";
 import "@swc/helpers/_/_await_async_generator";
 import "@swc/helpers/_/_wrap_async_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var N, _stack = [];
-    _using(_stack, {
+    var N, _usingCtx = _using_ctx();
+    _usingCtx.u({
         [Symbol.dispose] () {}
     }), (()=>{
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(), function(N) {
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(N || (N = {}));
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        _dispose(_stack1, _error, _hasError);
+        _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        _dispose(_stack4, _error3, _hasError3);
+        _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        _dispose(_stack8, _error7, _hasError7);
+        _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        _dispose(_stack10, _error9, _hasError9);
+        _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        _dispose(_stack11, _error10, _hasError10);
+        _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        _dispose(_stack12, _error11, _hasError11);
+        _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        _dispose(_stack13, _error12, _hasError12);
+        _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        _dispose(_stack14, _error13, _hasError13);
+        _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2017).1.normal.js

@@ -1,441 +1,408 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var d2 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d2 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function* g() {
     try {
-        var _stack = [];
-        var d4 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d4 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.u({
         [Symbol.dispose] () {}
     });
-    var a = ()=>{
+    const a = ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     };
     class C1 {
         m() {
             try {
-                var _stack = [];
-                var d10 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d10 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                var d11 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d11 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 return 0;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                var d12 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d12 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         *g() {
             try {
-                var _stack = [];
-                var d14 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d14 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                var d8 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d8 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     (()=>{
         try {
-            var _stack = [];
-            var d9 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d9 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })();
     class C2 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d16 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d16 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C3 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d17 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d17 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
                 this.y = 1;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     var N;
     (function(N) {
         try {
-            var _stack = [];
-            var d18 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            var d18 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(N || (N = {}));
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            _dispose(_stack1, _error, _hasError);
+            _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                _dispose(_stack4, _error3, _hasError3);
+                _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            _dispose(_stack8, _error7, _hasError7);
+            _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            _dispose(_stack9, _error8, _hasError8);
+            _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            _dispose(_stack10, _error9, _hasError9);
+            _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            _dispose(_stack11, _error10, _hasError10);
+            _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            _dispose(_stack12, _error11, _hasError11);
+            _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            _dispose(_stack13, _error12, _hasError12);
+            _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2017).2.minified.js

@@ -1,177 +1,176 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var N, _stack = [];
-    _using(_stack, {
+    var N, _usingCtx = _using_ctx();
+    _usingCtx.u({
         [Symbol.dispose] () {}
     }), (()=>{
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(), function(N) {
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(N || (N = {}));
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        _dispose(_stack1, _error, _hasError);
+        _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        _dispose(_stack4, _error3, _hasError3);
+        _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        _dispose(_stack8, _error7, _hasError7);
+        _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        _dispose(_stack10, _error9, _hasError9);
+        _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        _dispose(_stack11, _error10, _hasError10);
+        _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        _dispose(_stack12, _error11, _hasError11);
+        _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        _dispose(_stack13, _error12, _hasError12);
+        _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        _dispose(_stack14, _error13, _hasError13);
+        _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2022).1.normal.js

@@ -1,441 +1,408 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var d2 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d2 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function* g() {
     try {
-        var _stack = [];
-        var d4 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d4 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.u({
         [Symbol.dispose] () {}
     });
-    var a = ()=>{
+    const a = ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     };
     class C1 {
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                var d8 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d8 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         static{
             try {
-                var _stack = [];
-                var d9 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d9 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         m() {
             try {
-                var _stack = [];
-                var d10 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d10 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                var d11 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d11 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 return 0;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                var d12 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d12 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         *g() {
             try {
-                var _stack = [];
-                var d14 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d14 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C2 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d16 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d16 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C3 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d17 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d17 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
                 this.y = 1;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     var N;
     (function(N) {
         try {
-            var _stack = [];
-            var d18 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            var d18 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(N || (N = {}));
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            _dispose(_stack1, _error, _hasError);
+            _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                _dispose(_stack4, _error3, _hasError3);
+                _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            _dispose(_stack8, _error7, _hasError7);
+            _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            _dispose(_stack9, _error8, _hasError8);
+            _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            _dispose(_stack10, _error9, _hasError9);
+            _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            _dispose(_stack11, _error10, _hasError10);
+            _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            _dispose(_stack12, _error11, _hasError11);
+            _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            _dispose(_stack13, _error12, _hasError12);
+            _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.1(target=es2022).2.minified.js

@@ -1,277 +1,276 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var N, _stack = [];
-    _using(_stack, {
+    var N, _usingCtx = _using_ctx();
+    _usingCtx.u({
         [Symbol.dispose] () {}
     });
     class C1 {
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _, _hasError = !0;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         static{
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         m() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                return _using(_stack, {
+                var _usingCtx = _using_ctx();
+                return _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), 0;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async am() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), await null;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         *g() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), yield;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), yield, await null;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     !function(N) {
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(N || (N = {}));
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        _dispose(_stack1, _error, _hasError);
+        _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        _dispose(_stack4, _error3, _hasError3);
+        _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        _dispose(_stack8, _error7, _hasError7);
+        _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        _dispose(_stack10, _error9, _hasError9);
+        _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        _dispose(_stack11, _error10, _hasError10);
+        _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        _dispose(_stack12, _error11, _hasError11);
+        _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        _dispose(_stack13, _error12, _hasError12);
+        _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        _dispose(_stack14, _error13, _hasError13);
+        _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.1(target=es5).1.normal.js

@@ -9,17 +9,15 @@ import { _ as _possible_constructor_return } from "@swc/helpers/_/_possible_cons
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
 import { _ as _create_super } from "@swc/helpers/_/_create_super";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var d2 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx = _using_ctx();
+        var d2 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function af() {
@@ -27,7 +25,7 @@ function af() {
 }
 function _af() {
     _af = _async_to_generator(function() {
-        var _stack, d3, _, _error, _hasError;
+        var _usingCtx, d3, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -37,8 +35,8 @@ function _af() {
                         3,
                         4
                     ]);
-                    _stack = [];
-                    d3 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                    _usingCtx = _using_ctx();
+                    d3 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                     return [
                         4,
                         null
@@ -51,14 +49,13 @@ function _af() {
                     ];
                 case 2:
                     _ = _state.sent();
-                    _error = _;
-                    _hasError = true;
+                    _usingCtx.e = _;
                     return [
                         3,
                         4
                     ];
                 case 3:
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                     return [
                         7
                     ];
@@ -72,7 +69,7 @@ function _af() {
     return _af.apply(this, arguments);
 }
 function g() {
-    var _stack, d4, _, _error, _hasError;
+    var _usingCtx, d4, _;
     return _ts_generator(this, function(_state) {
         switch(_state.label){
             case 0:
@@ -82,8 +79,8 @@ function g() {
                     3,
                     4
                 ]);
-                _stack = [];
-                d4 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                _usingCtx = _using_ctx();
+                d4 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                 return [
                     4
                 ];
@@ -95,14 +92,13 @@ function g() {
                 ];
             case 2:
                 _ = _state.sent();
-                _error = _;
-                _hasError = true;
+                _usingCtx.e = _;
                 return [
                     3,
                     4
                 ];
             case 3:
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
                 return [
                     7
                 ];
@@ -118,7 +114,7 @@ function ag() {
 }
 function _ag() {
     _ag = _wrap_async_generator(function() {
-        var _stack, d5, _, _error, _hasError;
+        var _usingCtx, d5, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -128,8 +124,8 @@ function _ag() {
                         4,
                         5
                     ]);
-                    _stack = [];
-                    d5 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                    _usingCtx = _using_ctx();
+                    d5 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                     return [
                         4
                     ];
@@ -147,14 +143,13 @@ function _ag() {
                     ];
                 case 3:
                     _ = _state.sent();
-                    _error = _;
-                    _hasError = true;
+                    _usingCtx.e = _;
                     return [
                         3,
                         5
                     ];
                 case 4:
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                     return [
                         7
                     ];
@@ -168,17 +163,16 @@ function _ag() {
     return _ag.apply(this, arguments);
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
     var a = function() {
         try {
-            var _stack = [];
-            var d6 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx = _using_ctx();
+            var d6 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     };
     var C1 = /*#__PURE__*/ function() {
@@ -187,40 +181,37 @@ try {
             _class_call_check(this, C1);
             this.a = function() {
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                    var _usingCtx = _using_ctx();
+                    var d7 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                var d8 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx = _using_ctx();
+                var d8 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         var _proto = C1.prototype;
         _proto.m = function m() {
             try {
-                var _stack = [];
-                var d10 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx = _using_ctx();
+                var d10 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         };
         _proto.am = function am() {
             return _async_to_generator(function() {
-                var _stack, d13, _, _error, _hasError;
+                var _usingCtx, d13, _;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -230,8 +221,8 @@ try {
                                 3,
                                 4
                             ]);
-                            _stack = [];
-                            d13 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                            _usingCtx = _using_ctx();
+                            d13 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                             return [
                                 4,
                                 null
@@ -244,14 +235,13 @@ try {
                             ];
                         case 2:
                             _ = _state.sent();
-                            _error = _;
-                            _hasError = true;
+                            _usingCtx.e = _;
                             return [
                                 3,
                                 4
                             ];
                         case 3:
-                            _dispose(_stack, _error, _hasError);
+                            _usingCtx.d();
                             return [
                                 7
                             ];
@@ -264,7 +254,7 @@ try {
             })();
         };
         _proto.g = function g() {
-            var _stack, d14, _, _error, _hasError;
+            var _usingCtx, d14, _;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -274,8 +264,8 @@ try {
                             3,
                             4
                         ]);
-                        _stack = [];
-                        d14 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                        _usingCtx = _using_ctx();
+                        d14 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                         return [
                             4
                         ];
@@ -287,14 +277,13 @@ try {
                         ];
                     case 2:
                         _ = _state.sent();
-                        _error = _;
-                        _hasError = true;
+                        _usingCtx.e = _;
                         return [
                             3,
                             4
                         ];
                     case 3:
-                        _dispose(_stack, _error, _hasError);
+                        _usingCtx.d();
                         return [
                             7
                         ];
@@ -307,7 +296,7 @@ try {
         };
         _proto.ag = function ag() {
             return _wrap_async_generator(function() {
-                var _stack, d15, _, _error, _hasError;
+                var _usingCtx, d15, _;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -317,8 +306,8 @@ try {
                                 4,
                                 5
                             ]);
-                            _stack = [];
-                            d15 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                            _usingCtx = _using_ctx();
+                            d15 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                             return [
                                 4
                             ];
@@ -336,14 +325,13 @@ try {
                             ];
                         case 3:
                             _ = _state.sent();
-                            _error = _;
-                            _hasError = true;
+                            _usingCtx.e = _;
                             return [
                                 3,
                                 5
                             ];
                         case 4:
-                            _dispose(_stack, _error, _hasError);
+                            _usingCtx.d();
                             return [
                                 7
                             ];
@@ -360,25 +348,23 @@ try {
                 key: "x",
                 get: function get() {
                     try {
-                        var _stack = [];
-                        var d11 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                        var _usingCtx = _using_ctx();
+                        var d11 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                         return 0;
                     } catch (_) {
-                        var _error = _;
-                        var _hasError = true;
+                        _usingCtx.e = _;
                     } finally{
-                        _dispose(_stack, _error, _hasError);
+                        _usingCtx.d();
                     }
                 },
                 set: function set(v) {
                     try {
-                        var _stack = [];
-                        var d12 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                        var _usingCtx = _using_ctx();
+                        var d12 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                     } catch (_) {
-                        var _error = _;
-                        var _hasError = true;
+                        _usingCtx.e = _;
                     } finally{
-                        _dispose(_stack, _error, _hasError);
+                        _usingCtx.d();
                     }
                 }
             }
@@ -387,13 +373,12 @@ try {
     }();
     (function() {
         try {
-            var _stack = [];
-            var d9 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx = _using_ctx();
+            var d9 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })();
     var C2 = /*#__PURE__*/ function(C1) {
@@ -404,14 +389,13 @@ try {
             _class_call_check(this, C2);
             var _this;
             try {
-                var _stack = [];
-                var d16 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx = _using_ctx();
+                var d16 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                 _this = _super.call(this);
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
             return _possible_constructor_return(_this);
         }
@@ -425,15 +409,14 @@ try {
             _class_call_check(this, C3);
             var _this;
             try {
-                var _stack = [];
-                var d17 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx = _using_ctx();
+                var d17 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
                 _this = _super.call(this);
                 _this.y = 1;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
             return _possible_constructor_return(_this);
         }
@@ -442,178 +425,162 @@ try {
     var N;
     (function(N) {
         try {
-            var _stack = [];
-            var d18 = _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx = _using_ctx();
+            var d18 = _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(N || (N = {}));
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx1 = _using_ctx();
+            var d19 = _usingCtx1.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            _dispose(_stack1, _error, _hasError);
+            _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx2 = _using_ctx();
+                var d20 = _usingCtx2.u(_define_property({}, Symbol.dispose, function() {}));
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx3 = _using_ctx();
+                var d21 = _usingCtx3.u(_define_property({}, Symbol.dispose, function() {}));
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx4 = _using_ctx();
+                var d22 = _usingCtx4.u(_define_property({}, Symbol.dispose, function() {}));
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                _dispose(_stack4, _error3, _hasError3);
+                _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx5 = _using_ctx();
+            var d23 = _usingCtx5.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx6 = _using_ctx();
+            var d24 = _usingCtx6.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx7 = _using_ctx();
+            var d25 = _usingCtx7.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx8 = _using_ctx();
+            var d26 = _usingCtx8.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            _dispose(_stack8, _error7, _hasError7);
+            _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx9 = _using_ctx();
+            var d27 = _usingCtx9.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            _dispose(_stack9, _error8, _hasError8);
+            _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx10 = _using_ctx();
+            var d28 = _usingCtx10.u(_define_property({}, Symbol.dispose, function() {}));
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            _dispose(_stack10, _error9, _hasError9);
+            _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx11 = _using_ctx();
+            var d29 = _usingCtx11.u(_define_property({}, Symbol.dispose, function() {}));
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            _dispose(_stack11, _error10, _hasError10);
+            _usingCtx11.d();
         }
     }while (true);
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx12 = _using_ctx();
+            var d30 = _usingCtx12.u(_define_property({}, Symbol.dispose, function() {}));
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            _dispose(_stack12, _error11, _hasError11);
+            _usingCtx12.d();
         }
     }
     for(var x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx13 = _using_ctx();
+            var d31 = _usingCtx13.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            _dispose(_stack13, _error12, _hasError12);
+            _usingCtx13.d();
         }
     }
     for(var _i = 0, _iter = []; _i < _iter.length; _i++){
         var x1 = _iter[_i];
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx14 = _using_ctx();
+            var d32 = _usingCtx14.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.1(target=es5).2.minified.js

@@ -9,150 +9,149 @@ import { _ as _possible_constructor_return } from "@swc/helpers/_/_possible_cons
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
 import { _ as _create_super } from "@swc/helpers/_/_create_super";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var N, _stack = [];
-    _using(_stack, _define_property({}, Symbol.dispose, function() {})), function() {
+    var N, _usingCtx = _using_ctx();
+    _usingCtx.u(_define_property({}, Symbol.dispose, function() {})), function() {
         try {
-            var _stack = [];
-            _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx = _using_ctx();
+            _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(), function(N) {
         try {
-            var _stack = [];
-            _using(_stack, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx = _using_ctx();
+            _usingCtx.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(N || (N = {}));
     try {
-        var _stack1 = [];
-        _using(_stack1, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.u(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        _dispose(_stack1, _error, _hasError);
+        _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.u(_define_property({}, Symbol.dispose, function() {}));
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, _define_property({}, Symbol.dispose, function() {}));
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.u(_define_property({}, Symbol.dispose, function() {}));
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.u(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        _dispose(_stack4, _error3, _hasError3);
+        _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch (e) {
         try {
-            var _stack6 = [];
-            _using(_stack6, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.u(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        _dispose(_stack8, _error7, _hasError7);
+        _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.u(_define_property({}, Symbol.dispose, function() {}));
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        _dispose(_stack10, _error9, _hasError9);
+        _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.u(_define_property({}, Symbol.dispose, function() {}));
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        _dispose(_stack11, _error10, _hasError10);
+        _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.u(_define_property({}, Symbol.dispose, function() {}));
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        _dispose(_stack12, _error11, _hasError11);
+        _usingCtx12.d();
     }
     for(var x in {})try {
-        var _stack13 = [];
-        _using(_stack13, _define_property({}, Symbol.dispose, function() {}));
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.u(_define_property({}, Symbol.dispose, function() {}));
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        _dispose(_stack13, _error12, _hasError12);
+        _usingCtx13.d();
     }
     for(var _i = 0, _iter = []; _i < _iter.length; _i++){
         _iter[_i];
         try {
-            var _stack14 = [];
-            _using(_stack14, _define_property({}, Symbol.dispose, function() {}));
+            var _usingCtx14 = _using_ctx();
+            _usingCtx14.u(_define_property({}, Symbol.dispose, function() {}));
         } catch (_) {
-            var _error13 = _, _hasError13 = !0;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.1(target=esnext).1.normal.js

@@ -1,441 +1,408 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 function f() {
     try {
-        var _stack = [];
-        var d2 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d2 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function af() {
     try {
-        var _stack = [];
-        var d3 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d3 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 function* g() {
     try {
-        var _stack = [];
-        var d4 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d4 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 async function* ag() {
     try {
-        var _stack = [];
-        var d5 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d5 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
         yield;
         await null;
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }
 try {
-    var _stack = [];
-    var d1 = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var d1 = _usingCtx.u({
         [Symbol.dispose] () {}
     });
-    var a = ()=>{
+    const a = ()=>{
         try {
-            var _stack = [];
-            var d6 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            const d6 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     };
     class C1 {
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    var d7 = _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    const d7 = _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _;
-                    var _hasError = true;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                var d8 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d8 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         static{
             try {
-                var _stack = [];
-                var d9 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d9 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         m() {
             try {
-                var _stack = [];
-                var d10 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d10 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                var d11 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d11 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 return 0;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                var d12 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d12 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async am() {
             try {
-                var _stack = [];
-                var d13 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d13 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         *g() {
             try {
-                var _stack = [];
-                var d14 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d14 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                var d15 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d15 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 yield;
                 await null;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C2 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d16 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d16 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     class C3 extends C1 {
         constructor(){
             try {
-                var _stack = [];
-                var d17 = _using(_stack, {
+                var _usingCtx = _using_ctx();
+                const d17 = _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
                 super();
                 this.y = 1;
             } catch (_) {
-                var _error = _;
-                var _hasError = true;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     var N;
     (function(N) {
         try {
-            var _stack = [];
-            var d18 = _using(_stack, {
+            var _usingCtx = _using_ctx();
+            var d18 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     })(N || (N = {}));
     {
         try {
-            var _stack1 = [];
-            var d19 = _using(_stack1, {
+            var _usingCtx1 = _using_ctx();
+            const d19 = _usingCtx1.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx1.e = _;
         } finally{
-            _dispose(_stack1, _error, _hasError);
+            _usingCtx1.d();
         }
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                var d20 = _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                const d20 = _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _;
-                var _hasError1 = true;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                var d21 = _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                const d21 = _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error2 = _;
-                var _hasError2 = true;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     if (true) switch(0){
         case 0:
             try {
-                var _stack4 = [];
-                var d22 = _using(_stack4, {
+                var _usingCtx4 = _using_ctx();
+                const d22 = _usingCtx4.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error3 = _;
-                var _hasError3 = true;
+                _usingCtx4.e = _;
             } finally{
-                _dispose(_stack4, _error3, _hasError3);
+                _usingCtx4.d();
             }
     }
     try {
         try {
-            var _stack5 = [];
-            var d23 = _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            const d23 = _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _;
-            var _hasError4 = true;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            var d24 = _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            const d24 = _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _;
-            var _hasError5 = true;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            var d25 = _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            const d25 = _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _;
-            var _hasError6 = true;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     if (true) {
         try {
-            var _stack8 = [];
-            var d26 = _using(_stack8, {
+            var _usingCtx8 = _using_ctx();
+            const d26 = _usingCtx8.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error7 = _;
-            var _hasError7 = true;
+            _usingCtx8.e = _;
         } finally{
-            _dispose(_stack8, _error7, _hasError7);
+            _usingCtx8.d();
         }
     } else {
         try {
-            var _stack9 = [];
-            var d27 = _using(_stack9, {
+            var _usingCtx9 = _using_ctx();
+            const d27 = _usingCtx9.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error8 = _;
-            var _hasError8 = true;
+            _usingCtx9.e = _;
         } finally{
-            _dispose(_stack9, _error8, _hasError8);
+            _usingCtx9.d();
         }
     }
     while(true){
         try {
-            var _stack10 = [];
-            var d28 = _using(_stack10, {
+            var _usingCtx10 = _using_ctx();
+            const d28 = _usingCtx10.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error9 = _;
-            var _hasError9 = true;
+            _usingCtx10.e = _;
         } finally{
-            _dispose(_stack10, _error9, _hasError9);
+            _usingCtx10.d();
         }
     }
     do {
         try {
-            var _stack11 = [];
-            var d29 = _using(_stack11, {
+            var _usingCtx11 = _using_ctx();
+            const d29 = _usingCtx11.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error10 = _;
-            var _hasError10 = true;
+            _usingCtx11.e = _;
         } finally{
-            _dispose(_stack11, _error10, _hasError10);
+            _usingCtx11.d();
         }
     }while (true)
     for(;;){
         try {
-            var _stack12 = [];
-            var d30 = _using(_stack12, {
+            var _usingCtx12 = _using_ctx();
+            const d30 = _usingCtx12.u({
                 [Symbol.dispose] () {}
             });
             break;
         } catch (_) {
-            var _error11 = _;
-            var _hasError11 = true;
+            _usingCtx12.e = _;
         } finally{
-            _dispose(_stack12, _error11, _hasError11);
+            _usingCtx12.d();
         }
     }
     for(const x in {}){
         try {
-            var _stack13 = [];
-            var d31 = _using(_stack13, {
+            var _usingCtx13 = _using_ctx();
+            const d31 = _usingCtx13.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error12 = _;
-            var _hasError12 = true;
+            _usingCtx13.e = _;
         } finally{
-            _dispose(_stack13, _error12, _hasError12);
+            _usingCtx13.d();
         }
     }
     for (const x of []){
         try {
-            var _stack14 = [];
-            var d32 = _using(_stack14, {
+            var _usingCtx14 = _using_ctx();
+            const d32 = _usingCtx14.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error13 = _;
-            var _hasError13 = true;
+            _usingCtx14.e = _;
         } finally{
-            _dispose(_stack14, _error13, _hasError13);
+            _usingCtx14.d();
         }
     }
 } catch (_) {
-    var _error14 = _;
-    var _hasError14 = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.1(target=esnext).2.minified.js

@@ -1,277 +1,276 @@
 //// [usingDeclarations.1.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var N, _stack = [];
-    _using(_stack, {
+    var N, _usingCtx = _using_ctx();
+    _usingCtx.u({
         [Symbol.dispose] () {}
     });
     class C1 {
         constructor(){
             this.a = ()=>{
                 try {
-                    var _stack = [];
-                    _using(_stack, {
+                    var _usingCtx = _using_ctx();
+                    _usingCtx.u({
                         [Symbol.dispose] () {}
                     });
                 } catch (_) {
-                    var _error = _, _hasError = !0;
+                    _usingCtx.e = _;
                 } finally{
-                    _dispose(_stack, _error, _hasError);
+                    _usingCtx.d();
                 }
             };
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         static{
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         m() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         get x() {
             try {
-                var _stack = [];
-                return _using(_stack, {
+                var _usingCtx = _using_ctx();
+                return _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), 0;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         set x(v) {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async am() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), await null;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         *g() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), yield;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
         async *ag() {
             try {
-                var _stack = [];
-                _using(_stack, {
+                var _usingCtx = _using_ctx();
+                _usingCtx.u({
                     [Symbol.dispose] () {}
                 }), yield, await null;
             } catch (_) {
-                var _error = _, _hasError = !0;
+                _usingCtx.e = _;
             } finally{
-                _dispose(_stack, _error, _hasError);
+                _usingCtx.d();
             }
         }
     }
     !function(N) {
         try {
-            var _stack = [];
-            _using(_stack, {
+            var _usingCtx = _using_ctx();
+            _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _, _hasError = !0;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }(N || (N = {}));
     try {
-        var _stack1 = [];
-        _using(_stack1, {
+        var _usingCtx1 = _using_ctx();
+        _usingCtx1.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _, _hasError = !0;
+        _usingCtx1.e = _;
     } finally{
-        _dispose(_stack1, _error, _hasError);
+        _usingCtx1.d();
     }
     switch(Math.random()){
         case 0:
             try {
-                var _stack2 = [];
-                _using(_stack2, {
+                var _usingCtx2 = _using_ctx();
+                _usingCtx2.u({
                     [Symbol.dispose] () {}
                 });
                 break;
             } catch (_) {
-                var _error1 = _, _hasError1 = !0;
+                _usingCtx2.e = _;
             } finally{
-                _dispose(_stack2, _error1, _hasError1);
+                _usingCtx2.d();
             }
         case 1:
             try {
-                var _stack3 = [];
-                _using(_stack3, {
+                var _usingCtx3 = _using_ctx();
+                _usingCtx3.u({
                     [Symbol.dispose] () {}
                 });
             } catch (_) {
-                var _error2 = _, _hasError2 = !0;
+                _usingCtx3.e = _;
             } finally{
-                _dispose(_stack3, _error2, _hasError2);
+                _usingCtx3.d();
             }
     }
     try {
-        var _stack4 = [];
-        _using(_stack4, {
+        var _usingCtx4 = _using_ctx();
+        _usingCtx4.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error3 = _, _hasError3 = !0;
+        _usingCtx4.e = _;
     } finally{
-        _dispose(_stack4, _error3, _hasError3);
+        _usingCtx4.d();
     }
     try {
         try {
-            var _stack5 = [];
-            _using(_stack5, {
+            var _usingCtx5 = _using_ctx();
+            _usingCtx5.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error4 = _, _hasError4 = !0;
+            _usingCtx5.e = _;
         } finally{
-            _dispose(_stack5, _error4, _hasError4);
+            _usingCtx5.d();
         }
     } catch  {
         try {
-            var _stack6 = [];
-            _using(_stack6, {
+            var _usingCtx6 = _using_ctx();
+            _usingCtx6.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error5 = _, _hasError5 = !0;
+            _usingCtx6.e = _;
         } finally{
-            _dispose(_stack6, _error5, _hasError5);
+            _usingCtx6.d();
         }
     } finally{
         try {
-            var _stack7 = [];
-            _using(_stack7, {
+            var _usingCtx7 = _using_ctx();
+            _usingCtx7.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error6 = _, _hasError6 = !0;
+            _usingCtx7.e = _;
         } finally{
-            _dispose(_stack7, _error6, _hasError6);
+            _usingCtx7.d();
         }
     }
     try {
-        var _stack8 = [];
-        _using(_stack8, {
+        var _usingCtx8 = _using_ctx();
+        _usingCtx8.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error7 = _, _hasError7 = !0;
+        _usingCtx8.e = _;
     } finally{
-        _dispose(_stack8, _error7, _hasError7);
+        _usingCtx8.d();
     }
     for(;;)try {
-        var _stack10 = [];
-        _using(_stack10, {
+        var _usingCtx10 = _using_ctx();
+        _usingCtx10.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error9 = _, _hasError9 = !0;
+        _usingCtx10.e = _;
     } finally{
-        _dispose(_stack10, _error9, _hasError9);
+        _usingCtx10.d();
     }
     for(;;)try {
-        var _stack11 = [];
-        _using(_stack11, {
+        var _usingCtx11 = _using_ctx();
+        _usingCtx11.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error10 = _, _hasError10 = !0;
+        _usingCtx11.e = _;
     } finally{
-        _dispose(_stack11, _error10, _hasError10);
+        _usingCtx11.d();
     }
     for(;;)try {
-        var _stack12 = [];
-        _using(_stack12, {
+        var _usingCtx12 = _using_ctx();
+        _usingCtx12.u({
             [Symbol.dispose] () {}
         });
         break;
     } catch (_) {
-        var _error11 = _, _hasError11 = !0;
+        _usingCtx12.e = _;
     } finally{
-        _dispose(_stack12, _error11, _hasError11);
+        _usingCtx12.d();
     }
     for(let x in {})try {
-        var _stack13 = [];
-        _using(_stack13, {
+        var _usingCtx13 = _using_ctx();
+        _usingCtx13.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error12 = _, _hasError12 = !0;
+        _usingCtx13.e = _;
     } finally{
-        _dispose(_stack13, _error12, _hasError12);
+        _usingCtx13.d();
     }
     for (let x of [])try {
-        var _stack14 = [];
-        _using(_stack14, {
+        var _usingCtx14 = _using_ctx();
+        _usingCtx14.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error13 = _, _hasError13 = !0;
+        _usingCtx14.e = _;
     } finally{
-        _dispose(_stack14, _error13, _hasError13);
+        _usingCtx14.d();
     }
 } catch (_) {
-    var _error14 = _, _hasError14 = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error14, _hasError14);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.11.1.normal.js

@@ -3,8 +3,7 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _inherits } from "@swc/helpers/_/_inherits";
 import { _ as _possible_constructor_return } from "@swc/helpers/_/_possible_constructor_return";
 import { _ as _create_super } from "@swc/helpers/_/_create_super";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 var A = function A() {
     "use strict";
     _class_call_check(this, A);
@@ -17,14 +16,13 @@ var C1 = /*#__PURE__*/ function(A) {
         _class_call_check(this, C1);
         var _this;
         try {
-            var _stack = [];
-            var x = _using(_stack, null);
+            var _usingCtx = _using_ctx();
+            var x = _usingCtx.u(null);
             _this = _super.call(this);
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
         return _possible_constructor_return(_this);
     }
@@ -38,14 +36,13 @@ var C2 = /*#__PURE__*/ function(A) {
         _class_call_check(this, C2);
         var _this;
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             _this = _super.call(this);
-            var x = _using(_stack, null);
+            var x = _usingCtx.u(null);
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
         return _possible_constructor_return(_this);
     }
@@ -59,15 +56,14 @@ var C3 = /*#__PURE__*/ function(A) {
         _class_call_check(this, C3);
         var _this;
         try {
-            var _stack = [];
-            var x = _using(_stack, null);
+            var _usingCtx = _using_ctx();
+            var x = _usingCtx.u(null);
             _this = _super.call(this);
             _this.y = 1;
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
         return _possible_constructor_return(_this);
     }
@@ -81,15 +77,14 @@ var C4 = /*#__PURE__*/ function(A) {
         _class_call_check(this, C4);
         var _this;
         try {
-            var _stack = [];
-            var x = _using(_stack, null);
+            var _usingCtx = _using_ctx();
+            var x = _usingCtx.u(null);
             _this = _super.call(this);
             _this.y = y;
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
         return _possible_constructor_return(_this);
     }
@@ -103,16 +98,15 @@ var C5 = /*#__PURE__*/ function(A) {
         _class_call_check(this, C5);
         var _this;
         try {
-            var _stack = [];
-            var x = _using(_stack, null);
+            var _usingCtx = _using_ctx();
+            var x = _usingCtx.u(null);
             _this = _super.call(this);
             _this.y = y;
             _this.z = 1;
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
         return _possible_constructor_return(_this);
     }

crates/swc/tests/tsc-references/usingDeclarations.11.2.minified.js

@@ -3,5 +3,4 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _inherits } from "@swc/helpers/_/_inherits";
 import { _ as _possible_constructor_return } from "@swc/helpers/_/_possible_constructor_return";
 import { _ as _create_super } from "@swc/helpers/_/_create_super";
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/usingDeclarations.12.1.normal.js

@@ -1,23 +1,21 @@
 //// [usingDeclarations.12.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 class C1 {
     constructor(){}
 }
 class C2 extends C1 {
     constructor(){
         try {
-            var _stack = [];
+            var _usingCtx = _using_ctx();
             super();
             this.y = 1;
-            var d17 = _using(_stack, {
+            const d17 = _usingCtx.u({
                 [Symbol.dispose] () {}
             });
         } catch (_) {
-            var _error = _;
-            var _hasError = true;
+            _usingCtx.e = _;
         } finally{
-            _dispose(_stack, _error, _hasError);
+            _usingCtx.d();
         }
     }
 }

crates/swc/tests/tsc-references/usingDeclarations.12.2.minified.js

@@ -1,3 +1,2 @@
 //// [usingDeclarations.12.ts]
-import "@swc/helpers/_/_dispose";
-import "@swc/helpers/_/_using";
+import "@swc/helpers/_/_using_ctx";

crates/swc/tests/tsc-references/usingDeclarations.14.1.normal.js

@@ -1,12 +1,10 @@
 //// [usingDeclarations.14.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    var x = _using(_stack, {});
+    var _usingCtx = _using_ctx();
+    var x = _usingCtx.u({});
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.14.2.minified.js

@@ -1,11 +1,10 @@
 //// [usingDeclarations.14.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {});
+    var _usingCtx = _using_ctx();
+    _usingCtx.u({});
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.15.1.normal.js

@@ -1,15 +1,13 @@
 //// [usingDeclarations.15.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    var _ = _using(_stack, {
+    var _usingCtx = _using_ctx();
+    var _ = _usingCtx.u({
         [Symbol.dispose] () {}
     });
 } catch (_) {
-    var _error = _;
-    var _hasError = true;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }
 export { };

crates/swc/tests/tsc-references/usingDeclarations.15.2.minified.js

@@ -1,13 +1,12 @@
 //// [usingDeclarations.15.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 try {
-    var _stack = [];
-    _using(_stack, {
+    var _usingCtx = _using_ctx();
+    _usingCtx.u({
         [Symbol.dispose] () {}
     });
 } catch (_) {
-    var _error = _, _hasError = !0;
+    _usingCtx.e = _;
 } finally{
-    _dispose(_stack, _error, _hasError);
+    _usingCtx.d();
 }

crates/swc/tests/tsc-references/usingDeclarations.2(target=es2015).1.normal.js

@@ -1,18 +1,16 @@
 //// [usingDeclarations.2.ts]
-import { _ as _dispose } from "@swc/helpers/_/_dispose";
-import { _ as _using } from "@swc/helpers/_/_using";
+import { _ as _using_ctx } from "@swc/helpers/_/_using_ctx";
 {
     try {
-        var _stack = [];
-        var d1 = _using(_stack, {
+        var _usingCtx = _using_ctx();
+        const d1 = _usingCtx.u({
             [Symbol.dispose] () {}
-        }), d2 = _using(_stack, {
+        }), d2 = _usingCtx.u({
             [Symbol.dispose] () {}
         });
     } catch (_) {
-        var _error = _;
-        var _hasError = true;
+        _usingCtx.e = _;
     } finally{
-        _dispose(_stack, _error, _hasError);
+        _usingCtx.d();
     }
 }