feat(es/compat): Implement transform for explicit resource management

crates/swc_ecma_ast/src/decl.rs

@@ -175,15 +175,21 @@ impl Take for VarDeclarator {
 #[derive(Eq, Hash, EqIgnoreSpan)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct UsingDecl {
+    #[cfg_attr(feature = "serde-impl", serde(default))]
     pub span: Span,
 
+    #[cfg_attr(feature = "serde-impl", serde(default))]
+    pub is_await: bool,
+
+    #[cfg_attr(feature = "serde-impl", serde(default))]
     pub decls: Vec<VarDeclarator>,
 }
 
 impl Take for UsingDecl {
     fn dummy() -> Self {
         Self {
             span: DUMMY_SP,
+            is_await: Default::default(),
             decls: Take::dummy(),
         }
     }

crates/swc_ecma_codegen/src/decl.rs

@@ -38,6 +38,11 @@ where
     fn emit_using_decl(&mut self, node: &UsingDecl) -> Result {
         self.emit_leading_comments_of_span(node.span(), false)?;
 
+        if node.is_await {
+            keyword!("await");
+            space!();
+        }
+
         keyword!("using");
         space!();
 

crates/swc_ecma_parser/src/parser/class_and_fn.rs

@@ -586,6 +586,7 @@ impl<I: Tokens> Parser<I> {
         let body = self
             .with_ctx(Context {
                 in_class_field: true,
+                allow_using_decl: true,
                 ..self.ctx()
             })
             .parse_block(false)?;

crates/swc_ecma_parser/src/parser/stmt.rs

@@ -103,6 +103,7 @@ impl<'a, I: Tokens> Parser<I> {
 
         let ctx = Context {
             will_expect_colon_for_cond: false,
+            allow_using_decl: true,
             ..self.ctx()
         };
         self.with_ctx(ctx)
@@ -132,6 +133,15 @@ impl<'a, I: Tokens> Parser<I> {
                 self.emit_err(self.input.cur_span(), SyntaxError::TopLevelAwaitInScript);
             }
 
+            if peeked_is!(self, "using") {
+                assert_and_bump!(self, "await");
+
+                let v = self.parse_using_decl(start, true)?;
+                if let Some(v) = v {
+                    return Ok(Stmt::Decl(Decl::Using(v)));
+                }
+            }
+
             let expr = self.parse_await_expr()?;
             let expr = self
                 .include_in_expr(true)
@@ -154,6 +164,16 @@ impl<'a, I: Tokens> Parser<I> {
         }
 
         match cur!(self, true)? {
+            tok!("await") if include_decl => {
+                if peeked_is!(self, "using") {
+                    assert_and_bump!(self, "await");
+                    let v = self.parse_using_decl(start, true)?;
+                    if let Some(v) = v {
+                        return Ok(Stmt::Decl(Decl::Using(v)));
+                    }
+                }
+            }
+
             tok!("break") | tok!("continue") => {
                 let is_break = is!(self, "break");
                 bump!(self);
@@ -302,7 +322,7 @@ impl<'a, I: Tokens> Parser<I> {
             }
 
             tok!("using") if include_decl => {
-                let v = self.parse_using_decl()?;
+                let v = self.parse_using_decl(start, false)?;
                 if let Some(v) = v {
                     return Ok(Stmt::Decl(Decl::Using(v)));
                 }
@@ -762,7 +782,11 @@ impl<'a, I: Tokens> Parser<I> {
         }
     }
 
-    pub(super) fn parse_using_decl(&mut self) -> PResult<Option<Box<UsingDecl>>> {
+    pub(super) fn parse_using_decl(
+        &mut self,
+        start: BytePos,
+        is_await: bool,
+    ) -> PResult<Option<Box<UsingDecl>>> {
         // using
         // reader = init()
 
@@ -776,7 +800,6 @@ impl<'a, I: Tokens> Parser<I> {
             return Ok(None);
         }
 
-        let start = cur_pos!(self);
         assert_and_bump!(self, "using");
 
         let mut decls = vec![];
@@ -822,6 +845,7 @@ impl<'a, I: Tokens> Parser<I> {
 
         Ok(Some(Box::new(UsingDecl {
             span: span!(self, start),
+            is_await,
             decls,
         })))
     }
@@ -1278,6 +1302,7 @@ impl<'a, I: Tokens> Parser<I> {
 
             let pat = Box::new(UsingDecl {
                 span: span!(self, start),
+                is_await: false,
                 decls: vec![decl],
             });
 

crates/swc_ecma_quote_macros/src/ast/decl.rs

@@ -18,4 +18,4 @@ impl_struct!(ClassDecl, [ident, class]);
 impl_struct!(FnDecl, [ident, function]);
 impl_struct!(VarDecl, [span, kind, declare, decls]);
 impl_struct!(VarDeclarator, [span, name, init, definite]);
-impl_struct!(UsingDecl, [span, decls]);
+impl_struct!(UsingDecl, [span, is_await, decls]);

crates/swc_ecma_transforms_base/src/helpers/_dispose.js

@@ -0,0 +1,45 @@
+/* @minVersion 7.22.0 */
+function dispose_SuppressedError(suppressed, error) {
+    if (typeof SuppressedError !== "undefined") {
+        // eslint-disable-next-line no-undef
+        dispose_SuppressedError = SuppressedError;
+    } else {
+        dispose_SuppressedError = function SuppressedError(suppressed, error) {
+            this.suppressed = suppressed;
+            this.error = error;
+            this.stack = new Error().stack;
+        };
+        dispose_SuppressedError.prototype = Object.create(Error.prototype, {
+            constructor: {
+                value: dispose_SuppressedError,
+                writable: true,
+                configurable: true,
+            },
+        });
+    }
+    return new dispose_SuppressedError(suppressed, error);
+}
+
+function _dispose(stack, error, hasError) {
+    function next() {
+        while (stack.length > 0) {
+            try {
+                var r = stack.pop();
+                var p = r.d.call(r.v);
+                if (r.a) return Promise.resolve(p).then(next, err);
+            } catch (e) {
+                return err(e);
+            }
+        }
+        if (hasError) throw error;
+    }
+
+    function err(e) {
+        error = hasError ? new dispose_SuppressedError(e, error) : e;
+        hasError = true;
+
+        return next();
+    }
+
+    return next();
+}

crates/swc_ecma_transforms_base/src/helpers/_using.js

@@ -0,0 +1,21 @@
+function _using(stack, value, isAwait) {
+    if (value === null || value === void 0) return value;
+    if (typeof value !== "object") {
+        throw new TypeError(
+            "using declarations can only be used with objects, null, or undefined."
+        );
+    }
+    // core-js-pure uses Symbol.for for polyfilling well-known symbols
+    if (isAwait) {
+        var dispose =
+            value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
+    }
+    if (dispose === null || dispose === void 0) {
+        dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
+    }
+    if (typeof dispose !== "function") {
+        throw new TypeError(`Property [Symbol.dispose] is not a function.`);
+    }
+    stack.push({ v: value, d: dispose, a: isAwait });
+    return value;
+}

crates/swc_ecma_transforms_base/src/helpers/mod.rs

@@ -381,6 +381,8 @@ define_helpers!(Helpers {
 
     apply_decs_2203_r: (),
     identity: (),
+    dispose: (),
+    using: (),
 });
 
 pub fn inject_helpers(global_mark: Mark) -> impl Fold + VisitMut {