1 use crate::{LateContext, LateLintPass, LintContext};
3 use rustc_errors::{pluralize, Applicability};
5 use rustc_infer::infer::TyCtxtInferExt;
6 use rustc_middle::lint::in_external_macro;
8 use rustc_middle::ty::subst::InternalSubsts;
9 use rustc_parse_format::{ParseMode, Parser, Piece};
10 use rustc_session::lint::FutureIncompatibilityReason;
11 use rustc_span::edition::Edition;
12 use rustc_span::{hygiene, sym, symbol::kw, InnerSpan, Span, Symbol};
13 use rustc_trait_selection::infer::InferCtxtExt;
16 /// The `non_fmt_panics` lint detects `panic!(..)` invocations where the first
17 /// argument is not a formatting string.
21 /// ```rust,no_run,edition2018
30 /// In Rust 2018 and earlier, `panic!(x)` directly uses `x` as the message.
31 /// That means that `panic!("{}")` panics with the message `"{}"` instead
32 /// of using it as a formatting string, and `panic!(123)` will panic with
33 /// an `i32` as message.
35 /// Rust 2021 always interprets the first argument as format string.
38 "detect single-argument panic!() invocations in which the argument is not a format string",
39 @future_incompatible = FutureIncompatibleInfo {
40 reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2021),
41 explain_reason: false,
43 report_in_external_macro
46 declare_lint_pass!(NonPanicFmt => [NON_FMT_PANICS]);
48 impl<'tcx> LateLintPass<'tcx> for NonPanicFmt {
49 fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
50 if let hir::ExprKind::Call(f, [arg]) = &expr.kind {
51 if let &ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(f).kind() {
52 if Some(def_id) == cx.tcx.lang_items().begin_panic_fn()
53 || Some(def_id) == cx.tcx.lang_items().panic_fn()
54 || Some(def_id) == cx.tcx.lang_items().panic_str()
56 if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
58 cx.tcx.get_diagnostic_name(id),
59 Some(sym::core_panic_2015_macro | sym::std_panic_2015_macro)
61 check_panic(cx, f, arg);
70 fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tcx hir::Expr<'tcx>) {
71 if let hir::ExprKind::Lit(lit) = &arg.kind {
72 if let ast::LitKind::Str(sym, _) = lit.node {
73 // The argument is a string literal.
74 check_panic_str(cx, f, arg, sym.as_str());
79 // The argument is *not* a string literal.
81 let (span, panic, symbol) = panic_call(cx, f);
83 if in_external_macro(cx.sess(), span) {
84 // Nothing that can be done about it in the current crate.
88 // Find the span of the argument to `panic!()`, before expansion in the
89 // case of `panic!(some_macro!())`.
90 // We don't use source_callsite(), because this `panic!(..)` might itself
91 // be expanded from another macro, in which case we want to stop at that
93 let mut arg_span = arg.span;
94 let mut arg_macro = None;
95 while !span.contains(arg_span) {
96 let expn = arg_span.ctxt().outer_expn_data();
100 arg_macro = expn.macro_def_id;
101 arg_span = expn.call_site;
104 cx.struct_span_lint(NON_FMT_PANICS, arg_span, |lint| {
105 let mut l = lint.build("panic message is not a string literal");
106 l.note(&format!("this usage of {}!() is deprecated; it will be a hard error in Rust 2021", symbol));
107 l.note("for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>");
108 if !is_arg_inside_call(arg_span, span) {
109 // No clue where this argument is coming from.
113 if arg_macro.map_or(false, |id| cx.tcx.is_diagnostic_item(sym::format_macro, id)) {
114 // A case of `panic!(format!(..))`.
115 l.note(format!("the {}!() macro supports formatting, so there's no need for the format!() macro here", symbol).as_str());
116 if let Some((open, close, _)) = find_delimiters(cx, arg_span) {
117 l.multipart_suggestion(
118 "remove the `format!(..)` macro call",
120 (arg_span.until(open.shrink_to_hi()), "".into()),
121 (close.until(arg_span.shrink_to_hi()), "".into()),
123 Applicability::MachineApplicable,
127 let ty = cx.typeck_results().expr_ty(arg);
128 // If this is a &str or String, we can confidently give the `"{}", ` suggestion.
129 let is_str = matches!(
131 ty::Ref(_, r, _) if *r.kind() == ty::Str,
134 Some(ty_def) if cx.tcx.is_diagnostic_item(sym::String, ty_def.did),
137 let (suggest_display, suggest_debug) = cx.tcx.infer_ctxt().enter(|infcx| {
138 let display = is_str || cx.tcx.get_diagnostic_item(sym::Display).map(|t| {
139 infcx.type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env).may_apply()
141 let debug = !display && cx.tcx.get_diagnostic_item(sym::Debug).map(|t| {
142 infcx.type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env).may_apply()
147 let suggest_panic_any = !is_str && panic == sym::std_panic_macro;
149 let fmt_applicability = if suggest_panic_any {
150 // If we can use panic_any, use that as the MachineApplicable suggestion.
151 Applicability::MaybeIncorrect
153 // If we don't suggest panic_any, using a format string is our best bet.
154 Applicability::MachineApplicable
158 l.span_suggestion_verbose(
159 arg_span.shrink_to_lo(),
160 "add a \"{}\" format string to Display the message",
164 } else if suggest_debug {
165 l.span_suggestion_verbose(
166 arg_span.shrink_to_lo(),
168 "add a \"{{:?}}\" format string to use the Debug implementation of `{}`",
176 if suggest_panic_any {
177 if let Some((open, close, del)) = find_delimiters(cx, span) {
178 l.multipart_suggestion(
180 "{}use std::panic::panic_any instead",
181 if suggest_display || suggest_debug {
188 vec![(span.until(open), "std::panic::panic_any".into())]
191 (span.until(open.shrink_to_hi()), "std::panic::panic_any(".into()),
195 Applicability::MachineApplicable,
204 fn check_panic_str<'tcx>(
205 cx: &LateContext<'tcx>,
206 f: &'tcx hir::Expr<'tcx>,
207 arg: &'tcx hir::Expr<'tcx>,
210 if !fmt.contains(&['{', '}']) {
211 // No brace, no problem.
215 let (span, _, _) = panic_call(cx, f);
217 if in_external_macro(cx.sess(), span) && in_external_macro(cx.sess(), arg.span) {
218 // Nothing that can be done about it in the current crate.
222 let fmt_span = arg.span.source_callsite();
224 let (snippet, style) = match cx.sess().parse_sess.source_map().span_to_snippet(fmt_span) {
226 // Count the number of `#`s between the `r` and `"`.
227 let style = snippet.strip_prefix('r').and_then(|s| s.find('"'));
228 (Some(snippet), style)
230 Err(_) => (None, None),
233 let mut fmt_parser = Parser::new(fmt, style, snippet.clone(), false, ParseMode::Format);
234 let n_arguments = (&mut fmt_parser).filter(|a| matches!(a, Piece::NextArgument(_))).count();
236 if n_arguments > 0 && fmt_parser.errors.is_empty() {
237 let arg_spans: Vec<_> = match &fmt_parser.arg_places[..] {
238 [] => vec![fmt_span],
239 v => v.iter().map(|span| fmt_span.from_inner(*span)).collect(),
241 cx.struct_span_lint(NON_FMT_PANICS, arg_spans, |lint| {
242 let mut l = lint.build(match n_arguments {
243 1 => "panic message contains an unused formatting placeholder",
244 _ => "panic message contains unused formatting placeholders",
246 l.note("this message is not used as a format string when given without arguments, but will be in Rust 2021");
247 if is_arg_inside_call(arg.span, span) {
249 arg.span.shrink_to_hi(),
250 &format!("add the missing argument{}", pluralize!(n_arguments)),
252 Applicability::HasPlaceholders,
255 arg.span.shrink_to_lo(),
256 "or add a \"{}\" format string to use the message literally",
258 Applicability::MachineApplicable,
264 let brace_spans: Option<Vec<_>> =
265 snippet.filter(|s| s.starts_with('"') || s.starts_with("r#")).map(|s| {
267 .filter(|&(_, c)| c == '{' || c == '}')
268 .map(|(i, _)| fmt_span.from_inner(InnerSpan { start: i, end: i + 1 }))
271 let msg = match &brace_spans {
272 Some(v) if v.len() == 1 => "panic message contains a brace",
273 _ => "panic message contains braces",
275 cx.struct_span_lint(NON_FMT_PANICS, brace_spans.unwrap_or_else(|| vec![span]), |lint| {
276 let mut l = lint.build(msg);
277 l.note("this message is not used as a format string, but will be in Rust 2021");
278 if is_arg_inside_call(arg.span, span) {
280 arg.span.shrink_to_lo(),
281 "add a \"{}\" format string to use the message literally",
283 Applicability::MachineApplicable,
291 /// Given the span of `some_macro!(args);`, gives the span of `(` and `)`,
292 /// and the type of (opening) delimiter used.
293 fn find_delimiters<'tcx>(cx: &LateContext<'tcx>, span: Span) -> Option<(Span, Span, char)> {
294 let snippet = cx.sess().parse_sess.source_map().span_to_snippet(span).ok()?;
295 let (open, open_ch) = snippet.char_indices().find(|&(_, c)| "([{".contains(c))?;
296 let close = snippet.rfind(|c| ")]}".contains(c))?;
298 span.from_inner(InnerSpan { start: open, end: open + 1 }),
299 span.from_inner(InnerSpan { start: close, end: close + 1 }),
304 fn panic_call<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>) -> (Span, Symbol, Symbol) {
305 let mut expn = f.span.ctxt().outer_expn_data();
307 let mut panic_macro = kw::Empty;
309 // Unwrap more levels of macro expansion, as panic_2015!()
310 // was likely expanded from panic!() and possibly from
311 // [debug_]assert!().
313 let parent = expn.call_site.ctxt().outer_expn_data();
314 let Some(id) = parent.macro_def_id else { break };
315 let Some(name) = cx.tcx.get_diagnostic_name(id) else { break };
318 sym::core_panic_macro
319 | sym::std_panic_macro
321 | sym::debug_assert_macro
330 if let hygiene::ExpnKind::Macro(_, symbol) = expn.kind { symbol } else { sym::panic };
331 (expn.call_site, panic_macro, macro_symbol)
334 fn is_arg_inside_call(arg: Span, call: Span) -> bool {
335 // We only add suggestions if the argument we're looking at appears inside the
336 // panic call in the source file, to avoid invalid suggestions when macros are involved.
337 // We specifically check for the spans to not be identical, as that happens sometimes when
338 // proc_macros lie about spans and apply the same span to all the tokens they produce.
339 call.contains(arg) && !call.source_equal(&arg)