Parenthesize non-simple decorator expression (#14378)

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

@@ -113,9 +113,45 @@ export function Super(this: Printer) {
   this.word("super");
 }
 
+function isDecoratorMemberExpression(
+  node: t.Expression | t.V8IntrinsicIdentifier,
+) {
+  switch (node.type) {
+    case "Identifier":
+      return true;
+    case "MemberExpression":
+      return (
+        !node.computed &&
+        node.property.type === "Identifier" &&
+        isDecoratorMemberExpression(node.object)
+      );
+    default:
+      return false;
+  }
+}
+function shouldParenthesizeDecoratorExpression(
+  node: t.Expression | t.V8IntrinsicIdentifier,
+) {
+  if (node.type === "CallExpression") {
+    node = node.callee;
+  }
+  if (node.type === "ParenthesizedExpression") {
+    // We didn't check extra?.parenthesized here because we don't track decorators in needsParen
+    return false;
+  }
+  return !isDecoratorMemberExpression(node);
+}
+
 export function Decorator(this: Printer, node: t.Decorator) {
   this.token("@");
-  this.print(node.expression, node);
+  const { expression } = node;
+  if (shouldParenthesizeDecoratorExpression(expression)) {
+    this.token("(");
+    this.print(expression, node);
+    this.token(")");
+  } else {
+    this.print(expression, node);
+  }
   this.newline();
 }
 

packages/babel-generator/test/fixtures/decorators-legacy/ts-class-modifier-with-retainlines/options.json

@@ -1 +1,5 @@
-{ "plugins": ["classProperties", "decorators-legacy", "typescript"], "decoratorsBeforeExport": true, "retainLines": true }
+{
+  "plugins": ["decorators-legacy", "typescript"],
+  "decoratorsBeforeExport": true,
+  "retainLines": true
+}

packages/babel-generator/test/fixtures/decorators/decorator-call-expression/input.js

@@ -0,0 +1,6 @@
+class C {
+  @dec(0)
+  @globalThis.dec(0)
+  @(globalThis["dec"])(0)
+  p
+}

packages/babel-generator/test/fixtures/decorators/decorator-call-expression/output.js

@@ -0,0 +1,6 @@
+class C {
+  @dec(0)
+  @globalThis.dec(0)
+  @(globalThis["dec"](0))
+  p;
+}

packages/babel-generator/test/fixtures/decorators/decorator-member-expression/input.js

@@ -0,0 +1,6 @@
+class C {
+  @dec
+  @globalThis.dec
+  @globalThis.self.dec
+  p
+}

packages/babel-generator/test/fixtures/decorators/decorator-member-expression/output.js

@@ -0,0 +1,6 @@
+class C {
+  @dec
+  @globalThis.dec
+  @globalThis.self.dec
+  p;
+}

packages/babel-generator/test/fixtures/decorators/decorator-parenthesized-expression-createParenthesizedExpression/input.js

@@ -0,0 +1,30 @@
+class C extends class {} {
+  #x;
+  constructor() {
+    class ShouldPreserveParens {
+      @(decs[0])
+      @(decs`1`)
+      @(this?.two)
+      @(self.#x)
+      @(this.dec)
+      @(super.dec)
+      @(new DecFactory)
+      @(decs[three])()
+      p;
+    }
+
+    class ShouldNotAddParens {
+      @decs
+      @decs.one
+      @decs.two()
+      p;
+    }
+
+    class WillPreserveParens {
+      @(decs)
+      @(decs.one)
+      @(decs.two())
+      p;
+    }
+  }
+}

packages/babel-generator/test/fixtures/decorators/decorator-parenthesized-expression-createParenthesizedExpression/options.json

@@ -0,0 +1,5 @@
+{
+  "plugins": [["decorators", { "decoratorsBeforeExport": false }]],
+  "decoratorsBeforeExport": true,
+  "parserOpts": { "createParenthesizedExpressions": true }
+}

packages/babel-generator/test/fixtures/decorators/decorator-parenthesized-expression-createParenthesizedExpression/output.js

@@ -0,0 +1,32 @@
+class C extends class {} {
+  #x;
+
+  constructor() {
+    class ShouldPreserveParens {
+      @(decs[0])
+      @(decs`1`)
+      @(this?.two)
+      @(self.#x)
+      @(this.dec)
+      @(super.dec)
+      @(new DecFactory())
+      @(decs[three])()
+      p;
+    }
+
+    class ShouldNotAddParens {
+      @decs
+      @decs.one
+      @decs.two()
+      p;
+    }
+
+    class WillPreserveParens {
+      @(decs)
+      @(decs.one)
+      @(decs.two())
+      p;
+    }
+  }
+
+}

packages/babel-generator/test/fixtures/decorators/decorator-parenthesized-expression/input.js

@@ -0,0 +1,34 @@
+class C extends class {} {
+  #x;
+  constructor() {
+    class ShouldPreserveParens {
+      @(decs[0])
+      @(decs`1`)
+      @(this?.two)
+      @(self.#x)
+      @(this.dec)
+      @(super.dec)
+      @(new DecFactory)
+      p;
+    }
+
+    class ShouldNotAddParens {
+      @decs
+      @decs.one
+      @decs.two()
+      p;
+    }
+
+    class ShouldAddParens {
+      @(decs[three])()
+      p;
+    }
+
+    class ShouldRemoveParens {
+      @(decs)
+      @(decs.one)
+      @(decs.two())
+      p;
+    }
+  }
+}

packages/babel-generator/test/fixtures/decorators/decorator-parenthesized-expression/output.js

@@ -0,0 +1,36 @@
+class C extends class {} {
+  #x;
+
+  constructor() {
+    class ShouldPreserveParens {
+      @(decs[0])
+      @(decs`1`)
+      @(this?.two)
+      @(self.#x)
+      @(this.dec)
+      @(super.dec)
+      @(new DecFactory())
+      p;
+    }
+
+    class ShouldNotAddParens {
+      @decs
+      @decs.one
+      @decs.two()
+      p;
+    }
+
+    class ShouldAddParens {
+      @(decs[three]())
+      p;
+    }
+
+    class ShouldRemoveParens {
+      @decs
+      @decs.one
+      @decs.two()
+      p;
+    }
+  }
+
+}

packages/babel-generator/test/fixtures/decorators/options.json

@@ -1,9 +1,4 @@
 {
-  "plugins": [
-    ["decorators", { "decoratorsBeforeExport": false }],
-    "classProperties",
-    "classPrivateProperties",
-    "classPrivateMethods"
-  ],
+  "plugins": [["decorators", { "decoratorsBeforeExport": false }]],
   "decoratorsBeforeExport": true
 }

packages/babel-parser/src/parser/expression.js

@@ -1770,21 +1770,29 @@ export default class ExpressionParser extends LValParser {
       val = exprList[0];
     }
 
+    return this.wrapParenthesis(startPos, startLoc, val);
+  }
+
+  wrapParenthesis(
+    startPos: number,
+    startLoc: Position,
+    expression: N.Expression,
+  ): N.Expression {
     if (!this.options.createParenthesizedExpressions) {
-      this.addExtra(val, "parenthesized", true);
-      this.addExtra(val, "parenStart", startPos);
+      this.addExtra(expression, "parenthesized", true);
+      this.addExtra(expression, "parenStart", startPos);
 
       this.takeSurroundingComments(
-        val,
+        expression,
         startPos,
         this.state.lastTokEndLoc.index,
       );
 
-      return val;
+      return expression;
     }
 
     const parenExpression = this.startNodeAt(startPos, startLoc);
-    parenExpression.expression = val;
+    parenExpression.expression = expression;
     this.finishNode(parenExpression, "ParenthesizedExpression");
     return parenExpression;
   }

packages/babel-parser/src/parser/statement.js

@@ -539,9 +539,13 @@ export default class StatementParser extends ExpressionParser {
       const startLoc = this.state.startLoc;
       let expr: N.Expression;
 
-      if (this.eat(tt.parenL)) {
+      if (this.match(tt.parenL)) {
+        const startPos = this.state.start;
+        const startLoc = this.state.startLoc;
+        this.next(); // eat '('
         expr = this.parseExpression();
         this.expect(tt.parenR);
+        expr = this.wrapParenthesis(startPos, startLoc, expr);
       } else {
         expr = this.parseIdentifier(false);
 

packages/babel-parser/test/fixtures/experimental/decorators-2/invalid-unparenthesized-arrow/input.js

@@ -0,0 +1,3 @@
+class Foo {
+  @() => () => "bar" p;
+}

packages/babel-parser/test/fixtures/experimental/decorators-2/invalid-unparenthesized-arrow/options.json

@@ -0,0 +1,3 @@
+{
+  "throws": "Unexpected token (2:4)"
+}

packages/babel-parser/test/fixtures/experimental/decorators-2/nested-class-decorator/output.json

@@ -56,7 +56,11 @@
                     }
                   }
                 }
-              ]
+              ],
+              "extra": {
+                "parenthesized": true,
+                "parenStart": 1
+              }
             }
           }
         ],

packages/babel-parser/test/fixtures/experimental/decorators-2/nested-method-decorator/output.json

@@ -81,6 +81,10 @@
                           }
                         }
                       ]
+                    },
+                    "extra": {
+                      "parenthesized": true,
+                      "parenStart": 14
                     }
                   }
                 }

packages/babel-parser/test/fixtures/experimental/decorators-2/parenthesized-createParenthesizedExpressions/input.js

@@ -0,0 +1,8 @@
+@(foo().bar)
+class Foo {
+  @(member[expression]) method() {}
+
+  @(foo + bar) method2() {}
+
+  @(this.foo)(bar) method3() {}
+}

packages/babel-parser/test/fixtures/experimental/decorators-2/parenthesized-createParenthesizedExpressions/options.json

@@ -0,0 +1,4 @@
+{
+  "plugins": [["decorators", { "decoratorsBeforeExport": false }]],
+  "createParenthesizedExpressions": true
+}