Optimize transform-async-to-generator output

packages/babel-helper-remap-async-to-generator/src/index.ts

@@ -36,6 +36,7 @@ export default function (
     wrapAwait?: any;
   },
   noNewArrows?: boolean,
+  ignoreFunctionLength?: boolean,
 ) {
   path.traverse(awaitVisitor, {
     wrapAwait: helpers.wrapAwait,
@@ -46,7 +47,12 @@ export default function (
   path.node.async = false;
   path.node.generator = true;
 
-  wrapFunction(path, cloneNode(helpers.wrapAsync), noNewArrows);
+  wrapFunction(
+    path,
+    cloneNode(helpers.wrapAsync),
+    noNewArrows,
+    ignoreFunctionLength,
+  );
 
   const isProperty =
     path.isObjectMethod() ||

packages/babel-helper-wrap-function/src/index.ts

@@ -66,7 +66,12 @@ function classOrObjectMethod(
   ).unwrapFunctionEnvironment();
 }
 
-function plainFunction(path: NodePath<any>, callId: any, noNewArrows: boolean) {
+function plainFunction(
+  path: NodePath<any>,
+  callId: any,
+  noNewArrows: boolean,
+  ignoreFunctionLength: boolean,
+) {
   const node = path.node;
   const isDeclaration = path.isFunctionDeclaration();
   const functionId = node.id;
@@ -87,26 +92,26 @@ function plainFunction(path: NodePath<any>, callId: any, noNewArrows: boolean) {
   }
 
   const built = callExpression(callId, [node]);
+  const params = node.params.reduce(
+    (acc, param) => {
+      acc.done = acc.done || isAssignmentPattern(param) || isRestElement(param);
+
+      if (!acc.done) {
+        acc.params.push(path.scope.generateUidIdentifier("x"));
+      }
+
+      return acc;
+    },
+    {
+      params: [],
+      done: false,
+    },
+  ).params;
   const container = wrapper({
     NAME: functionId || null,
     REF: path.scope.generateUidIdentifier(functionId ? functionId.name : "ref"),
     FUNCTION: built,
-    PARAMS: node.params.reduce(
-      (acc, param) => {
-        acc.done =
-          acc.done || isAssignmentPattern(param) || isRestElement(param);
-
-        if (!acc.done) {
-          acc.params.push(path.scope.generateUidIdentifier("x"));
-        }
-
-        return acc;
-      },
-      {
-        params: [],
-        done: false,
-      },
-    ).params,
+    PARAMS: params,
   });
 
   if (isDeclaration) {
@@ -123,7 +128,11 @@ function plainFunction(path: NodePath<any>, callId: any, noNewArrows: boolean) {
       });
     }
 
-    if (!retFunction || retFunction.id || node.params.length) {
+    if (
+      !retFunction ||
+      retFunction.id ||
+      (!ignoreFunctionLength && params.length)
+    ) {
       // we have an inferred function id or params so we need this wrapper
       // @ts-expect-error todo(flow->ts) separate `wrapper` for `isDeclaration` and `else` branches
       path.replaceWith(container);
@@ -139,10 +148,11 @@ export default function wrapFunction(
   callId: any,
   // TODO(Babel 8): Consider defaulting to false for spec compliancy
   noNewArrows: boolean = true,
+  ignoreFunctionLength: boolean = false,
 ) {
   if (path.isMethod()) {
     classOrObjectMethod(path, callId);
   } else {
-    plainFunction(path, callId, noNewArrows);
+    plainFunction(path, callId, noNewArrows, ignoreFunctionLength);
   }
 }

packages/babel-plugin-transform-async-to-generator/src/index.ts

@@ -8,6 +8,7 @@ export default declare((api, options) => {
 
   const { method, module } = options;
   const noNewArrows = api.assumption("noNewArrows");
+  const ignoreFunctionLength = api.assumption("ignoreFunctionLength");
 
   if (method && module) {
     return {
@@ -24,7 +25,12 @@ export default declare((api, options) => {
             wrapAsync = state.methodWrapper = addNamed(path, method, module);
           }
 
-          remapAsyncToGenerator(path, { wrapAsync }, noNewArrows);
+          remapAsyncToGenerator(
+            path,
+            { wrapAsync },
+            noNewArrows,
+            ignoreFunctionLength,
+          );
         },
       },
     };
@@ -41,6 +47,7 @@ export default declare((api, options) => {
           path,
           { wrapAsync: state.addHelper("asyncToGenerator") },
           noNewArrows,
+          ignoreFunctionLength,
         );
       },
     },

packages/babel-plugin-transform-async-to-generator/test/fixtures/assumption-ignoreFunctionLength-true/basic/input.js

@@ -0,0 +1,7 @@
+async (x = 1) => 1;
+(async function (x = 2) {
+  return 2;
+})();
+
+foo(async (...x) => {});
+foo(async (...[...y]) => {});

packages/babel-plugin-transform-async-to-generator/test/fixtures/assumption-ignoreFunctionLength-true/basic/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": ["transform-async-to-generator"],
+  "assumptions": {
+    "ignoreFunctionLength": true
+  }
+}

packages/babel-plugin-transform-async-to-generator/test/fixtures/assumption-ignoreFunctionLength-true/basic/output.js

@@ -0,0 +1,9 @@
+/*#__PURE__*/
+babelHelpers.asyncToGenerator(function* (x = 1) {
+  return 1;
+});
+babelHelpers.asyncToGenerator(function* (x = 2) {
+  return 2;
+})();
+foo( /*#__PURE__*/babelHelpers.asyncToGenerator(function* (...x) {}));
+foo( /*#__PURE__*/babelHelpers.asyncToGenerator(function* (...[...y]) {}));

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/no-parameters-and-no-id/input.js

@@ -1,3 +1,11 @@
 foo(async function () {
 
 });
+
+bar(async function (x = 1) {
+
+});
+
+baz(async function (...y) {
+
+});

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/no-parameters-and-no-id/output.js

@@ -1 +1,5 @@
 foo( /*#__PURE__*/babelHelpers.asyncToGenerator(function* () {}));
+bar( /*#__PURE__*/babelHelpers.asyncToGenerator(function* () {
+  let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+}));
+baz( /*#__PURE__*/babelHelpers.asyncToGenerator(function* () {}));