Rule proposal: `no-implicit-return-on-newline`

When does this rule warn? Please describe and show example code:

This rules checks that ES6 arrow functions that use implicit return do so on the same line as their parameters.

Correct:

// ex 1
someArray.map((value, index) => value + 1);

// ex 2
processAsync()
  .then(result => result
    .moreAsync()
    .then(final => Object.assign({}, final, { foo: 'bar' })));

Incorrect:

// ex 1
someArray.map((value, index) =>
  value + 1);

// ex 2
processAsync()
  .then(result =>
    result
      .moreAsync()
      .then(final =>
        Object.assign({}, final, { foo: 'bar' })));

Is this rule preventing an error or is it stylistic?

Purely stylistic. I find it much easier to process source-code if I can assume that same-line arrow-functions return and code blocks will explicitly return.

Why is this rule a candidate for inclusion instead of creating a custom rule?

This would benefit to any JS developers who also find it easier this way.

Are you willing to create the rule yourself?

Yes, if the rule makes sense to others.

[platinumazure]

Could you please refine your incorrect example so it would parse successfully? (You’re missing a trailing parenthesis)

[nzakas]

Unfortunately, it looks like consensus couldn’t be reached on this issue and so I’m closing it. While we wish we’d be able to accommodate everyone’s requests, we do need to prioritize. We’ve found that issues failing to reach consensus after 21 days tend never to reach consensus, and as such, we close those issues. This doesn’t mean the idea isn’t interesting, just that it’s not something the team can commit to.