Take in account the unreachable! macro in the non_fmt_panic lint

9 files changed, 160 insertions, 35 deletions

diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index be4849d0b84..603971a6a91 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -277,7 +277,6 @@ language_item_table! {
     Panic,                   sym::panic,               panic_fn,                   Target::Fn,             GenericRequirement::Exact(0);
     PanicFmt,                sym::panic_fmt,           panic_fmt,                  Target::Fn,             GenericRequirement::None;
     PanicDisplay,            sym::panic_display,       panic_display,              Target::Fn,             GenericRequirement::None;
-    PanicStr,                sym::panic_str,           panic_str,                  Target::Fn,             GenericRequirement::None;
     ConstPanicFmt,           sym::const_panic_fmt,     const_panic_fmt,            Target::Fn,             GenericRequirement::None;
     PanicBoundsCheck,        sym::panic_bounds_check,  panic_bounds_check_fn,      Target::Fn,             GenericRequirement::Exact(0);
     PanicInfo,               sym::panic_info,          panic_info,                 Target::Struct,         GenericRequirement::None;
diff --git a/compiler/rustc_lint/src/non_fmt_panic.rs b/compiler/rustc_lint/src/non_fmt_panic.rs
index 6bf25732f60..3130d57c2a9 100644
--- a/compiler/rustc_lint/src/non_fmt_panic.rs
+++ b/compiler/rustc_lint/src/non_fmt_panic.rs
@@ -49,9 +49,11 @@ impl<'tcx> LateLintPass<'tcx> for NonPanicFmt {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
         if let hir::ExprKind::Call(f, [arg]) = &expr.kind {
             if let &ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(f).kind() {
+                let f_diagnostic_name = cx.tcx.get_diagnostic_name(def_id);
+
                 if Some(def_id) == cx.tcx.lang_items().begin_panic_fn()
                     || Some(def_id) == cx.tcx.lang_items().panic_fn()
-                    || Some(def_id) == cx.tcx.lang_items().panic_str()
+                    || f_diagnostic_name == Some(sym::panic_str)
                 {
                     if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
                         if matches!(
@@ -61,6 +63,22 @@ impl<'tcx> LateLintPass<'tcx> for NonPanicFmt {
                             check_panic(cx, f, arg);
                         }
                     }
+                } else if f_diagnostic_name == Some(sym::unreachable_display) {
+                    if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
+                        if cx.tcx.is_diagnostic_item(sym::unreachable_2015_macro, id) {
+                            check_panic(
+                                cx,
+                                f,
+                                // This is safe because we checked above that the callee is indeed
+                                // unreachable_display
+                                match &arg.kind {
+                                    // Get the borrowed arg not the borrow
+                                    hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, arg) => arg,
+                                    _ => bug!("call to unreachable_display without borrow"),
+                                },
+                            );
+                        }
+                    }
                 }
             }
         }
@@ -85,8 +103,8 @@ fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tc
         return;
     }
 
-    // Find the span of the argument to `panic!()`, before expansion in the
-    // case of `panic!(some_macro!())`.
+    // Find the span of the argument to `panic!()` or `unreachable!`, before expansion in the
+    // case of `panic!(some_macro!())` or `unreachable!(some_macro!())`.
     // We don't use source_callsite(), because this `panic!(..)` might itself
     // be expanded from another macro, in which case we want to stop at that
     // expansion.
@@ -319,6 +337,7 @@ fn panic_call<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>) -> (Span,
                 | sym::std_panic_macro
                 | sym::assert_macro
                 | sym::debug_assert_macro
+                | sym::unreachable_macro
         ) {
             break;
         }
diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index d857b4948b5..0798076411a 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -50,7 +50,7 @@ pub const fn panic(expr: &'static str) -> ! {
 
 #[inline]
 #[track_caller]
-#[lang = "panic_str"] // needed for `non-fmt-panics` lint
+#[rustc_diagnostic_item = "panic_str"]
 #[rustc_const_unstable(feature = "core_panic", issue = "none")]
 pub const fn panic_str(expr: &str) -> ! {
     panic_display(&expr);
diff --git a/src/test/ui/macros/unreachable-arg.edition_2021.stderr b/src/test/ui/macros/unreachable-arg.edition_2021.stderr
new file mode 100644
index 00000000000..d70ef31eed6
--- /dev/null
+++ b/src/test/ui/macros/unreachable-arg.edition_2021.stderr
@@ -0,0 +1,13 @@
+error: format argument must be a string literal
+  --> $DIR/unreachable-arg.rs:15:18
+   |
+LL |     unreachable!(a);
+   |                  ^
+   |
+help: you might be missing a string literal to format with
+   |
+LL |     unreachable!("{}", a);
+   |                  +++++
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/macros/unreachable-arg.rs b/src/test/ui/macros/unreachable-arg.rs
new file mode 100644
index 00000000000..4024bd20b79
--- /dev/null
+++ b/src/test/ui/macros/unreachable-arg.rs
@@ -0,0 +1,16 @@
+// ignore-emscripten no processes
+
+// revisions: edition_2015 edition_2021
+// [edition_2015]edition:2015
+// [edition_2021]edition:2021
+// [edition_2015]run-fail
+// [edition_2021]check-fail
+// [edition_2015]error-pattern:internal error: entered unreachable code: hello
+// [edition_2021]error-pattern:format argument must be a string literal
+
+#![allow(non_fmt_panics)]
+
+fn main() {
+    let a = "hello";
+    unreachable!(a);
+}
diff --git a/src/test/ui/macros/unreachable-format-arg.rs b/src/test/ui/macros/unreachable-format-arg.rs
index 7d83b698d79..ff059ad9e15 100644
--- a/src/test/ui/macros/unreachable-format-arg.rs
+++ b/src/test/ui/macros/unreachable-format-arg.rs
@@ -7,6 +7,8 @@
 // [edition_2015]error-pattern:internal error: entered unreachable code: x is {x}
 // [edition_2021]error-pattern:internal error: entered unreachable code: x is 5
 
+#![allow(non_fmt_panics)]
+
 fn main() {
     let x = 5;
     unreachable!("x is {x}");
diff --git a/src/test/ui/non-fmt-panic.fixed b/src/test/ui/non-fmt-panic.fixed
index d226f4129aa..5191f1877a9 100644
--- a/src/test/ui/non-fmt-panic.fixed
+++ b/src/test/ui/non-fmt-panic.fixed
@@ -11,6 +11,7 @@ static S: &str = "{bla}";
 #[allow(unreachable_code)]
 fn main() {
     panic!("{}", "here's a brace: {"); //~ WARN panic message contains a brace
+    unreachable!("{}", "here's a brace: {"); //~ WARN panic message contains a brace
     std::panic!("{}", "another one: }"); //~ WARN panic message contains a brace
     core::panic!("{}", "Hello {}"); //~ WARN panic message contains an unused formatting placeholder
     assert!(false, "{}", "{:03x} {test} bla");
@@ -24,6 +25,8 @@ fn main() {
     debug_assert!(false, "{}", "{{}} bla"); //~ WARN panic message contains braces
     panic!("{}", C); //~ WARN panic message is not a string literal
     panic!("{}", S); //~ WARN panic message is not a string literal
+    unreachable!("{}", S); //~ WARN panic message is not a string literal
+    unreachable!("{}", S); //~ WARN panic message is not a string literal
     std::panic::panic_any(123); //~ WARN panic message is not a string literal
     core::panic!("{}", &*"abc"); //~ WARN panic message is not a string literal
     std::panic::panic_any(Some(123)); //~ WARN panic message is not a string literal
@@ -41,8 +44,10 @@ fn main() {
     }
 
     std::panic::panic_any(a!()); //~ WARN panic message is not a string literal
+    unreachable!("{}", a!()); //~ WARN panic message is not a string literal
 
     panic!("{}", 1); //~ WARN panic message is not a string literal
+    unreachable!("{}", 1); //~ WARN panic message is not a string literal
     assert!(false, "{}", 1); //~ WARN panic message is not a string literal
     debug_assert!(false, "{}", 1); //~ WARN panic message is not a string literal
 
diff --git a/src/test/ui/non-fmt-panic.rs b/src/test/ui/non-fmt-panic.rs
index 2ffd7638ae0..d0d06b79775 100644
--- a/src/test/ui/non-fmt-panic.rs
+++ b/src/test/ui/non-fmt-panic.rs
@@ -11,6 +11,7 @@ static S: &str = "{bla}";
 #[allow(unreachable_code)]
 fn main() {
     panic!("here's a brace: {"); //~ WARN panic message contains a brace
+    unreachable!("here's a brace: {"); //~ WARN panic message contains a brace
     std::panic!("another one: }"); //~ WARN panic message contains a brace
     core::panic!("Hello {}"); //~ WARN panic message contains an unused formatting placeholder
     assert!(false, "{:03x} {test} bla");
@@ -24,6 +25,8 @@ fn main() {
     debug_assert!(false, "{{}} bla"); //~ WARN panic message contains braces
     panic!(C); //~ WARN panic message is not a string literal
     panic!(S); //~ WARN panic message is not a string literal
+    unreachable!(S); //~ WARN panic message is not a string literal
+    unreachable!(S); //~ WARN panic message is not a string literal
     std::panic!(123); //~ WARN panic message is not a string literal
     core::panic!(&*"abc"); //~ WARN panic message is not a string literal
     panic!(Some(123)); //~ WARN panic message is not a string literal
@@ -41,8 +44,10 @@ fn main() {
     }
 
     panic!(a!()); //~ WARN panic message is not a string literal
+    unreachable!(a!()); //~ WARN panic message is not a string literal
 
     panic!(format!("{}", 1)); //~ WARN panic message is not a string literal
+    unreachable!(format!("{}", 1)); //~ WARN panic message is not a string literal
     assert!(false, format!("{}", 1)); //~ WARN panic message is not a string literal
     debug_assert!(false, format!("{}", 1)); //~ WARN panic message is not a string literal
 
diff --git a/src/test/ui/non-fmt-panic.stderr b/src/test/ui/non-fmt-panic.stderr
index f9e6d895136..3305e5cc906 100644
--- a/src/test/ui/non-fmt-panic.stderr
+++ b/src/test/ui/non-fmt-panic.stderr
@@ -12,7 +12,19 @@ LL |     panic!("{}", "here's a brace: {");
    |            +++++
 
 warning: panic message contains a brace
-  --> $DIR/non-fmt-panic.rs:14:31
+  --> $DIR/non-fmt-panic.rs:14: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:15:31
    |
 LL |     std::panic!("another one: }");
    |                               ^
@@ -24,7 +36,7 @@ LL |     std::panic!("{}", "another one: }");
    |                 +++++
 
 warning: panic message contains an unused formatting placeholder
-  --> $DIR/non-fmt-panic.rs:15:25
+  --> $DIR/non-fmt-panic.rs:16:25
    |
 LL |     core::panic!("Hello {}");
    |                         ^^
@@ -40,7 +52,7 @@ LL |     core::panic!("{}", "Hello {}");
    |                  +++++
 
 warning: panic message contains unused formatting placeholders
-  --> $DIR/non-fmt-panic.rs:16:21
+  --> $DIR/non-fmt-panic.rs:17:21
    |
 LL |     assert!(false, "{:03x} {test} bla");
    |                     ^^^^^^ ^^^^^^
@@ -56,7 +68,7 @@ LL |     assert!(false, "{}", "{:03x} {test} bla");
    |                    +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:18:20
+  --> $DIR/non-fmt-panic.rs:19:20
    |
 LL |     assert!(false, S);
    |                    ^
@@ -69,7 +81,7 @@ LL |     assert!(false, "{}", S);
    |                    +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:20:20
+  --> $DIR/non-fmt-panic.rs:21:20
    |
 LL |     assert!(false, 123);
    |                    ^^^
@@ -82,7 +94,7 @@ LL |     assert!(false, "{}", 123);
    |                    +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:22:20
+  --> $DIR/non-fmt-panic.rs:23:20
    |
 LL |     assert!(false, Some(123));
    |                    ^^^^^^^^^
@@ -95,7 +107,7 @@ LL |     assert!(false, "{:?}", Some(123));
    |                    +++++++
 
 warning: panic message contains braces
-  --> $DIR/non-fmt-panic.rs:24:27
+  --> $DIR/non-fmt-panic.rs:25:27
    |
 LL |     debug_assert!(false, "{{}} bla");
    |                           ^^^^
@@ -107,7 +119,7 @@ LL |     debug_assert!(false, "{}", "{{}} bla");
    |                          +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:25:12
+  --> $DIR/non-fmt-panic.rs:26:12
    |
 LL |     panic!(C);
    |            ^
@@ -120,7 +132,7 @@ LL |     panic!("{}", C);
    |            +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:26:12
+  --> $DIR/non-fmt-panic.rs:27:12
    |
 LL |     panic!(S);
    |            ^
@@ -133,7 +145,33 @@ LL |     panic!("{}", S);
    |            +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:27:17
+  --> $DIR/non-fmt-panic.rs:28: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/nightly/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:29: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/nightly/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:30:17
    |
 LL |     std::panic!(123);
    |                 ^^^
@@ -150,7 +188,7 @@ LL |     std::panic::panic_any(123);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:28:18
+  --> $DIR/non-fmt-panic.rs:31:18
    |
 LL |     core::panic!(&*"abc");
    |                  ^^^^^^^
@@ -163,7 +201,7 @@ LL |     core::panic!("{}", &*"abc");
    |                  +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:29:12
+  --> $DIR/non-fmt-panic.rs:32:12
    |
 LL |     panic!(Some(123));
    |            ^^^^^^^^^
@@ -180,7 +218,7 @@ LL |     std::panic::panic_any(Some(123));
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message contains an unused formatting placeholder
-  --> $DIR/non-fmt-panic.rs:30:12
+  --> $DIR/non-fmt-panic.rs:33:12
    |
 LL |     panic!(concat!("{", "}"));
    |            ^^^^^^^^^^^^^^^^^
@@ -196,7 +234,7 @@ LL |     panic!("{}", concat!("{", "}"));
    |            +++++
 
 warning: panic message contains braces
-  --> $DIR/non-fmt-panic.rs:31:5
+  --> $DIR/non-fmt-panic.rs:34:5
    |
 LL |     panic!(concat!("{", "{"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -208,7 +246,7 @@ LL |     panic!("{}", concat!("{", "{"));
    |            +++++
 
 warning: panic message contains an unused formatting placeholder
-  --> $DIR/non-fmt-panic.rs:33:37
+  --> $DIR/non-fmt-panic.rs:36:37
    |
 LL |     fancy_panic::fancy_panic!("test {} 123");
    |                                     ^^
@@ -216,7 +254,7 @@ 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:43:12
+  --> $DIR/non-fmt-panic.rs:46:12
    |
 LL |     panic!(a!());
    |            ^^^^
@@ -233,7 +271,20 @@ LL |     std::panic::panic_any(a!());
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:45:12
+  --> $DIR/non-fmt-panic.rs:47: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/nightly/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:49:12
    |
 LL |     panic!(format!("{}", 1));
    |            ^^^^^^^^^^^^^^^^
@@ -248,7 +299,22 @@ LL +     panic!("{}", 1);
    | 
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:46:20
+  --> $DIR/non-fmt-panic.rs:50: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/nightly/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:51:20
    |
 LL |     assert!(false, format!("{}", 1));
    |                    ^^^^^^^^^^^^^^^^
@@ -263,7 +329,7 @@ LL +     assert!(false, "{}", 1);
    | 
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:47:26
+  --> $DIR/non-fmt-panic.rs:52:26
    |
 LL |     debug_assert!(false, format!("{}", 1));
    |                          ^^^^^^^^^^^^^^^^
@@ -278,7 +344,7 @@ LL +     debug_assert!(false, "{}", 1);
    | 
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:49:12
+  --> $DIR/non-fmt-panic.rs:54:12
    |
 LL |     panic![123];
    |            ^^^
@@ -295,7 +361,7 @@ LL |     std::panic::panic_any(123);
    |     ~~~~~~~~~~~~~~~~~~~~~~   ~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:50:12
+  --> $DIR/non-fmt-panic.rs:55:12
    |
 LL |     panic!{123};
    |            ^^^
@@ -312,7 +378,7 @@ LL |     std::panic::panic_any(123);
    |     ~~~~~~~~~~~~~~~~~~~~~~   ~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:67:12
+  --> $DIR/non-fmt-panic.rs:72:12
    |
 LL |     panic!(v);
    |     ------ ^
@@ -323,7 +389,7 @@ LL |     panic!(v);
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:68:20
+  --> $DIR/non-fmt-panic.rs:73:20
    |
 LL |     assert!(false, v);
    |                    ^
@@ -332,7 +398,7 @@ LL |     assert!(false, v);
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:72:12
+  --> $DIR/non-fmt-panic.rs:77:12
    |
 LL |     panic!(v);
    |            ^
@@ -349,7 +415,7 @@ LL |     std::panic::panic_any(v);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:73:20
+  --> $DIR/non-fmt-panic.rs:78:20
    |
 LL |     assert!(false, v);
    |                    ^
@@ -362,7 +428,7 @@ LL |     assert!(false, "{:?}", v);
    |                    +++++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:77:12
+  --> $DIR/non-fmt-panic.rs:82:12
    |
 LL |     panic!(v);
    |            ^
@@ -379,7 +445,7 @@ LL |     std::panic::panic_any(v);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:78:20
+  --> $DIR/non-fmt-panic.rs:83:20
    |
 LL |     assert!(false, v);
    |                    ^
@@ -392,7 +458,7 @@ LL |     assert!(false, "{}", v);
    |                    +++++
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:82:12
+  --> $DIR/non-fmt-panic.rs:87:12
    |
 LL |     panic!(v);
    |            ^
@@ -409,7 +475,7 @@ LL |     std::panic::panic_any(v);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 warning: panic message is not a string literal
-  --> $DIR/non-fmt-panic.rs:83:20
+  --> $DIR/non-fmt-panic.rs:88:20
    |
 LL |     assert!(false, v);
    |                    ^
@@ -421,5 +487,5 @@ help: add a "{}" format string to Display the message
 LL |     assert!(false, "{}", v);
    |                    +++++
 
-warning: 30 warnings emitted
+warning: 35 warnings emitted