Suggestion for an `IfLongLine` setting for `use_small_heuristic`

[Kiechant]

Currently, use_small_heuristic will wrap constructs vertically if they pass the maximum width for that particular construct, regardless of if the line is long enough to justify a wrap.

If feasible, it would be good to have an option to only apply the small heuristic on blocks of code that would pass the max width if no wrapping is applied. Suggesting the name IfLongLine.

[ytmimi]

@Kiechant Does use_small_heuristic=Max not do what you want?

Some examples of the wrapping behaviour you're describing would also be helpful.

[Kiechant]

Hi @ytmimi, no, I've noticed that when use_small_heuristics=Max, the lines which are wrapped are broken at the first construct which exceeds the line count.

I have some examples below. The code is longer than I hoped. It seems rustfmt has a minimum width before constructs are broken, meaning I struggled making small max_width examples <80 lines.

rustfmt.toml

max_width = 80
use_small_heuristics = "Default"

main.rs

#![allow(clippy::no_effect)]

struct Foo {
    bar: i64,
    baz: i64,
    bad: i64,
}

fn main() {
    let x = Foo {
        bar: 500,
        baz: 500,
        bad: 500,
    };

    let y = (1..20)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x);

    let z = (1..20)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| Foo {
            bar: 500,
            baz: 500,
            bad: 500,
        });
}

rustfmt.toml

max_width = 80
use_small_heuristics = "Max"

main.rs

fn main() {
    let x = Foo { bar: 500, baz: 500, bad: 500 };

    let y = (1..20).map(|x| x).map(|x| x).map(|x| x).map(|x| x).map(|x| x);

    let z = (1..20).map(|x| x).map(|x| x).map(|x| x).map(|x| x).map(|x| Foo {
        bar: 500,
        baz: 500,
        bad: 500,
    });
}

Expected behaviour with the IfLongLine suggestion:

fn main() {
    let x = Foo { bar: 500, baz: 500, bad: 500 };

    let y = (1..20).map(|x| x).map(|x| x).map(|x| x).map(|x| x).map(|x| x);

    let z = (1..20)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| Foo {
            bar: 500,
            baz: 500,
            bad: 500,
        });
}

It occurs to me my issue might not be so much with the small heuristics or max widths, but the precedence of line breaks, where a shallowest-first approach might be more appropriate, as follows:

fn main() {
    let x = Foo { bar: 500, baz: 500, bad: 500 };

    let y = (1..20).map(|x| x).map(|x| x).map(|x| x).map(|x| x).map(|x| x);

    let z = (1..20)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| x)
        .map(|x| Foo { bar: 500, baz: 500, bad: 500 });
}

However, I noticed I get the expected result when the line doesn't end with the struct but another smaller map operation. The following is also using use_small_heuristics=Max:

fn main() {
    let x = Foo { bar: 500, baz: 500, bad: 500 };

    let y = (1..20).map(|x| x).map(|x| x).map(|x| x).map(|x| x).map(|x| x);

    let zzzzzzzzzzzzzzzzzzzzzz = (1..20)
        .map(|x| x)
        .map(|x| Foo { bar: 500, baz: 500, bad: 500 })
        .map(|x| x);
}

[ytmimi]

Are you only concerned with chained method calls?

[Kiechant]

Not necessarily, but it's the only example I can think of at the moment.

I might experiment with this some more on the weekend.

[ytmimi]

Yes please provide other examples, because if it's just chains then this is a duplicate of #4306