`function(a) {};` changed into `(function(a) {})` even when AST does not change

The following test case

```
import assert from "assert";
import * as recast from "recast";
import {EOL as eol} from "os";

it("should keep unmodified function as is", function () {
const code = ["const a = b => function(a) {};"].join(eol);

const ast = recast.parse(code);

assert.strictEqual(
recast.print(ast).code,
["const a = b => function(a) {};"].join(eol),
);
});
```

produces

```
Expected value to strictly be equal to:
"const a = b => function(a) {};"
Received:
"const a = b => (function(a) {});"
```

for me. From what I understand, recast does not change unmodified code - is this a special case where it's different, or a legit bug?

Use the provided test case as a regression test and trace the recast.parse and recast.print entry points for this function expression. The issue is done when printing the unchanged AST preserves `function(a) {};` rather than adding parentheses, and the regression test passes.

Written by the indexing model from the issue text.