specified formatting not applied if `format_args()` is passed to `println!()`

[matthiaskrgr]

I tried this code:

use std::fmt;

struct A {}

impl fmt::Debug for A {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "1234567890")
    }
}

pub fn main() {
    println!("{:<.5}", "1234567890");
    let a = A {};
    println!("{:<.5}", format_args!("{:?}", a));
}

playground

I expected to see this happen:
I would expect both lines prints to print the same output.

Instead, this happened:
output is

12345
1234567890

and there is no warning that the second println! completely ignores the formatting directives :<.5 that I passed.

Meta

rustc --version --verbose:

rustc 1.63.0-nightly (a6b8c6954 2022-06-03)
binary: rustc
commit-hash: a6b8c6954829669a5c4fa320c3e6132edf04fcfc
commit-date: 2022-06-03
host: x86_64-unknown-linux-gnu
release: 1.63.0-nightly
LLVM version: 14.0.4

[compiler-errors]

I think this makes sense? We're no longer formatting a number in the second example, so the <.5 format doesn't apply anything... it's equivalent to a println!("{:<.5}", format!("{:?}", a)).

[matthiaskrgr]

println!("{:<.5}", format!("{:?}", a))

this is equivalent to the first example and not the second one.

from the docs: "For non-numeric types, this can be considered a “maximum width”. If the resulting string is longer than this width, then it is truncated down to this many characters and that truncated value is emitted with proper fill, alignment and width if those parameters are set." 🤔

[compiler-errors]

..... my bad.

I should've checked. println!("{:<.5}", format!("{:?}", a)) does print the correct thing, and is not equivalent to the similar format_args usage. lol. 😅

[compiler-errors]

Huh, looks like impl Display for Arguments totally bypasses the formatter's flags: https://doc.rust-lang.org/src/core/fmt/mod.rs.html#527

so we don't get an equivalent padding call like the str impl: https://doc.rust-lang.org/src/core/fmt/mod.rs.html#2201

[ChayimFriedman2]

Fixing that, besides being a breaking change, is also hard because if we will forward the flags then if we for example print two strings each will be cut alone and without respect to the total length.

Maybe we should explain in the docs that format_args!() does not forward the flag and this might cause unexpected behavior.

[compiler-errors]

I don't think the solution here is to forward the format flags, but instead (inside the impl Display for fmt::Arguments<'_>) detect when we have a limit, and if so, dispatch to a formatter that drops all characters after it gets to that limit.