|
| 1 | +use clippy_utils::diagnostics::span_lint; |
| 2 | +use clippy_utils::format_macros::is_format_macro; |
| 3 | +use clippy_utils::macros::{root_macro_call, FormatArgsArg, FormatArgsExpn}; |
| 4 | +use clippy_utils::{is_diag_trait_item, path_to_local}; |
| 5 | +use if_chain::if_chain; |
| 6 | +use rustc_hir::{Expr, ExprKind, Impl, Item, ItemKind, UnOp}; |
| 7 | +use rustc_lint::{LateContext, LateLintPass}; |
| 8 | +use rustc_session::{declare_tool_lint, impl_lint_pass}; |
| 9 | +use rustc_span::{sym, symbol::kw, Symbol}; |
| 10 | + |
| 11 | +#[derive(Clone, Copy)] |
| 12 | +enum FormatTrait { |
| 13 | + Debug, |
| 14 | + Display, |
| 15 | +} |
| 16 | + |
| 17 | +impl FormatTrait { |
| 18 | + fn name(self) -> Symbol { |
| 19 | + match self { |
| 20 | + FormatTrait::Debug => sym::Debug, |
| 21 | + FormatTrait::Display => sym::Display, |
| 22 | + } |
| 23 | + } |
| 24 | +} |
| 25 | + |
| 26 | +declare_clippy_lint! { |
| 27 | + /// ### What it does |
| 28 | + /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself |
| 29 | + /// which uses `self` as a parameter. |
| 30 | + /// This is typically done indirectly with the `write!` macro or with `to_string()`. |
| 31 | + /// |
| 32 | + /// ### Why is this bad? |
| 33 | + /// This will lead to infinite recursion and a stack overflow. |
| 34 | + /// |
| 35 | + /// ### Example |
| 36 | + /// |
| 37 | + /// ```rust |
| 38 | + /// use std::fmt; |
| 39 | + /// |
| 40 | + /// struct Structure(i32); |
| 41 | + /// impl fmt::Display for Structure { |
| 42 | + /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| 43 | + /// write!(f, "{}", self.to_string()) |
| 44 | + /// } |
| 45 | + /// } |
| 46 | + /// |
| 47 | + /// ``` |
| 48 | + /// Use instead: |
| 49 | + /// ```rust |
| 50 | + /// use std::fmt; |
| 51 | + /// |
| 52 | + /// struct Structure(i32); |
| 53 | + /// impl fmt::Display for Structure { |
| 54 | + /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| 55 | + /// write!(f, "{}", self.0) |
| 56 | + /// } |
| 57 | + /// } |
| 58 | + /// ``` |
| 59 | + #[clippy::version = "1.48.0"] |
| 60 | + pub RECURSIVE_FORMAT_IMPL, |
| 61 | + correctness, |
| 62 | + "Format trait method called while implementing the same Format trait" |
| 63 | +} |
| 64 | + |
| 65 | +#[derive(Default)] |
| 66 | +pub struct RecursiveFormatImpl { |
| 67 | + // Whether we are inside Display or Debug trait impl - None for neither |
| 68 | + format_trait_impl: Option<FormatTrait>, |
| 69 | +} |
| 70 | + |
| 71 | +impl RecursiveFormatImpl { |
| 72 | + pub fn new() -> Self { |
| 73 | + Self { |
| 74 | + format_trait_impl: None, |
| 75 | + } |
| 76 | + } |
| 77 | +} |
| 78 | + |
| 79 | +impl_lint_pass!(RecursiveFormatImpl => [RECURSIVE_FORMAT_IMPL]); |
| 80 | + |
| 81 | +impl LateLintPass<'_> for RecursiveFormatImpl { |
| 82 | + fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) { |
| 83 | + if let Some(format_trait_impl) = is_format_trait_impl(cx, item) { |
| 84 | + self.format_trait_impl = Some(format_trait_impl); |
| 85 | + } |
| 86 | + } |
| 87 | + |
| 88 | + fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) { |
| 89 | + // Assume no nested Impl of Debug and Display within eachother |
| 90 | + if is_format_trait_impl(cx, item).is_some() { |
| 91 | + self.format_trait_impl = None; |
| 92 | + } |
| 93 | + } |
| 94 | + |
| 95 | + fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { |
| 96 | + match self.format_trait_impl { |
| 97 | + Some(FormatTrait::Display) => { |
| 98 | + check_to_string_in_display(cx, expr); |
| 99 | + check_self_in_format_args(cx, expr, FormatTrait::Display); |
| 100 | + }, |
| 101 | + Some(FormatTrait::Debug) => { |
| 102 | + check_self_in_format_args(cx, expr, FormatTrait::Debug); |
| 103 | + }, |
| 104 | + None => {}, |
| 105 | + } |
| 106 | + } |
| 107 | +} |
| 108 | + |
| 109 | +fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) { |
| 110 | + let map = cx.tcx.hir(); |
| 111 | + if_chain! { |
| 112 | + // Get the hir_id of the object we are calling the method on |
| 113 | + if let ExprKind::MethodCall(path, _, [ref self_arg, ..], _) = expr.kind; |
| 114 | + // Is the method to_string() ? |
| 115 | + if path.ident.name == sym!(to_string); |
| 116 | + // Is the method a part of the ToString trait? (i.e. not to_string() implemented |
| 117 | + // separately) |
| 118 | + if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id); |
| 119 | + if is_diag_trait_item(cx, expr_def_id, sym::ToString); |
| 120 | + // Is the method is called on self |
| 121 | + if path_to_local(self_arg).map(|x| map.name(x)) == Some(kw::SelfLower); |
| 122 | + then { |
| 123 | + span_lint( |
| 124 | + cx, |
| 125 | + RECURSIVE_FORMAT_IMPL, |
| 126 | + expr.span, |
| 127 | + "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion", |
| 128 | + ); |
| 129 | + } |
| 130 | + } |
| 131 | +} |
| 132 | + |
| 133 | +fn check_self_in_format_args(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTrait) { |
| 134 | + // Check each arg in format calls - do we ever use Display on self (directly or via deref)? |
| 135 | + if_chain! { |
| 136 | + if let Some(macro_call) = root_macro_call(expr.span); |
| 137 | + if let Some(format_args) = FormatArgsExpn::parse(cx, expr); |
| 138 | + if let macro_def_id = macro_call.def_id; |
| 139 | + if is_format_macro(cx, macro_def_id); |
| 140 | + if let Some(args) = format_args.args(); |
| 141 | + then { |
| 142 | + for arg in args { |
| 143 | + if arg.format_trait != impl_trait.name() { |
| 144 | + continue; |
| 145 | + } |
| 146 | + check_format_arg_self(cx, expr, &arg, impl_trait); |
| 147 | + } |
| 148 | + } |
| 149 | + } |
| 150 | +} |
| 151 | + |
| 152 | +fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgsArg<'_>, impl_trait: FormatTrait) { |
| 153 | + // Handle multiple dereferencing of references e.g. &&self |
| 154 | + // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl) |
| 155 | + // Since the argument to fmt is itself a reference: &self |
| 156 | + let reference = deref_expr(arg.value); |
| 157 | + let map = cx.tcx.hir(); |
| 158 | + // Is the reference self? |
| 159 | + let symbol_ident = impl_trait.name().to_ident_string(); |
| 160 | + if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) { |
| 161 | + span_lint( |
| 162 | + cx, |
| 163 | + RECURSIVE_FORMAT_IMPL, |
| 164 | + expr.span, |
| 165 | + &format!( |
| 166 | + "using `self` as `{}` in `impl {}` will cause infinite recursion", |
| 167 | + &symbol_ident, &symbol_ident |
| 168 | + ), |
| 169 | + ); |
| 170 | + } |
| 171 | +} |
| 172 | + |
| 173 | +fn deref_expr<'a, 'b>(expr: &'a Expr<'b>) -> &'a Expr<'b> { |
| 174 | + match expr.kind { |
| 175 | + ExprKind::Unary(UnOp::Deref, ex) => match ex.kind { |
| 176 | + ExprKind::Unary(..) => expr, |
| 177 | + _ => deref_expr(ex), |
| 178 | + }, |
| 179 | + ExprKind::AddrOf(_, _, reference) => deref_expr(reference), |
| 180 | + _ => expr, |
| 181 | + } |
| 182 | +} |
| 183 | + |
| 184 | +fn is_format_trait_impl(cx: &LateContext<'_>, item: &Item<'_>) -> Option<FormatTrait> { |
| 185 | + if_chain! { |
| 186 | + // Are we at an Impl? |
| 187 | + if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind; |
| 188 | + if let Some(did) = trait_ref.trait_def_id(); |
| 189 | + if let Some(name) = cx.tcx.get_diagnostic_name(did); |
| 190 | + then { |
| 191 | + // Is Impl for Debug or Display? |
| 192 | + match name { |
| 193 | + sym::Debug => Some(FormatTrait::Debug), |
| 194 | + sym::Display => Some(FormatTrait::Display), |
| 195 | + _ => None, |
| 196 | + } |
| 197 | + } else { |
| 198 | + None |
| 199 | + } |
| 200 | + } |
| 201 | +} |
0 commit comments