Brocken parenthesizes around arrow function body when return an object

[coderaiser]

recast produces invalid code when babel used as a parser for such code, that returns an object:

before:

 const get = (a) => ({
    hello: 'world',
    'x': 'y',
});

after:

 const get = (a) => {
    hello: 'world',
    'x': 'y',
};

Which is invalid because has different meaning without parenthesizes, as a labeled series expressions without an end.

Can be reproduced using v0.20.2 with:

const babel = require('@babel/parser');
const generate = require('@babel/generator').default;
const recast = require('recast');
const traverse = require('@babel/traverse').default;

const source = `
    const get = (a) => ({
        hello: 'world',
        'x': 'y',
    });
`;

const babelAST = recast.parse(source, {
    parser: {
        parse: babel.parse,
    }
});

traverse(babelAST, {
    Identifier(path) {
        if (path.node.name === 'a')
            path.remove();
    }
});

console.log('recast:', recast.print(babelAST));
console.log('babel', generate(babelAST));

Output:

recast: PrintResult {
  code: "\n    const get = () => {\n        hello: 'world',\n        'x': 'y',\n    };\n"
}
babel {
  code: "const get = () => ({\n  hello: 'world',\n  'x': 'y'\n});",
  map: null,
  rawMappings: undefined
}

Can be related to #705
This can be fixed setting createParenthesizedExpressions:

const babelAST = recast.parse(source, {
    parser: {
        parse: () => {
            return babel.parse(source, {
                createParenthesizedExpressions: true
            });
        }
    }
});

But would be amazing if this option can be avoided, because it makes harder to traverse and compare AST nodes, because ParenthesizedExpressions adds an extra noise.

[gnprice]

This appears to have been fixed -- the example in the description no longer reproduces.

(Probably fixed by #1068: it looks like #1067 was a duplicate of this issue.)

[eventualbuddha]

Verified this no longer reproduces. Thanks for the nudge, @gnprice.