1 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
2 use clippy_utils::higher::{FormatArgsArg, FormatArgsExpn, FormatExpn};
3 use clippy_utils::source::snippet_opt;
4 use clippy_utils::ty::implements_trait;
5 use clippy_utils::{is_diag_trait_item, match_def_path, paths};
6 use if_chain::if_chain;
7 use rustc_errors::Applicability;
8 use rustc_hir::{Expr, ExprKind};
9 use rustc_lint::{LateContext, LateLintPass};
10 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
11 use rustc_middle::ty::Ty;
12 use rustc_session::{declare_lint_pass, declare_tool_lint};
13 use rustc_span::{sym, BytePos, ExpnData, ExpnKind, Span, Symbol};
15 declare_clippy_lint! {
17 /// Detects `format!` within the arguments of another macro that does
18 /// formatting such as `format!` itself, `write!` or `println!`. Suggests
19 /// inlining the `format!` call.
21 /// ### Why is this bad?
22 /// The recommended code is both shorter and avoids a temporary allocation.
26 /// # use std::panic::Location;
27 /// println!("error: {}", format!("something failed at {}", Location::caller()));
31 /// # use std::panic::Location;
32 /// println!("error: something failed at {}", Location::caller());
34 pub FORMAT_IN_FORMAT_ARGS,
36 "`format!` used in a macro that does formatting"
39 declare_clippy_lint! {
41 /// Checks for [`ToString::to_string`](https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string)
42 /// applied to a type that implements [`Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html)
43 /// in a macro that does formatting.
45 /// ### Why is this bad?
46 /// Since the type implements `Display`, the use of `to_string` is
51 /// # use std::panic::Location;
52 /// println!("error: something failed at {}", Location::caller().to_string());
56 /// # use std::panic::Location;
57 /// println!("error: something failed at {}", Location::caller());
59 pub TO_STRING_IN_FORMAT_ARGS,
61 "`to_string` applied to a type that implements `Display` in format args"
64 declare_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
66 const FORMAT_MACRO_PATHS: &[&[&str]] = &[
67 &paths::FORMAT_ARGS_MACRO,
68 &paths::ASSERT_EQ_MACRO,
70 &paths::ASSERT_NE_MACRO,
72 &paths::EPRINTLN_MACRO,
74 &paths::PRINTLN_MACRO,
76 &paths::WRITELN_MACRO,
79 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_macro];
81 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
82 fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
84 if let Some(format_args) = FormatArgsExpn::parse(expr);
85 let expr_expn_data = expr.span.ctxt().outer_expn_data();
86 let outermost_expn_data = outermost_expn_data(expr_expn_data);
87 if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
90 .any(|path| match_def_path(cx, macro_def_id, path))
91 || FORMAT_MACRO_DIAG_ITEMS
93 .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, macro_def_id));
94 if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
95 if let Some(args) = format_args.args();
97 for (i, arg) in args.iter().enumerate() {
98 if !arg.is_display() {
101 if arg.has_string_formatting() {
104 if is_aliased(&args, i) {
107 check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg);
108 check_to_string_in_format_args(cx, name, arg);
115 fn outermost_expn_data(expn_data: ExpnData) -> ExpnData {
116 if expn_data.call_site.from_expansion() {
117 outermost_expn_data(expn_data.call_site.ctxt().outer_expn_data())
123 fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &FormatArgsArg<'_>) {
125 if FormatExpn::parse(arg.value).is_some();
126 if !arg.value.span.ctxt().outer_expn_data().call_site.from_expansion();
130 FORMAT_IN_FORMAT_ARGS,
131 trim_semicolon(cx, call_site),
132 &format!("`format!` in `{}!` args", name),
135 "combine the `format!(..)` arguments with the outer `{}!(..)` call",
138 diag.help("or consider changing `format!` to `format_args!`");
145 fn check_to_string_in_format_args<'tcx>(cx: &LateContext<'tcx>, name: Symbol, arg: &FormatArgsArg<'tcx>) {
146 let value = arg.value;
148 if !value.span.from_expansion();
149 if let ExprKind::MethodCall(_, _, [receiver], _) = value.kind;
150 if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id);
151 if is_diag_trait_item(cx, method_def_id, sym::ToString);
152 let receiver_ty = cx.typeck_results().expr_ty(receiver);
153 if let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display);
154 if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
156 let (n_needed_derefs, target) = count_needed_derefs(
158 cx.typeck_results().expr_adjustments(receiver).iter(),
160 if implements_trait(cx, target, display_trait_id, &[]) {
161 if n_needed_derefs == 0 {
164 TO_STRING_IN_FORMAT_ARGS,
165 value.span.with_lo(receiver.span.hi()),
166 &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
169 Applicability::MachineApplicable,
174 TO_STRING_IN_FORMAT_ARGS,
176 &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
178 format!("{:*>width$}{}", "", receiver_snippet, width = n_needed_derefs),
179 Applicability::MachineApplicable,
187 // Returns true if `args[i]` "refers to" or "is referred to by" another argument.
188 fn is_aliased(args: &[FormatArgsArg<'_>], i: usize) -> bool {
189 let value = args[i].value;
192 .any(|(j, arg)| i != j && std::ptr::eq(value, arg.value))
195 fn trim_semicolon(cx: &LateContext<'_>, span: Span) -> Span {
196 snippet_opt(cx, span).map_or(span, |snippet| {
197 let snippet = snippet.trim_end_matches(';');
198 span.with_hi(span.lo() + BytePos(u32::try_from(snippet.len()).unwrap()))
202 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
204 I: Iterator<Item = &'tcx Adjustment<'tcx>>,
207 let mut n_needed = 0;
209 if let Some(Adjustment {
210 kind: Adjust::Deref(overloaded_deref),
215 if overloaded_deref.is_some() {
220 return (n_needed, ty);