Option to preserve match alignment

[azerupi]

Some people like to align match arms for readability

match val {
    &TOMLValue::Integer(_)        => ArrayType::Integer,
    &TOMLValue::Float(_)          => ArrayType::Float,
    &TOMLValue::Boolean(_)        => ArrayType::Boolean,
    &TOMLValue::DateTime(_)       => ArrayType::DateTime,
    &TOMLValue::Array(_)          => ArrayType::Array,
    &TOMLValue::String(_,_)       => ArrayType::String,
    &TOMLValue::InlineTable(_)    => ArrayType::InlineTable,
    &TOMLValue::Table             => panic!("Cannot have a table in an array"),
 }

And currently it gets reformatted like this

match val {
    &TOMLValue::Integer(_) => ArrayType::Integer,
    &TOMLValue::Float(_) => ArrayType::Float,
    &TOMLValue::Boolean(_) => ArrayType::Boolean,
    &TOMLValue::DateTime(_) => ArrayType::DateTime,
    &TOMLValue::Array(_) => ArrayType::Array,
    &TOMLValue::String(_, _) => ArrayType::String,
    &TOMLValue::InlineTable(_) => ArrayType::InlineTable,
    &TOMLValue::Table => panic!("Cannot have a table in an array"),
}

It would be nice if rustfmt offered an option like match_align_arms that can have multiple values:

• Always: rustfmt will try to align all (non-block) match arms
• Preserve: rustfmt will preserve alignment if it is already aligned manually. For matches that are not already aligned, current behavior will be used.
• Never: current behavior

I think Preserve should be the default behavior.

/cc @joelself

[chris-morgan]

I would still expect Preserve/Always to remove three spaces on each line, to take the => as far to the left as it reasonably can:

match val {
    &TOMLValue::Integer(_)     => ArrayType::Integer,
    &TOMLValue::Float(_)       => ArrayType::Float,
    &TOMLValue::Boolean(_)     => ArrayType::Boolean,
    &TOMLValue::DateTime(_)    => ArrayType::DateTime,
    &TOMLValue::Array(_)       => ArrayType::Array,
    &TOMLValue::String(_,_)    => ArrayType::String,
    &TOMLValue::InlineTable(_) => ArrayType::InlineTable,
    &TOMLValue::Table          => panic!("Cannot have a table in an array"),
 }

(Aside: is rustfmt doing anything as advanced as turning match x { &A => ..., &B => ... } to match *x { A => ..., B => ... }? Another aside: TOMLValue should be TomlValue.)

The really fun question would be how it handles a situation like the following (imagine we just added InlineTable):

match *val {
    TomlValue::Integer(_)  => ArrayType::Integer,
    TomlValue::Float(_)    => ArrayType::Float,
    TomlValue::Boolean(_)  => ArrayType::Boolean,
    TomlValue::DateTime(_) => ArrayType::DateTime,
    TomlValue::Array(_)    => ArrayType::Array,
    TomlValue::String(_,_) => ArrayType::String,
    TomlValue::InlineTable(_) => ArrayType::InlineTable,
    TomlValue::Table       => panic!("Cannot have a table in an array"),
}

[nrc]

re aside: no. I'm keen to do some refactoring-ish changes, I'm not sure where to draw the line though.

[azerupi]

I would still expect Preserve/Always to remove three spaces on each line, to take the => as far to the left as it reasonably can

Absolutely, I just copy pasted the problematic code portion from a PR I made that ran rustfmt on someone else's repo. I didn't pay much attention to where the alignment began. It would indeed make a lot of sense to align as far left as possible.

The really fun question would be how it handles a situation like the following (imagine we just added InlineTable)

I think, for starters, it would be totally reasonable to let the burden be on the programmer. If he wants it aligned, he can do so manually with the guarantee that rustfmt will respect the alignment. (assuming config is set to "Preserve")

Later a "smarter" algorithm could be introduced to detect / guess if there was intent to align and format accordingly. It would be a nice addition but definitely not mandatory for this configuration option.

[joelself]

I only line up match arms sometimes (not even very consistently), so this isn't that important to me. And alining it to the left makes sense. I'm always torn between lining things up or not and if I line things up do I line it up all the way to the left for to the closest tab stop.

Another aside: TOMLValue should be TomlValue

Gah, and I worried so much over that. Is it a language standard? Man, I really don't want to have to make a breaking change to change the casing on a struct.

[stouset]

In general, preserving alignments like these (not just in match arms) would be super useful for rustfmt.

[barafael]

Is there anything new on this? I use tabular in vim which can handle all situations described above but rustfmt doesn't preserve alignment unfortunately.

[nrc]

Is there anything new on this?

No update, sorry. This is a 'some day' feature tbh.

[umurgdk]

Any update on this? I like aligning those match right hand sides.