compiler/rustc_lint/src/non_fmt_panic.rs

   1 use crate::{LateContext, LateLintPass, LintContext};
   2 use rustc_ast as ast;
   3 use rustc_errors::{pluralize, Applicability};
   4 use rustc_hir as hir;
   5 use rustc_infer::infer::TyCtxtInferExt;
   6 use rustc_middle::lint::in_external_macro;
   7 use rustc_middle::ty;
   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, symbol::SymbolStr, InnerSpan, Span, Symbol};
  13 use rustc_trait_selection::infer::InferCtxtExt;
  14
  15 declare_lint! {
  16     /// The `non_fmt_panics` lint detects `panic!(..)` invocations where the first
  17     /// argument is not a formatting string.
  18     ///
  19     /// ### Example
  20     ///
  21     /// ```rust,no_run
  22     /// panic!("{}");
  23     /// panic!(123);
  24     /// ```
  25     ///
  26     /// {{produces}}
  27     ///
  28     /// ### Explanation
  29     ///
  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.
  34     ///
  35     /// Rust 2021 always interprets the first argument as format string.
  36     NON_FMT_PANICS,
  37     Warn,
  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,
  42     };
  43     report_in_external_macro
  44 }
  45
  46 declare_lint_pass!(NonPanicFmt => [NON_FMT_PANICS]);
  47
  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()
  55                 {
  56                     if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
  57                         if cx.tcx.is_diagnostic_item(sym::std_panic_2015_macro, id)
  58                             || cx.tcx.is_diagnostic_item(sym::core_panic_2015_macro, id)
  59                         {
  60                             check_panic(cx, f, arg);
  61                         }
  62                     }
  63                 }
  64             }
  65         }
  66     }
  67 }
  68
  69 fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tcx hir::Expr<'tcx>) {
  70     if let hir::ExprKind::Lit(lit) = &arg.kind {
  71         if let ast::LitKind::Str(sym, _) = lit.node {
  72             // The argument is a string literal.
  73             check_panic_str(cx, f, arg, &sym.as_str());
  74             return;
  75         }
  76     }
  77
  78     // The argument is *not* a string literal.
  79
  80     let (span, panic, symbol_str) = panic_call(cx, f);
  81
  82     if in_external_macro(cx.sess(), span) {
  83         // Nothing that can be done about it in the current crate.
  84         return;
  85     }
  86
  87     // Find the span of the argument to `panic!()`, before expansion in the
  88     // case of `panic!(some_macro!())`.
  89     // We don't use source_callsite(), because this `panic!(..)` might itself
  90     // be expanded from another macro, in which case we want to stop at that
  91     // expansion.
  92     let mut arg_span = arg.span;
  93     let mut arg_macro = None;
  94     while !span.contains(arg_span) {
  95         let expn = arg_span.ctxt().outer_expn_data();
  96         if expn.is_root() {
  97             break;
  98         }
  99         arg_macro = expn.macro_def_id;
 100         arg_span = expn.call_site;
 101     }
 102
 103     cx.struct_span_lint(NON_FMT_PANICS, arg_span, |lint| {
 104         let mut l = lint.build("panic message is not a string literal");
 105         l.note(&format!("this usage of {}!() is deprecated; it will be a hard error in Rust 2021", symbol_str));
 106         l.note("for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>");
 107         if !is_arg_inside_call(arg_span, span) {
 108             // No clue where this argument is coming from.
 109             l.emit();
 110             return;
 111         }
 112         if arg_macro.map_or(false, |id| cx.tcx.is_diagnostic_item(sym::format_macro, id)) {
 113             // A case of `panic!(format!(..))`.
 114             l.note(format!("the {}!() macro supports formatting, so there's no need for the format!() macro here", symbol_str).as_str());
 115             if let Some((open, close, _)) = find_delimiters(cx, arg_span) {
 116                 l.multipart_suggestion(
 117                     "remove the `format!(..)` macro call",
 118                     vec![
 119                         (arg_span.until(open.shrink_to_hi()), "".into()),
 120                         (close.until(arg_span.shrink_to_hi()), "".into()),
 121                     ],
 122                     Applicability::MachineApplicable,
 123                 );
 124             }
 125         } else {
 126             let ty = cx.typeck_results().expr_ty(arg);
 127             // If this is a &str or String, we can confidently give the `"{}", ` suggestion.
 128             let is_str = matches!(
 129                 ty.kind(),
 130                 ty::Ref(_, r, _) if *r.kind() == ty::Str,
 131             ) || matches!(
 132                 ty.ty_adt_def(),
 133                 Some(ty_def) if cx.tcx.is_diagnostic_item(sym::string_type, ty_def.did),
 134             );
 135
 136             let (suggest_display, suggest_debug) = cx.tcx.infer_ctxt().enter(|infcx| {
 137                 let display = is_str || cx.tcx.get_diagnostic_item(sym::display_trait).map(|t| {
 138                     infcx.type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env).may_apply()
 139                 }) == Some(true);
 140                 let debug = !display && cx.tcx.get_diagnostic_item(sym::debug_trait).map(|t| {
 141                     infcx.type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env).may_apply()
 142                 }) == Some(true);
 143                 (display, debug)
 144             });
 145
 146             let suggest_panic_any = !is_str && panic == sym::std_panic_macro;
 147
 148             let fmt_applicability = if suggest_panic_any {
 149                 // If we can use panic_any, use that as the MachineApplicable suggestion.
 150                 Applicability::MaybeIncorrect
 151             } else {
 152                 // If we don't suggest panic_any, using a format string is our best bet.
 153                 Applicability::MachineApplicable
 154             };
 155
 156             if suggest_display {
 157                 l.span_suggestion_verbose(
 158                     arg_span.shrink_to_lo(),
 159                     "add a \"{}\" format string to Display the message",
 160                     "\"{}\", ".into(),
 161                     fmt_applicability,
 162                 );
 163             } else if suggest_debug {
 164                 l.span_suggestion_verbose(
 165                     arg_span.shrink_to_lo(),
 166                     &format!(
 167                         "add a \"{{:?}}\" format string to use the Debug implementation of `{}`",
 168                         ty,
 169                     ),
 170                     "\"{:?}\", ".into(),
 171                     fmt_applicability,
 172                 );
 173             }
 174
 175             if suggest_panic_any {
 176                 if let Some((open, close, del)) = find_delimiters(cx, span) {
 177                     l.multipart_suggestion(
 178                         &format!(
 179                             "{}use std::panic::panic_any instead",
 180                             if suggest_display || suggest_debug {
 181                                 "or "
 182                             } else {
 183                                 ""
 184                             },
 185                         ),
 186                         if del == '(' {
 187                             vec![(span.until(open), "std::panic::panic_any".into())]
 188                         } else {
 189                             vec![
 190                                 (span.until(open.shrink_to_hi()), "std::panic::panic_any(".into()),
 191                                 (close, ")".into()),
 192                             ]
 193                         },
 194                         Applicability::MachineApplicable,
 195                     );
 196                 }
 197             }
 198         }
 199         l.emit();
 200     });
 201 }
 202
 203 fn check_panic_str<'tcx>(
 204     cx: &LateContext<'tcx>,
 205     f: &'tcx hir::Expr<'tcx>,
 206     arg: &'tcx hir::Expr<'tcx>,
 207     fmt: &str,
 208 ) {
 209     if !fmt.contains(&['{', '}'][..]) {
 210         // No brace, no problem.
 211         return;
 212     }
 213
 214     let (span, _, _) = panic_call(cx, f);
 215
 216     if in_external_macro(cx.sess(), span) && in_external_macro(cx.sess(), arg.span) {
 217         // Nothing that can be done about it in the current crate.
 218         return;
 219     }
 220
 221     let fmt_span = arg.span.source_callsite();
 222
 223     let (snippet, style) = match cx.sess().parse_sess.source_map().span_to_snippet(fmt_span) {
 224         Ok(snippet) => {
 225             // Count the number of `#`s between the `r` and `"`.
 226             let style = snippet.strip_prefix('r').and_then(|s| s.find('"'));
 227             (Some(snippet), style)
 228         }
 229         Err(_) => (None, None),
 230     };
 231
 232     let mut fmt_parser =
 233         Parser::new(fmt.as_ref(), style, snippet.clone(), false, ParseMode::Format);
 234     let n_arguments = (&mut fmt_parser).filter(|a| matches!(a, Piece::NextArgument(_))).count();
 235
 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(),
 240         };
 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",
 245             });
 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) {
 248                 l.span_suggestion(
 249                     arg.span.shrink_to_hi(),
 250                     &format!("add the missing argument{}", pluralize!(n_arguments)),
 251                     ", ...".into(),
 252                     Applicability::HasPlaceholders,
 253                 );
 254                 l.span_suggestion(
 255                     arg.span.shrink_to_lo(),
 256                     "or add a \"{}\" format string to use the message literally",
 257                     "\"{}\", ".into(),
 258                     Applicability::MachineApplicable,
 259                 );
 260             }
 261             l.emit();
 262         });
 263     } else {
 264         let brace_spans: Option<Vec<_>> =
 265             snippet.filter(|s| s.starts_with('"') || s.starts_with("r#")).map(|s| {
 266                 s.char_indices()
 267                     .filter(|&(_, c)| c == '{' || c == '}')
 268                     .map(|(i, _)| fmt_span.from_inner(InnerSpan { start: i, end: i + 1 }))
 269                     .collect()
 270             });
 271         let msg = match &brace_spans {
 272             Some(v) if v.len() == 1 => "panic message contains a brace",
 273             _ => "panic message contains braces",
 274         };
 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) {
 279                 l.span_suggestion(
 280                     arg.span.shrink_to_lo(),
 281                     "add a \"{}\" format string to use the message literally",
 282                     "\"{}\", ".into(),
 283                     Applicability::MachineApplicable,
 284                 );
 285             }
 286             l.emit();
 287         });
 288     }
 289 }
 290
 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))?;
 297     Some((
 298         span.from_inner(InnerSpan { start: open, end: open + 1 }),
 299         span.from_inner(InnerSpan { start: close, end: close + 1 }),
 300         open_ch,
 301     ))
 302 }
 303
 304 fn panic_call<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>) -> (Span, Symbol, SymbolStr) {
 305     let mut expn = f.span.ctxt().outer_expn_data();
 306
 307     let mut panic_macro = kw::Empty;
 308
 309     // Unwrap more levels of macro expansion, as panic_2015!()
 310     // was likely expanded from panic!() and possibly from
 311     // [debug_]assert!().
 312     for &i in
 313         &[sym::std_panic_macro, sym::core_panic_macro, sym::assert_macro, sym::debug_assert_macro]
 314     {
 315         let parent = expn.call_site.ctxt().outer_expn_data();
 316         if parent.macro_def_id.map_or(false, |id| cx.tcx.is_diagnostic_item(i, id)) {
 317             expn = parent;
 318             panic_macro = i;
 319         }
 320     }
 321
 322     let macro_symbol =
 323         if let hygiene::ExpnKind::Macro(_, symbol) = expn.kind { symbol } else { sym::panic };
 324     (expn.call_site, panic_macro, macro_symbol.as_str())
 325 }
 326
 327 fn is_arg_inside_call(arg: Span, call: Span) -> bool {
 328     // We only add suggestions if the argument we're looking at appears inside the
 329     // panic call in the source file, to avoid invalid suggestions when macros are involved.
 330     // We specifically check for the spans to not be identical, as that happens sometimes when
 331     // proc_macros lie about spans and apply the same span to all the tokens they produce.
 332     call.contains(arg) && !call.source_equal(&arg)
 333 }