Simplify the special-case printing of single-param arrow functions (#13204)

* Simplify the special-case printing of single-param arrow functions

* Update test fixtures with single-param arrow functions

* Add some explicit snapshot tests for known edge-cases

packages/babel-generator/src/generators/methods.ts

@@ -112,32 +112,18 @@ export function ArrowFunctionExpression(
 
   const firstParam = node.params[0];
 
+  // Try to avoid printing parens in simple cases, but only if we're pretty
+  // sure that they aren't needed by type annotations or potential newlines.
   if (
+    !this.format.retainLines &&
+    // Auxiliary comments can introduce unexpected newlines
+    !this.format.auxiliaryCommentBefore &&
+    !this.format.auxiliaryCommentAfter &&
     node.params.length === 1 &&
     t.isIdentifier(firstParam) &&
-    !hasTypes(node, firstParam)
+    !hasTypesOrComments(node, firstParam)
   ) {
-    if (
-      (this.format.retainLines || node.async) &&
-      ((node.loc &&
-        node.body.loc &&
-        node.loc.start.line < node.body.loc.start.line) ||
-        firstParam.leadingComments?.length ||
-        firstParam.trailingComments?.length)
-    ) {
-      this.token("(");
-      if (firstParam.loc && firstParam.loc.start.line > node.loc.start.line) {
-        this.indent();
-        this.print(firstParam, node);
-        this.dedent();
-        this._catchUp("start", node.body.loc);
-      } else {
-        this.print(firstParam, node);
-      }
-      this.token(")");
-    } else {
-      this.print(firstParam, node);
-    }
+    this.print(firstParam, node);
   } else {
     this._params(node);
   }
@@ -151,12 +137,18 @@ export function ArrowFunctionExpression(
   this.print(node.body, node);
 }
 
-function hasTypes(node, param) {
-  return (
+function hasTypesOrComments(
+  node: t.ArrowFunctionExpression,
+  param: t.Identifier,
+): boolean {
+  return !!(
     node.typeParameters ||
     node.returnType ||
+    // @ts-expect-error
+    node.predicate ||
     param.typeAnnotation ||
     param.optional ||
-    param.trailingComments
+    param.leadingComments?.length ||
+    param.trailingComments?.length
   );
 }

packages/babel-generator/test/arrow-functions.js

@@ -0,0 +1,119 @@
+import generate from "../lib";
+import { parse } from "@babel/parser";
+
+describe("parameter parentheses", () => {
+  // Common source text for several snapshot tests
+  const source = `
+    () => {};
+    a => {};
+    (a, b) => {};
+    async () => {};
+    async a => {};
+    async (a, b) => {};
+  `;
+  // Apply a callback function to each parameter in the AST of the above source
+  function forEachParam(ast, callbackFn) {
+    ast.program.body.forEach(s => {
+      s.expression.params.forEach(p => {
+        callbackFn(p);
+      });
+    });
+  }
+
+  it("auxiliaryCommentBefore", () => {
+    const ast = parse(source);
+    forEachParam(ast, p => (p.loc = null));
+    const output = generate(ast, { auxiliaryCommentBefore: "BEFORE" }).code;
+    expect(output).toMatchInlineSnapshot(`
+      "() => {};
+
+      (
+      /*BEFORE*/
+      a) => {};
+
+      (
+      /*BEFORE*/
+      a,
+      /*BEFORE*/
+      b) => {};
+
+      async () => {};
+
+      async (
+      /*BEFORE*/
+      a) => {};
+
+      async (
+      /*BEFORE*/
+      a,
+      /*BEFORE*/
+      b) => {};"
+    `);
+  });
+  it("auxiliaryCommentAfter", () => {
+    const ast = parse(source);
+    forEachParam(ast, p => (p.loc = null));
+    const output = generate(ast, { auxiliaryCommentAfter: "AFTER" }).code;
+    expect(output).toMatchInlineSnapshot(`
+      "() => {};
+
+      (a
+      /*AFTER*/
+      ) => {};
+
+      (a
+      /*AFTER*/
+      , b
+      /*AFTER*/
+      ) => {};
+
+      async () => {};
+
+      async (a
+      /*AFTER*/
+      ) => {};
+
+      async (a
+      /*AFTER*/
+      , b
+      /*AFTER*/
+      ) => {};"
+    `);
+  });
+  it("empty leadingComments array", () => {
+    const ast = parse(source);
+    forEachParam(ast, p => (p.leadingComments = []));
+    const output = generate(ast).code;
+    expect(output).toMatchInlineSnapshot(`
+      "() => {};
+
+      a => {};
+
+      (a, b) => {};
+
+      async () => {};
+
+      async a => {};
+
+      async (a, b) => {};"
+    `);
+  });
+  it("empty trailingComments array", () => {
+    const ast = parse(source);
+    forEachParam(ast, p => (p.trailingComments = []));
+    const output = generate(ast).code;
+    expect(output).toMatchInlineSnapshot(`
+      "() => {};
+
+      a => {};
+
+      (a, b) => {};
+
+      async () => {};
+
+      async a => {};
+
+      async (a, b) => {};"
+    `);
+  });
+});

packages/babel-generator/test/fixtures/edgecase/single-arg-async-arrow-with-retainlines/output.js

@@ -1,11 +1,11 @@
 var fn = async (
-  arg
-) => {};
+arg) =>
+{};
 
 async (x) =>
 {};
 
-async x => {};
+async (x) => {};
 
 async (x) =>
 {};

packages/babel-generator/test/fixtures/flow/predicates/output.js

@@ -14,4 +14,4 @@ var f = (x: mixed): %checks => typeof x === "string";
 
 const foo2 = (x: mixed): boolean %checks => typeof x === "string";
 
-x: %checks => x !== null;
+(x): %checks => x !== null;

packages/babel-generator/test/fixtures/parentheses/async-arrow-function/output.js

@@ -1,8 +1,8 @@
 const x = async ( // some comment
-  a) => {
+a) => {
   return foo(await a);
 };
 
 function foo(a) {
   return a;
-}
+}

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-computed-key/output.js

@@ -1,7 +1,7 @@
 var _ref2;
 
 const {
-  [(_ref) => {
+  [_ref => {
     let rest = babelHelpers.extends({}, _ref);
     let b = babelHelpers.extends({}, {});
   }]: a,

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-default-value/output.js

@@ -1,7 +1,7 @@
 var _ref2;
 
 const {
-  a = (_ref) => {
+  a = _ref => {
     let rest = babelHelpers.extends({}, _ref);
     let b = babelHelpers.extends({}, {});
   },

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/parameters-object-rest-used-in-default/output.js

@@ -1,4 +1,4 @@
-(_ref) => {
+_ref => {
   let R = babelHelpers.extends({}, _ref);
   let a = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : R;
 };
@@ -32,7 +32,7 @@
   }();
 };
 
-(_ref6) => {
+_ref6 => {
   let R = babelHelpers.extends({}, _ref6);
   let a = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : f(R);
 };

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/regression/gh-4904/output.js

@@ -15,7 +15,7 @@ const _bar = bar(),
 
 const {
   a
-} = foo((_ref) => {
+} = foo(_ref => {
   let {
     b
   } = _ref,

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/regression/gh-8323/output.js

@@ -3,7 +3,7 @@ const get = () => {
   return 3;
 };
 
-const f = (_ref) => {
+const f = _ref => {
   let {
     a = get(),
     b

packages/babel-preset-env/test/fixtures/bugfixes/_esmodules-no-bugfixes/output.js

@@ -1,5 +1,5 @@
 // Edge
-(_ref) => {
+_ref => {
   var {
     x = 2
   } = _ref;

packages/babel-preset-env/test/fixtures/bugfixes/edge-default-params-chrome-40/output.js

@@ -1,4 +1,4 @@
-(_ref) => {
+_ref => {
   var {
     x = 2
   } = _ref;

packages/babel-preset-env/test/fixtures/bugfixes/edge-default-params-edge-14/output.js

@@ -1,4 +1,4 @@
-(_ref) => {
+_ref => {
   let _ref$x = _ref.x,
       x = _ref$x === void 0 ? 2 : _ref$x;
 };

packages/babel-preset-env/test/fixtures/bugfixes/edge-default-params-edge-17-no-bugfixes/output.js

@@ -1,4 +1,4 @@
-(_ref) => {
+_ref => {
   let {
     x = 2
   } = _ref;