Assert panic is difficult to read for long expressions

[jyn514]

Given the following test, the traceback is very ugly and difficult to read. I think the assert! macro is trying to limit the width to 80 or 100 characters, but it also indents by a ridiculous amount. It should either use block indentation instead of visual indentation, put everything one line, or possibly just format it the same as the original code.

This happened even when the terminal width was more than 100 characters.

    #[test]
    fn test_complex_types() {
        assert!(match_type(
            parse("char * const (*(* const bar)[10])(int )"),
            Pointer(
                Box::new(Array(
                    Box::new(Pointer(
                        Box::new(Function(FunctionType {
                            return_type: Box::new(Pointer(Box::new(Char(true)), Qualifiers::CONST)),
                            params: vec![Symbol {
                                ctype: Int(true),
                                storage_class: Default::default(),
                                id: String::new(),
                                qualifiers: Qualifiers::NONE,
                            }],
                            varargs: false,
                        })),
                        Qualifiers::NONE
                    )),
                    ArrayType::Fixed(Box::new(Expr::Int(Token::Int(10))))
                )),
                Qualifiers::CONST
            )
        ));
    }

failures:

---- parse::tests::test_complex_types stdout ----
thread 'parse::tests::test_complex_types' panicked at 'assertion failed: match_type(parse("char * const (*(* const bar)[10])(int )"),
           Pointer(Box::new(Array(Box::new(Pointer(Box::new(Function(FunctionType{return_type:
                                                                                      Box::new(Pointer(Box::new(Char(true)),
                                                                                                       Qualifiers::CONST)),
                                                                                  params:
                                                                                      vec![Symbol
                                                                                           {
                                                                                           ctype
                                                                                           :
                                                                                           Int
                                                                                           (
                                                                                           true
                                                                                           )
                                                                                           ,
                                                                                           storage_class
                                                                                           :
                                                                                           Default
                                                                                           ::
                                                                                           default
                                                                                           (

                                                                                           )
                                                                                           ,
                                                                                           id
                                                                                           :
                                                                                           String
                                                                                           ::
                                                                                           new
                                                                                           (

                                                                                           )
                                                                                           ,
                                                                                           qualifiers
                                                                                           :
                                                                                           Qualifiers
                                                                                           ::
                                                                                           NONE
                                                                                           ,
                                                                                           }],
                                                                                  varargs:
                                                                                      false,})),
                                                   Qualifiers::NONE)),
                                  ArrayType::Fixed(Box::new(Expr::Int(Token::Int(10)))))),
                   Qualifiers::CONST))', src/parse.rs:965:9

[tesuji]

@rustbot modify labels: A-diagnostics

[eddyb]

Yeah, this is the pretty-printer not having updated for "block indentation" rules.
I'll try to poke around, maybe it's easy to fix.

[steveklabnik]

Triage: i don't have time to put it together, but an easy reproduction here would be nice!

[jyn514]

Here is a partial reproduction: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=40739fc9999c13cfa3d802e302d72c1f

I simplified Symbol a little because I was tired of typing :P but I think it still gets the idea across.

[jyn514]

Note the error message is significantly better if you use assert_eq instead. I'm not sure why they're pretty printed differently, maybe one is going through stringify!? https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=66c23c384fa7ecd405f342a4a5abad3f

[RodBurman]

Using current toolchain:

% cargo -v -V
cargo 1.85.1 (d73d2caf9 2024-12-31)
release: 1.85.1
commit-hash: d73d2caf9e41a39daf2a8d6ce60ec80bf354d2a7
commit-date: 2024-12-31
host: aarch64-apple-darwin
libgit2: 1.8.1 (sys:0.19.0 vendored)
libcurl: 8.7.1 (sys:0.4.74+curl-8.9.0 system ssl:(SecureTransport) LibreSSL/3.3.6)
ssl: OpenSSL 1.1.1w  11 Sep 2023
os: Mac OS 15.3.2 [64-bit]

and the partial reproduction code from: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=40739fc9999c13cfa3d802e302d72c1f
Then the backtrace (RUST_BACKTRACE=1) looks fairly normal now, with no extra long tabbing:

thread 'main' panicked at src/main.rs:51:5:
assertion failed: f(Pointer(Box::new(Array(Box::new(Pointer(Box::new(Function(FunctionType {
                                    return_type: Box::new(Pointer(Box::new(Char(true)),
                                            Qualifiers::CONST)),
                                    params: vec![String::new()],
                                    varargs: false,
                                })), Qualifiers::NONE)),
                ArrayType::Fixed(Box::new(Expr::Literal(Token::Int(10)))))),
        Qualifiers::CONST))
stack backtrace:
   0: rust_begin_unwind
             at /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/std/src/panicking.rs:692:5
   1: core::panicking::panic_fmt
             at /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/panicking.rs:75:14
   2: core::panicking::panic
             at /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/panicking.rs:145:5
   3: aspan::main
             at ./src/main.rs:51:5
   4: core::ops::function::FnOnce::call_once
             at /Users/rod/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

So if we agree that the partial reproduction should reproduce at least some of the problem, then it appears the problem has been fixed.