match arm grouping with | can make it hard to distinguish groups of arms

[nikomatsakis]

rustfmt renders the following match as it is shown:

fn foo() {
        match *self {
            NotInRegistry(..) |
            FailedToDownload(..) |
            TestFail(..) |
            BuildFail(..) => None,
            FailedToDownload(_, ref e) => Some(&**e),
        }
}

Personally, I find that it is visually challenging to identify the "groups" of arms here. This would be even more true if (e.g.) BuildFail(..) were a longer pattern like BuildFail(ref a, SomeStruct { b, c }) etc. The problem is that then you have to scan pretty far to the right to find if there is a => or a |. I have definitely had cases in rustc where I thought the grouping was one thing but it was another.

I would prefer a newline after the =>:

fn foo() {
        match *self {
            NotInRegistry(..) |
            FailedToDownload(..) |
            TestFail(..) |
            BuildFail(..) =>
                None,
            FailedToDownload(_, ref e) =>
                Some(&**e),
        }
}

Or maybe, though it's not what I would do myself, a newline separating the groups:

fn foo() {
        match *self {
            NotInRegistry(..) |
            FailedToDownload(..) |
            TestFail(..) |
            BuildFail(..) => None,

            FailedToDownload(_, ref e) => Some(&**e),
        }
}

My rule of thumb is to put a newline after the => if there are | patterns involved (and also to try and put newlines after the => if any other groups of patterns have a newline), unless the expression is a block expression (=> {\n).

I am not really familiar with the totality of the match heuristics involved in rustfmt so I can't say how this fits in.

[jethrogb]

This is #490

[nrc]

Closing as a dup of #490, and note that the fmt-rfcs repo is probably the best place to discuss this.