compiler/rustc_lint/src/non_fmt_panic.rs

   1 use crate::{LateContext, LateLintPass, LintContext};
   2 use rustc_ast as ast;
   3 use rustc_errors::{fluent, 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, 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,edition2018
  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                 let f_diagnostic_name = cx.tcx.get_diagnostic_name(def_id);
  53
  54                 if Some(def_id) == cx.tcx.lang_items().begin_panic_fn()
  55                     || Some(def_id) == cx.tcx.lang_items().panic_fn()
  56                     || f_diagnostic_name == Some(sym::panic_str)
  57                 {
  58                     if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
  59                         if matches!(
  60                             cx.tcx.get_diagnostic_name(id),
  61                             Some(sym::core_panic_2015_macro | sym::std_panic_2015_macro)
  62                         ) {
  63                             check_panic(cx, f, arg);
  64                         }
  65                     }
  66                 } else if f_diagnostic_name == Some(sym::unreachable_display) {
  67                     if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
  68                         if cx.tcx.is_diagnostic_item(sym::unreachable_2015_macro, id) {
  69                             check_panic(
  70                                 cx,
  71                                 f,
  72                                 // This is safe because we checked above that the callee is indeed
  73                                 // unreachable_display
  74                                 match &arg.kind {
  75                                     // Get the borrowed arg not the borrow
  76                                     hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, arg) => arg,
  77                                     _ => bug!("call to unreachable_display without borrow"),
  78                                 },
  79                             );
  80                         }
  81                     }
  82                 }
  83             }
  84         }
  85     }
  86 }
  87
  88 fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tcx hir::Expr<'tcx>) {
  89     if let hir::ExprKind::Lit(lit) = &arg.kind {
  90         if let ast::LitKind::Str(sym, _) = lit.node {
  91             // The argument is a string literal.
  92             check_panic_str(cx, f, arg, sym.as_str());
  93             return;
  94         }
  95     }
  96
  97     // The argument is *not* a string literal.
  98
  99     let (span, panic, symbol) = panic_call(cx, f);
 100
 101     if in_external_macro(cx.sess(), span) {
 102         // Nothing that can be done about it in the current crate.
 103         return;
 104     }
 105
 106     // Find the span of the argument to `panic!()` or `unreachable!`, before expansion in the
 107     // case of `panic!(some_macro!())` or `unreachable!(some_macro!())`.
 108     // We don't use source_callsite(), because this `panic!(..)` might itself
 109     // be expanded from another macro, in which case we want to stop at that
 110     // expansion.
 111     let mut arg_span = arg.span;
 112     let mut arg_macro = None;
 113     while !span.contains(arg_span) {
 114         let expn = arg_span.ctxt().outer_expn_data();
 115         if expn.is_root() {
 116             break;
 117         }
 118         arg_macro = expn.macro_def_id;
 119         arg_span = expn.call_site;
 120     }
 121
 122     cx.struct_span_lint(NON_FMT_PANICS, arg_span, fluent::lint::non_fmt_panic, |lint| {
 123         lint.set_arg("name", symbol);
 124         lint.note(fluent::lint::note);
 125         lint.note(fluent::lint::more_info_note);
 126         if !is_arg_inside_call(arg_span, span) {
 127             // No clue where this argument is coming from.
 128             return lint;
 129         }
 130         if arg_macro.map_or(false, |id| cx.tcx.is_diagnostic_item(sym::format_macro, id)) {
 131             // A case of `panic!(format!(..))`.
 132             lint.note(fluent::lint::supports_fmt_note);
 133             if let Some((open, close, _)) = find_delimiters(cx, arg_span) {
 134                 lint.multipart_suggestion(
 135                     fluent::lint::supports_fmt_suggestion,
 136                     vec![
 137                         (arg_span.until(open.shrink_to_hi()), "".into()),
 138                         (close.until(arg_span.shrink_to_hi()), "".into()),
 139                     ],
 140                     Applicability::MachineApplicable,
 141                 );
 142             }
 143         } else {
 144             let ty = cx.typeck_results().expr_ty(arg);
 145             // If this is a &str or String, we can confidently give the `"{}", ` suggestion.
 146             let is_str = matches!(
 147                 ty.kind(),
 148                 ty::Ref(_, r, _) if *r.kind() == ty::Str,
 149             ) || matches!(
 150                 ty.ty_adt_def(),
 151                 Some(ty_def) if cx.tcx.is_diagnostic_item(sym::String, ty_def.did()),
 152             );
 153
 154             let (suggest_display, suggest_debug) = cx.tcx.infer_ctxt().enter(|infcx| {
 155                 let display = is_str
 156                     || cx.tcx.get_diagnostic_item(sym::Display).map(|t| {
 157                         infcx
 158                             .type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env)
 159                             .may_apply()
 160                     }) == Some(true);
 161                 let debug = !display
 162                     && cx.tcx.get_diagnostic_item(sym::Debug).map(|t| {
 163                         infcx
 164                             .type_implements_trait(t, ty, InternalSubsts::empty(), cx.param_env)
 165                             .may_apply()
 166                     }) == Some(true);
 167                 (display, debug)
 168             });
 169
 170             let suggest_panic_any = !is_str && panic == sym::std_panic_macro;
 171
 172             let fmt_applicability = if suggest_panic_any {
 173                 // If we can use panic_any, use that as the MachineApplicable suggestion.
 174                 Applicability::MaybeIncorrect
 175             } else {
 176                 // If we don't suggest panic_any, using a format string is our best bet.
 177                 Applicability::MachineApplicable
 178             };
 179
 180             if suggest_display {
 181                 lint.span_suggestion_verbose(
 182                     arg_span.shrink_to_lo(),
 183                     fluent::lint::display_suggestion,
 184                     "\"{}\", ",
 185                     fmt_applicability,
 186                 );
 187             } else if suggest_debug {
 188                 lint.set_arg("ty", ty);
 189                 lint.span_suggestion_verbose(
 190                     arg_span.shrink_to_lo(),
 191                     fluent::lint::debug_suggestion,
 192                     "\"{:?}\", ",
 193                     fmt_applicability,
 194                 );
 195             }
 196
 197             if suggest_panic_any {
 198                 if let Some((open, close, del)) = find_delimiters(cx, span) {
 199                     lint.set_arg("already_suggested", suggest_display || suggest_debug);
 200                     lint.multipart_suggestion(
 201                         fluent::lint::panic_suggestion,
 202                         if del == '(' {
 203                             vec![(span.until(open), "std::panic::panic_any".into())]
 204                         } else {
 205                             vec![
 206                                 (span.until(open.shrink_to_hi()), "std::panic::panic_any(".into()),
 207                                 (close, ")".into()),
 208                             ]
 209                         },
 210                         Applicability::MachineApplicable,
 211                     );
 212                 }
 213             }
 214         }
 215         lint
 216     });
 217 }
 218
 219 fn check_panic_str<'tcx>(
 220     cx: &LateContext<'tcx>,
 221     f: &'tcx hir::Expr<'tcx>,
 222     arg: &'tcx hir::Expr<'tcx>,
 223     fmt: &str,
 224 ) {
 225     if !fmt.contains(&['{', '}']) {
 226         // No brace, no problem.
 227         return;
 228     }
 229
 230     let (span, _, _) = panic_call(cx, f);
 231
 232     if in_external_macro(cx.sess(), span) && in_external_macro(cx.sess(), arg.span) {
 233         // Nothing that can be done about it in the current crate.
 234         return;
 235     }
 236
 237     let fmt_span = arg.span.source_callsite();
 238
 239     let (snippet, style) = match cx.sess().parse_sess.source_map().span_to_snippet(fmt_span) {
 240         Ok(snippet) => {
 241             // Count the number of `#`s between the `r` and `"`.
 242             let style = snippet.strip_prefix('r').and_then(|s| s.find('"'));
 243             (Some(snippet), style)
 244         }
 245         Err(_) => (None, None),
 246     };
 247
 248     let mut fmt_parser = Parser::new(fmt, style, snippet.clone(), false, ParseMode::Format);
 249     let n_arguments = (&mut fmt_parser).filter(|a| matches!(a, Piece::NextArgument(_))).count();
 250
 251     if n_arguments > 0 && fmt_parser.errors.is_empty() {
 252         let arg_spans: Vec<_> = match &fmt_parser.arg_places[..] {
 253             [] => vec![fmt_span],
 254             v => v
 255                 .iter()
 256                 .map(|span| fmt_span.from_inner(InnerSpan::new(span.start, span.end)))
 257                 .collect(),
 258         };
 259         cx.struct_span_lint(
 260             NON_FMT_PANICS,
 261             arg_spans,
 262             fluent::lint::non_fmt_panic_unused,
 263             |lint| {
 264                 lint.set_arg("count", n_arguments);
 265                 lint.note(fluent::lint::note);
 266                 if is_arg_inside_call(arg.span, span) {
 267                     lint.span_suggestion(
 268                         arg.span.shrink_to_hi(),
 269                         fluent::lint::add_args_suggestion,
 270                         ", ...",
 271                         Applicability::HasPlaceholders,
 272                     );
 273                     lint.span_suggestion(
 274                         arg.span.shrink_to_lo(),
 275                         fluent::lint::add_fmt_suggestion,
 276                         "\"{}\", ",
 277                         Applicability::MachineApplicable,
 278                     );
 279                 }
 280                 lint
 281             },
 282         );
 283     } else {
 284         let brace_spans: Option<Vec<_>> =
 285             snippet.filter(|s| s.starts_with('"') || s.starts_with("r#")).map(|s| {
 286                 s.char_indices()
 287                     .filter(|&(_, c)| c == '{' || c == '}')
 288                     .map(|(i, _)| fmt_span.from_inner(InnerSpan { start: i, end: i + 1 }))
 289                     .collect()
 290             });
 291         let count = brace_spans.as_ref().map(|v| v.len()).unwrap_or(/* any number >1 */ 2);
 292         cx.struct_span_lint(
 293             NON_FMT_PANICS,
 294             brace_spans.unwrap_or_else(|| vec![span]),
 295             fluent::lint::non_fmt_panic_braces,
 296             |lint| {
 297                 lint.set_arg("count", count);
 298                 lint.note(fluent::lint::note);
 299                 if is_arg_inside_call(arg.span, span) {
 300                     lint.span_suggestion(
 301                         arg.span.shrink_to_lo(),
 302                         fluent::lint::suggestion,
 303                         "\"{}\", ",
 304                         Applicability::MachineApplicable,
 305                     );
 306                 }
 307                 lint
 308             },
 309         );
 310     }
 311 }
 312
 313 /// Given the span of `some_macro!(args);`, gives the span of `(` and `)`,
 314 /// and the type of (opening) delimiter used.
 315 fn find_delimiters<'tcx>(cx: &LateContext<'tcx>, span: Span) -> Option<(Span, Span, char)> {
 316     let snippet = cx.sess().parse_sess.source_map().span_to_snippet(span).ok()?;
 317     let (open, open_ch) = snippet.char_indices().find(|&(_, c)| "([{".contains(c))?;
 318     let close = snippet.rfind(|c| ")]}".contains(c))?;
 319     Some((
 320         span.from_inner(InnerSpan { start: open, end: open + 1 }),
 321         span.from_inner(InnerSpan { start: close, end: close + 1 }),
 322         open_ch,
 323     ))
 324 }
 325
 326 fn panic_call<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>) -> (Span, Symbol, Symbol) {
 327     let mut expn = f.span.ctxt().outer_expn_data();
 328
 329     let mut panic_macro = kw::Empty;
 330
 331     // Unwrap more levels of macro expansion, as panic_2015!()
 332     // was likely expanded from panic!() and possibly from
 333     // [debug_]assert!().
 334     loop {
 335         let parent = expn.call_site.ctxt().outer_expn_data();
 336         let Some(id) = parent.macro_def_id else { break };
 337         let Some(name) = cx.tcx.get_diagnostic_name(id) else { break };
 338         if !matches!(
 339             name,
 340             sym::core_panic_macro
 341                 | sym::std_panic_macro
 342                 | sym::assert_macro
 343                 | sym::debug_assert_macro
 344                 | sym::unreachable_macro
 345         ) {
 346             break;
 347         }
 348         expn = parent;
 349         panic_macro = name;
 350     }
 351
 352     let macro_symbol =
 353         if let hygiene::ExpnKind::Macro(_, symbol) = expn.kind { symbol } else { sym::panic };
 354     (expn.call_site, panic_macro, macro_symbol)
 355 }
 356
 357 fn is_arg_inside_call(arg: Span, call: Span) -> bool {
 358     // We only add suggestions if the argument we're looking at appears inside the
 359     // panic call in the source file, to avoid invalid suggestions when macros are involved.
 360     // We specifically check for the spans to not be identical, as that happens sometimes when
 361     // proc_macros lie about spans and apply the same span to all the tokens they produce.
 362     call.contains(arg) && !call.source_equal(arg)
 363 }