Preserve parens around expressions in default export declaration that start with function or class

[duailibe]

Closes #6083

✨Try the playground for this PR✨

[thorn0]

It's not something specific to as-expressions. As per the spec, the same happens with other default-exported expressions whose first operand starts with one of these keywords: function, async function, class. So this is not TypeScript-specific. E.g., Babel doesn't parse this too:

Prettier 1.17.1
Playground link

--parser typescript

Input:

export default function log(){} * 2;

Output:

SyntaxError: Expression expected. (1:33)
> 1 | export default function log(){} * 2;
    |                                 ^
  2 | 

[duailibe]

@thorn0 Can you think of practical cases that aren't yet covered?

The one you mentioned is correct per the spec, but doesn't happen in practice because isn't valid in the runtime, so we shouldn't need to worry about that.

[thorn0]

It surely feels like a stretch, but still, I can imagine somebody doing things like these:

export default (function(){  /* ... */ }.toString());
export default (class WeirdSingleton { /* ... */ }.getInstance());

And don't forget about the upcoming pipeline operator. It totally makes sense for a function or a class expression to be its left-hand operand.

[duailibe]

Thanks @thorn0, those are more practical use cases.

Unfortunately because of the format of the AST it's a bit hard to detect when there's a function or class keyword in the start of the expression.

We do have some code to try and guess what is the "left most" node in an expression to add ASI protection. I'll see if we can reuse some of the code for that. Otherwise, we have to manually handle all possible cases.

[duailibe]

@lydell @thorn0 What do you think of this solution now?

[thorn0]

Tagged template literals get extra parens:

Prettier pr-6133
Playground link

--parser babylon

Input:

export default (function() {})`a`;

Output:

export default ((function() {})`a`);

[duailibe]

@thorn0 Thank you for testing!

Now it only wraps the expression being exported if the function/class isn't already wrapped.

[thorn0]

I wonder why these tests aren't run using babel.

[thorn0]

Why not use spread syntax here instead of apply and concat?

[thorn0]

Overall looks great, but I did manage to produce superfluous parens:

Prettier pr-6133
Playground link

--parser babel

Input:

export default (function(){} |> a)``;

Output:

export default ((function() {} |> a)``);

[duailibe]

@thorn0 Thanks for stress testing!

After years of Prettier this is the first bug report we've had, I think we're on the safe side now. From a practical point of view, we've covered enough cases IMO.