tests/ui/macros/non-fmt-panic.stderr

warning: panic message contains a brace
  --> $DIR/non-fmt-panic.rs:20:29
   |
LL |     panic!("here's a brace: {");
   |                             ^
   |
   = note: this message is not used as a format string, but will be in Rust 2021
   = note: `#[warn(non_fmt_panics)]` (part of `#[warn(rust_2021_compatibility)]`) on by default
help: add a "{}" format string to use the message literally
   |
LL |     panic!("{}", "here's a brace: {");
   |            +++++

warning: panic message contains a brace
  --> $DIR/non-fmt-panic.rs:21:35
   |
LL |     unreachable!("here's a brace: {");
   |                                   ^
   |
   = note: this message is not used as a format string, but will be in Rust 2021
help: add a "{}" format string to use the message literally
   |
LL |     unreachable!("{}", "here's a brace: {");
   |                  +++++

warning: panic message contains a brace
  --> $DIR/non-fmt-panic.rs:22:31
   |
LL |     std::panic!("another one: }");
   |                               ^
   |
   = note: this message is not used as a format string, but will be in Rust 2021
help: add a "{}" format string to use the message literally
   |
LL |     std::panic!("{}", "another one: }");
   |                 +++++

warning: panic message contains an unused formatting placeholder
  --> $DIR/non-fmt-panic.rs:23:25
   |
LL |     core::panic!("Hello {}");
   |                         ^^
   |
   = note: this message is not used as a format string when given without arguments, but will be in Rust 2021
help: add the missing argument
   |
LL |     core::panic!("Hello {}", ...);
   |                            +++++
help: or add a "{}" format string to use the message literally
   |
LL |     core::panic!("{}", "Hello {}");
   |                  +++++

warning: panic message contains unused formatting placeholders
  --> $DIR/non-fmt-panic.rs:24:21
   |
LL |     assert!(false, "{:03x} {test} bla");
   |                     ^^^^^^ ^^^^^^
   |
   = note: this message is not used as a format string when given without arguments, but will be in Rust 2021
help: add the missing arguments
   |
LL |     assert!(false, "{:03x} {test} bla", ...);
   |                                       +++++
help: or add a "{}" format string to use the message literally
   |
LL |     assert!(false, "{}", "{:03x} {test} bla");
   |                    +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:26:20
   |
LL |     assert!(false, S);
   |                    ^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     assert!(false, "{}", S);
   |                    +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:28:20
   |
LL |     assert!(false, 123);
   |                    ^^^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     assert!(false, "{}", 123);
   |                    +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:30:20
   |
LL |     assert!(false, Some(123));
   |                    ^^^^^^^^^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{:?}" format string to use the `Debug` implementation of `Option<i32>`
   |
LL |     assert!(false, "{:?}", Some(123));
   |                    +++++++

warning: panic message contains braces
  --> $DIR/non-fmt-panic.rs:32:27
   |
LL |     debug_assert!(false, "{{}} bla");
   |                           ^^^^
   |
   = note: this message is not used as a format string, but will be in Rust 2021
help: add a "{}" format string to use the message literally
   |
LL |     debug_assert!(false, "{}", "{{}} bla");
   |                          +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:33:12
   |
LL |     panic!(C);
   |            ^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!("{}", C);
   |            +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:34:12
   |
LL |     panic!(S);
   |            ^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!("{}", S);
   |            +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:35:18
   |
LL |     unreachable!(S);
   |                  ^
   |
   = note: this usage of `unreachable!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     unreachable!("{}", S);
   |                  +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:36:18
   |
LL |     unreachable!(S);
   |                  ^
   |
   = note: this usage of `unreachable!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     unreachable!("{}", S);
   |                  +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:37:17
   |
LL |     std::panic!(123);
   |                 ^^^
   |
   = note: this usage of `std::panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     std::panic!("{}", 123);
   |                 +++++
help: or use std::panic::panic_any instead
   |
LL -     std::panic!(123);
LL +     std::panic::panic_any(123);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:38:18
   |
LL |     core::panic!(&*"abc");
   |                  ^^^^^^^
   |
   = note: this usage of `core::panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     core::panic!("{}", &*"abc");
   |                  +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:39:12
   |
LL |     panic!(Some(123));
   |            ^^^^^^^^^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{:?}" format string to use the `Debug` implementation of `Option<i32>`
   |
LL |     panic!("{:?}", Some(123));
   |            +++++++
help: or use std::panic::panic_any instead
   |
LL -     panic!(Some(123));
LL +     std::panic::panic_any(Some(123));
   |

warning: panic message contains an unused formatting placeholder
  --> $DIR/non-fmt-panic.rs:40:12
   |
LL |     panic!(concat!("{", "}"));
   |            ^^^^^^^^^^^^^^^^^
   |
   = note: this message is not used as a format string when given without arguments, but will be in Rust 2021
help: add the missing argument
   |
LL |     panic!(concat!("{", "}"), ...);
   |                             +++++
