Back-to-back match blocks causes error[internal]: left behind trailing whitespace

[betseg]

Having back-to-back match blocks causes this problem:

fn func<F: Fn(u8) -> u8>(f: F) -> u8 {
    f(0)
}

fn main() {
    func(|x| 
        match x {
            x => x,
        } + match x {
            x => x,
        }
    );
}

results in

error[internal]: left behind trailing whitespace
 --> /playground/src/main.rs:6:6:13
  |
6 |     func(|x| 
  |             ^
  |

warning: rustfmt has failed to format. See previous 1 errors.

[ytmimi]

Looks like this may also be related to / a duplicate of #3203 as they both have to do with a single binary expression in a closure.

[ytmimi]

I did some more digging, and I think this particular issue is caused because we don't let binary expression get formatted over multiple lines

In this case we don't format the body of the closure at all, which results in the whitespace from the input snippet not being removed.

for anyone interested in working on this, here are the formatting rules for closures that need to be adhered to.

We could probably add a match arm for ast::ExprKind::Binary and check if the lhs and the rhs of the binary expression are both allowed to be formatted over multiple lines.

Here's an example that compiles and reproduces the issue:

fn func<F: Fn(usize) -> usize>(f: F) -> usize{
    f(0)
}

fn main() {
    let _result = func(|x|  
        match x {
            _ => 0,
        } + match 1 {
            _ => 1,
        }
    );
}

---

As a side note, one might also be tempted to solve this issue by wrapping the closure in a block, but because of some rules defined in the rustc parser we can't wrap the closure in a block for certain lhs expressions.