fix: upgrade swc and add back explicit resource management

Cargo.toml

@@ -51,21 +51,21 @@ unicode-width = "0.2.0"
 #
 # NOTE: You can automatically update these dependencies by running ./scripts/update_swc_deps.ts
 swc_atoms = "=5.0.0"
-swc_common = "=8.0.1"
+swc_common = "=8.1.0"
 swc_config = { version = "=2.0.0", optional = true }
 swc_config_macro = { version = "=1.0.0", optional = true }
-swc_ecma_ast = { version = "=8.1.0", features = ["serde-impl"] }
+swc_ecma_ast = { version = "=8.1.2", features = ["serde-impl"] }
 swc_ecma_codegen = { version = "=10.0.0", optional = true }
 swc_ecma_codegen_macros = { version = "=2.0.0", optional = true }
 swc_ecma_loader = { version = "=8.0.0", optional = true }
-swc_ecma_parser = "=11.0.0"
-swc_ecma_transforms_base = { version = "=12.0.0", optional = true }
+swc_ecma_parser = "=11.1.2"
+swc_ecma_transforms_base = { version = "=12.2.0", optional = true }
 swc_ecma_transforms_classes = { version = "=12.0.0", optional = true }
 swc_ecma_transforms_compat = { version = "=13.0.0", optional = true }
 swc_ecma_transforms_macros = { version = "=1.0.0", optional = true }
 swc_ecma_transforms_optimization = { version = "=12.0.0", optional = true }
-swc_ecma_transforms_proposal = { version = "=12.0.0", optional = true }
-swc_ecma_transforms_react = { version = "=13.0.0", optional = true }
+swc_ecma_transforms_proposal = { version = "=12.0.1", optional = true }
+swc_ecma_transforms_react = { version = "=13.0.1", optional = true }
 swc_ecma_transforms_typescript = { version = "=13.0.0", optional = true }
 swc_ecma_utils = { version = "=12.0.0", optional = true }
 swc_ecma_visit = { version = "=8.0.0", optional = true }

src/transpiling/mod.rs

@@ -633,10 +633,12 @@ impl DiagnosticCollector {
 }
 
 impl crate::swc::common::errors::Emitter for DiagnosticCollector {
-  fn emit(&mut self, db: &crate::swc::common::errors::DiagnosticBuilder<'_>) {
-    use std::ops::Deref;
+  fn emit(
+    &mut self,
+    db: &mut crate::swc::common::errors::DiagnosticBuilder<'_>,
+  ) {
     let mut diagnostics = self.diagnostics.lock();
-    diagnostics.push(db.deref().clone());
+    diagnostics.push(db.take());
   }
 }
 
@@ -678,6 +680,7 @@ pub fn fold_program<'a>(
       proposal::decorator_2022_03::decorator_2022_03(),
       options.use_decorators_proposal,
     ),
+    proposal::explicit_resource_management::explicit_resource_management(),
     helpers::inject_helpers(marks.top_level),
     // transform imports to var decls before doing the typescript pass
     // so that swc doesn't do any optimizations on the import declarations
@@ -982,6 +985,113 @@ var N;
     assert!(transpiled_source.source_map.is_none());
   }
 
+  #[test]
+  fn test_explicit_resource_management() {
+    let specifier =
+      ModuleSpecifier::parse("https://deno.land/x/mod.ts").unwrap();
+    let source = "using data = create();\nconsole.log(data);";
+    let program = parse_program(ParseParams {
+      specifier,
+      text: source.into(),
+      media_type: MediaType::TypeScript,
+      capture_tokens: false,
+      maybe_syntax: None,
+      scope_analysis: false,
+    })
+    .unwrap();
+    let transpiled_source = program
+      .transpile(
+        &TranspileOptions::default(),
+        &TranspileModuleOptions::default(),
+        &EmitOptions::default(),
+      )
+      .unwrap()
+      .into_source();
+    let expected_text = r#"function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value: value,
+      dispose: dispose,
+      async: async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+    function fail(e) {
+      env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+      env.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while(r = env.stack.pop()){
+        try {
+          if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+      if (env.hasError) throw env.error;
+    }
+    return next();
+  })(env);
+}
+const env = {
+  stack: [],
+  error: void 0,
+  hasError: false
+};
+try {
+  var data = _ts_add_disposable_resource(env, create(), false);
+  console.log(data);
+} catch (e) {
+  env.error = e;
+  env.hasError = true;
+} finally{
+  _ts_dispose_resources(env);
+}"#;
+    assert_eq!(
+      &transpiled_source.text[..expected_text.len()],
+      expected_text
+    );
+  }
+
   #[test]
   fn test_transpile_tsx() {
     let specifier =