help: or add a "{}" format string to use the message literally
   |
LL |     panic!("{}", concat!("{", "}"));
   |            +++++

warning: panic message contains braces
  --> $DIR/non-fmt-panic.rs:41:5
   |
LL |     panic!(concat!("{", "{"));
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this message is not used as a format string, but will be in Rust 2021
help: add a "{}" format string to use the message literally
   |
LL |     panic!("{}", concat!("{", "{"));
   |            +++++

warning: panic message contains an unused formatting placeholder
  --> $DIR/non-fmt-panic.rs:43:37
   |
LL |     fancy_panic::fancy_panic!("test {} 123");
   |                                     ^^
   |
   = note: this message is not used as a format string when given without arguments, but will be in Rust 2021

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:53:12
   |
LL |     panic!(a!());
   |            ^^^^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!("{}", a!());
   |            +++++
help: or use std::panic::panic_any instead
   |
LL -     panic!(a!());
LL +     std::panic::panic_any(a!());
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:54:18
   |
LL |     unreachable!(a!());
   |                  ^^^^
   |
   = note: this usage of `unreachable!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     unreachable!("{}", a!());
   |                  +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:56:12
   |
LL |     panic!(format!("{}", 1));
   |            ^^^^^^^^^^^^^^^^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
   = note: the `panic!()` macro supports formatting, so there's no need for the `format!()` macro here
help: remove the `format!(..)` macro call
   |
LL -     panic!(format!("{}", 1));
LL +     panic!("{}", 1);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:57:18
   |
LL |     unreachable!(format!("{}", 1));
   |                  ^^^^^^^^^^^^^^^^
   |
   = note: this usage of `unreachable!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
   = note: the `unreachable!()` macro supports formatting, so there's no need for the `format!()` macro here
help: remove the `format!(..)` macro call
   |
LL -     unreachable!(format!("{}", 1));
LL +     unreachable!("{}", 1);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:58:20
   |
LL |     assert!(false, format!("{}", 1));
   |                    ^^^^^^^^^^^^^^^^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
   = note: the `assert!()` macro supports formatting, so there's no need for the `format!()` macro here
help: remove the `format!(..)` macro call
   |
LL -     assert!(false, format!("{}", 1));
LL +     assert!(false, "{}", 1);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:59:26
   |
LL |     debug_assert!(false, format!("{}", 1));
   |                          ^^^^^^^^^^^^^^^^
   |
   = note: this usage of `debug_assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
   = note: the `debug_assert!()` macro supports formatting, so there's no need for the `format!()` macro here
help: remove the `format!(..)` macro call
   |
LL -     debug_assert!(false, format!("{}", 1));
LL +     debug_assert!(false, "{}", 1);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:61:12
   |
LL |     panic![123];
   |            ^^^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!["{}", 123];
   |            +++++
help: or use std::panic::panic_any instead
   |
LL -     panic![123];
LL +     std::panic::panic_any(123);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:62:12
   |
LL |     panic!{123};
   |            ^^^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!{"{}", 123};
   |            +++++
help: or use std::panic::panic_any instead
   |
LL -     panic!{123};
LL +     std::panic::panic_any(123);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:79:12
   |
LL |     panic!(v);
   |     ------ ^
   |     |
   |     help: use std::panic::panic_any instead: `std::panic::panic_any`
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:80:20
   |
LL |     assert!(false, v);
   |                    ^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:84:12
   |
LL |     panic!(v);
   |            ^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{:?}" format string to use the `Debug` implementation of `T`
   |
LL |     panic!("{:?}", v);
   |            +++++++
help: or use std::panic::panic_any instead
   |
LL -     panic!(v);
LL +     std::panic::panic_any(v);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:85:20
   |
LL |     assert!(false, v);
   |                    ^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{:?}" format string to use the `Debug` implementation of `T`
   |
LL |     assert!(false, "{:?}", v);
   |                    +++++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:89:12
   |
LL |     panic!(v);
   |            ^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!("{}", v);
   |            +++++
help: or use std::panic::panic_any instead
   |
LL -     panic!(v);
LL +     std::panic::panic_any(v);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:90:20
   |
LL |     assert!(false, v);
   |                    ^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     assert!(false, "{}", v);
   |                    +++++

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:94:12
   |
LL |     panic!(v);
   |            ^
   |
   = note: this usage of `panic!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     panic!("{}", v);
   |            +++++
help: or use std::panic::panic_any instead
   |
LL -     panic!(v);
LL +     std::panic::panic_any(v);
   |

warning: panic message is not a string literal
  --> $DIR/non-fmt-panic.rs:95:20
   |
LL |     assert!(false, v);
   |                    ^
   |
   = note: this usage of `assert!()` is deprecated; it will be a hard error in Rust 2021
   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/panic-macro-consistency.html>
help: add a "{}" format string to `Display` the message
   |
LL |     assert!(false, "{}", v);
   |                    +++++

warning: 35 warnings emitted