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

crates/swc_ecma_transforms_proposal/src/explicit_resource_management.rs

@@ -0,0 +1,11 @@
+use swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut};
+
+pub fn explicit_resource_management() -> impl Fold + VisitMut {
+    as_folder(ExplicitResourceManagement)
+}
+
+struct ExplicitResourceManagement;
+
+impl VisitMut for ExplicitResourceManagement {
+    noop_visit_mut_type!();
+}

crates/swc_ecma_transforms_proposal/src/lib.rs

@@ -8,5 +8,6 @@ pub use self::{
 
 pub mod decorator_2022_03;
 pub mod decorators;
+pub mod explicit_resource_management;
 mod export_default_from;
 mod import_assertions;

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/async-dispose-throws-synchronously.js

@@ -0,0 +1,22 @@
+return async function () {
+  let disposed = false;
+  let beforeEnd;
+
+  const err1 = {};
+  const err2 = {};
+  let thrown;
+
+  try {
+    await using x = {
+      [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        throw err1;
+      }
+    };
+    throw err2;
+  } catch (e) {
+    thrown = e;
+  }
+
+  expect(thrown.suppressed).toBe(err1);
+  expect(thrown.error).toBe(err2);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/completion-break.js

@@ -0,0 +1,17 @@
+return async function () {
+  let disposed = false;
+  let beforeBreak;
+
+  while (true) {
+    await using x = {
+      async [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        disposed = true;
+      }
+    };
+    beforeBreak = disposed;
+    break;
+  }
+
+  expect(beforeBreak).toBe(false);
+  expect(disposed).toBe(true);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/completion-normal.js

@@ -0,0 +1,16 @@
+return async function () {
+  let disposed = false;
+  let beforeEnd;
+
+  {
+    await using x = {
+      async [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        disposed = true;
+      }
+    };
+    beforeEnd = disposed;
+  }
+
+  expect(beforeEnd).toBe(false);
+  expect(disposed).toBe(true);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/completion-return.js

@@ -0,0 +1,17 @@
+return async function () {
+  let disposed = false;
+  let beforeReturn;
+
+  await async function () {
+    await using x = {
+      async [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        disposed = true;
+      }
+    };
+    beforeReturn = disposed;
+    return 0;
+  }();
+
+  expect(beforeReturn).toBe(false);
+  expect(disposed).toBe(true);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/completion-throw.js

@@ -0,0 +1,22 @@
+return async function () {
+  let disposed = false;
+  let beforeReturn;
+  let inCatch;
+  let inFinally;
+
+  try {
+    await using x = {
+      async [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        disposed = true;
+      }
+    };
+    beforeReturn = disposed;
+    throw 0;
+  } catch {
+    inCatch = disposed;
+  }
+
+  expect(beforeReturn).toBe(false);
+  expect(inCatch).toBe(true);
+  expect(disposed).toBe(true);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/invalid-not-a-function.js

@@ -0,0 +1,3 @@
+return expect(async function () {
+  await using foo = { [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]: 3 };
+}()).rejects.toThrow(TypeError);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/multiple.js

@@ -0,0 +1,20 @@
+return async function () {
+  let log = [];
+
+  function disposable(name){
+    return {
+      async [Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]() {
+        log.push(name);
+      }
+    };
+  }
+
+  {
+    await using x = disposable("x");
+    await using y = disposable("y"), z = disposable("z");
+    await using w = disposable("w");
+    log.push("body");
+  }
+
+  expect(log).toEqual(["body", "w", "z", "y", "x"]);
+}();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/options.json

@@ -0,0 +1,8 @@
+{
+  "plugins": [
+    "proposal-explicit-resource-management",
+    "transform-optional-catch-binding",
+    "transform-async-to-generator"
+  ],
+  "parserOpts": { "allowReturnOutsideFunction": true }
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/sync-async-mixed.js

@@ -0,0 +1,41 @@
+return (async function () {
+  let log = [];
+
+  function disposable(name, symbolName, cb){
+    return {
+      async [Symbol[symbolName] || Symbol.for("Symbol." + symbolName)]() {
+        log.push(name);
+        if (cb) cb();
+      }
+    };
+  }
+
+  let inBmicrotick = false;
+  let inBmicrotickWhileC = false;
+  let inBmicrotickWhileD = false;
+  let inBmicrotickWhileE = false;
+  {
+    using e = disposable("e", "dispose", () => {
+      inBmicrotickWhileE = inBmicrotick;
+    });
+    await using d = disposable("d", "asyncDispose", () => {
+      inBmicrotickWhileD = inBmicrotick;
+    });
+    using c = disposable("c", "dispose", () => {
+      inBmicrotickWhileC = inBmicrotick;
+    });
+    using b = disposable("b", "dispose", () => {
+      inBmicrotick = true;
+      Promise.resolve().then(() => {
+        inBmicrotick = false;
+      });
+    });
+    await using a = disposable("a", "asyncDispose");
+  }
+
+  expect(log).toEqual(["a", "b", "c", "d", "e"]);
+  expect(inBmicrotick).toBe(false);
+  expect(inBmicrotickWhileC).toBe(true);
+  expect(inBmicrotickWhileD).toBe(true);
+  expect(inBmicrotickWhileE).toBe(false);
+})();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/sync-fallback.js

@@ -0,0 +1,20 @@
+return (async function () {
+  let disposed = false;
+  let awaited = false;
+  let beforeEnd;
+  {
+    await using x = {
+      [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+        disposed = true;
+      }
+    };
+    beforeEnd = disposed;
+    Promise.resolve().then(() => {
+      awaited = true;
+    });
+  }
+
+  expect(beforeEnd).toBe(false);
+  expect(disposed).toBe(true);
+  expect(awaited).toBe(true);
+})();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-async/using-null.js

@@ -0,0 +1,3 @@
+return expect(async function () {
+  await using x = null;
+}()).resolves.toBeUndefined();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-break.js

@@ -0,0 +1,15 @@
+let disposed = false;
+let beforeBreak;
+
+while (true) {
+  using x = {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      disposed = true;
+    }
+  };
+  beforeBreak = disposed;
+  break;
+}
+
+expect(beforeBreak).toBe(false);
+expect(disposed).toBe(true);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-normal.js

@@ -0,0 +1,14 @@
+let disposed = false;
+let beforeEnd;
+
+{
+  using x = {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      disposed = true;
+    }
+  };
+  beforeEnd = disposed;
+}
+
+expect(beforeEnd).toBe(false);
+expect(disposed).toBe(true);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-return.js

@@ -0,0 +1,15 @@
+let disposed = false;
+let beforeReturn;
+
+(function () {
+  using x = {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      disposed = true;
+    }
+  };
+  beforeReturn = disposed;
+  return 0;
+})();
+
+expect(beforeReturn).toBe(false);
+expect(disposed).toBe(true);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-throw.js

@@ -0,0 +1,20 @@
+let disposed = false;
+let beforeReturn;
+let inCatch;
+let inFinally;
+
+try {
+  using x = {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      disposed = true;
+    }
+  };
+  beforeReturn = disposed;
+  throw 0;
+} catch {
+  inCatch = disposed;
+}
+
+expect(beforeReturn).toBe(false);
+expect(inCatch).toBe(true);
+expect(disposed).toBe(true);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/invalid-dispose-not-a-function.js

@@ -0,0 +1,3 @@
+expect(() => {
+  using foo = { [Symbol.dispose || Symbol.for("Symbol.dispose")]: 3 };
+}).toThrow(TypeError);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/invalid-not-object.js

@@ -0,0 +1,3 @@
+expect(() => {
+  using x = 2;
+}).toThrow(TypeError);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/multiple.js

@@ -0,0 +1,18 @@
+let log = [];
+
+function disposable(name){
+  return {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      log.push(name);
+    }
+  };
+}
+
+{
+  using x = disposable("x");
+  using y = disposable("y"), z = disposable("z");
+  using w = disposable("w");
+  log.push("body");
+}
+
+expect(log).toEqual(["body", "w", "z", "y", "x"]);

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": [
+    "proposal-explicit-resource-management",
+    "transform-optional-catch-binding"
+  ]
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/using-null.js

@@ -0,0 +1,4 @@
+expect(() => {
+  using x = null;
+  using y = undefined;
+}).not.toThrow();

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/integration/async-to-generator/input.js

@@ -0,0 +1,7 @@
+async function fn() {
+  await 0;
+  {
+    await using x = y;
+    await 1;
+  }
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/integration/async-to-generator/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": [
+    "proposal-explicit-resource-management",
+    "transform-async-to-generator"
+  ]
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/integration/async-to-generator/output.js

@@ -0,0 +1,19 @@
+function fn() {
+  return _fn.apply(this, arguments);
+}
+function _fn() {
+  _fn = babelHelpers.asyncToGenerator(function* () {
+    yield 0;
+    try {
+      var _stack = [];
+      const x = babelHelpers.using(_stack, y, true);
+      yield 1;
+    } catch (_) {
+      var _error = _;
+      var _hasError = true;
+    } finally {
+      yield babelHelpers.dispose(_stack, _error, _hasError);
+    }
+  });
+  return _fn.apply(this, arguments);
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["proposal-explicit-resource-management"]
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/mixed/input.js

@@ -0,0 +1,5 @@
+{
+  using a = 1;
+  await using b = 2;
+  using c = 3;
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/mixed/output.mjs

@@ -0,0 +1,11 @@
+try {
+  var _stack = [];
+  const a = babelHelpers.using(_stack, 1);
+  const b = babelHelpers.using(_stack, 2, true);
+  const c = babelHelpers.using(_stack, 3);
+} catch (_) {
+  var _error = _;
+  var _hasError = true;
+} finally {
+  await babelHelpers.dispose(_stack, _error, _hasError);
+}

crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/only-using-await/input.js

@@ -0,0 +1,6 @@
+{
+  await using x = obj;
+  stmt;
+  await using y = obj, z = obj;
+  doSomethingWith(x, y);
+}