file-lines can't partially format trait bounds lists

[randomPoison]

If I have a long list of trait bounds in a generic params list, I'd expect to be able to use the --file-lines option to format part of that list without affecting other parts of the function signature (or whatever the surrounding context is). But right now if any attempt to partially format the bounds list will cause the entire list to be reformatted, potentially pulling it all onto one line, modifying unselected lines in the process.

Summary

Consider the following code, where there's a long list of trait bounds and a couple of them are misaligned:

fn whatever<
    A: Clone
        + Copy
        + Debug
        + Display
    + PartialEq
    + Eq
        + PartialOrd
        + Ord
        + Hash,
>() {
}

I would like to use --file-lines to format just lines 6-7 to pull the two misaligned trait bounds in line with the rest, but not otherwise reformat the list.

Expected behavior

fn whatever<
    A: Clone
        + Copy
        + Debug
        + Display
        + PartialEq
        + Eq
        + PartialOrd
        + Ord
        + Hash,
>() {
}

Actual behavior

fn whatever<A: Clone + Copy + Debug + Display + PartialEq + Eq + PartialOrd + Ord + Hash>() {}

Note that because of #6868 the entire function signature is getting reformatted to one line. If that issue were fixed, the output here would look more like the following, where just the bounds list gets reformatted:

fn whatever<
    A: Clone + Copy + Debug + Display + PartialEq + Eq + PartialOrd + Ord + Hash,
>() {
}

That highlights the more fundamental issue here, that the logic for laying out the trait bounds list doesn't account for --file-lines and so can pull everything onto one line, modifying unselected lines in the process.

Configuration

rustfmt cli options used:

rustfmt --unstable-features --file-lines '[{"file":"test.rs","range":[6,7]}]' test.rs

Meta

The relevant code is in join_bounds_inner, which currently doesn't check the --file-lines configuration at all.

There's a few related issues here due to --file-lines not being fully implemented:

• Right now any attempt to partially format a function signature will reformat the whole thing (tracked by file-lines can't partially format function signatures #6868), so in the example above we see the entire function get rewritten to a single line.
• Part of file-lines can't partially format where clauses #6872, which tracks partial formatting of where clauses. Fixing this issue is a requirement for fixing that one, since a where clause is made up of a list of trait bounds lists, but I think this is worth splitting off into its own issue because trait bounds lists can show up outside of where clauses.
• This might need to be added as a blocker for [unstable option] file_lines #3397, though I think there's some room to discuss what the actual desired behavior is here, and that may mean this doesn't need to block stabilization.

[randomPoison]

I think there's a bit of subtlety here with regards to what the actual desired behavior is, so I want to leave some additional thoughts on that topic. The example in the issue description implies a couple of specific requirements:

• You have a bounds list that is spread across multiple lines. If the list is already all on one line, then there's no way to partially select it and it's fine to rewrite the whole list.
• Your bounds list is short enough that it could fit on one line. In the example in the description, if the list were longer such that it needs to overflow across multiple lines, then it wouldn't matter that the whole thing is being rewritten because the unselected parts of the list will end up in the same place.
• You have edited only part of the trait bounds list and want to fix just the part you edited, without reflowing the rest of the list, even if the list could now fit on one line. This could happen if you had a long list of bounds that was previously formatted across multiple lines, then you edit it to both remove a few bounds plus add a couple of new ones, such that the list is now short enough to fit on one line. In that case, you may select just the couple of bounds that you added and expect that it won't reflow the entire list.
• Your code is not fully formatted, such that you don't want to just auto-format the entire file. I think this point is generally the case if you're using --file-lines, though, since --file-lines implies that there are parts of the file that you don't want to format.

This is a very specific set of circumstances, which makes me wonder if it's a use case worth supporting. Alternatively, we could say that that you have to select the entire trait bounds list in order to reformat it, effectively saying we don't support partially formatting these. However, I'm inclined to say this is worth supporting, as it's similar to other cases where want to support partially formatting multi-line constructs, e.g. method chains (see #4053).