src/tools/clippy/clippy_lints/src/unused_peekable.rs

   1 use clippy_utils::diagnostics::span_lint_and_help;
   2 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
   3 use clippy_utils::{fn_def_id, is_trait_method, path_to_local_id, peel_ref_operators};
   4 use rustc_ast::Mutability;
   5 use rustc_hir::intravisit::{walk_expr, Visitor};
   6 use rustc_hir::{Block, Expr, ExprKind, HirId, Local, Node, PatKind, PathSegment, StmtKind};
   7 use rustc_lint::{LateContext, LateLintPass};
   8 use rustc_middle::hir::nested_filter::OnlyBodies;
   9 use rustc_session::declare_lint_pass;
  10 use rustc_span::sym;
  11
  12 declare_clippy_lint! {
  13     /// ### What it does
  14     /// Checks for the creation of a `peekable` iterator that is never `.peek()`ed
  15     ///
  16     /// ### Why is this bad?
  17     /// Creating a peekable iterator without using any of its methods is likely a mistake,
  18     /// or just a leftover after a refactor.
  19     ///
  20     /// ### Example
  21     /// ```no_run
  22     /// let collection = vec![1, 2, 3];
  23     /// let iter = collection.iter().peekable();
  24     ///
  25     /// for item in iter {
  26     ///     // ...
  27     /// }
  28     /// ```
  29     ///
  30     /// Use instead:
  31     /// ```no_run
  32     /// let collection = vec![1, 2, 3];
  33     /// let iter = collection.iter();
  34     ///
  35     /// for item in iter {
  36     ///     // ...
  37     /// }
  38     /// ```
  39     #[clippy::version = "1.65.0"]
  40     pub UNUSED_PEEKABLE,
  41     nursery,
  42     "creating a peekable iterator without using any of its methods"
  43 }
  44
  45 declare_lint_pass!(UnusedPeekable => [UNUSED_PEEKABLE]);
  46
  47 impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
  48     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
  49         // Don't lint `Peekable`s returned from a block
  50         if let Some(expr) = block.expr
  51             && let Some(ty) = cx.typeck_results().expr_ty_opt(peel_ref_operators(cx, expr))
  52             && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
  53         {
  54             return;
  55         }
  56
  57         for (idx, stmt) in block.stmts.iter().enumerate() {
  58             if !stmt.span.from_expansion()
  59                 && let StmtKind::Local(local) = stmt.kind
  60                 && let PatKind::Binding(_, binding, ident, _) = local.pat.kind
  61                 && let Some(init) = local.init
  62                 && !init.span.from_expansion()
  63                 && let Some(ty) = cx.typeck_results().expr_ty_opt(init)
  64                 && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
  65                 && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
  66             {
  67                 let mut vis = PeekableVisitor::new(cx, binding);
  68
  69                 if idx + 1 == block.stmts.len() && block.expr.is_none() {
  70                     return;
  71                 }
  72
  73                 for stmt in &block.stmts[idx..] {
  74                     vis.visit_stmt(stmt);
  75                 }
  76
  77                 if let Some(expr) = block.expr {
  78                     vis.visit_expr(expr);
  79                 }
  80
  81                 if !vis.found_peek_call {
  82                     span_lint_and_help(
  83                         cx,
  84                         UNUSED_PEEKABLE,
  85                         ident.span,
  86                         "`peek` never called on `Peekable` iterator",
  87                         None,
  88                         "consider removing the call to `peekable`",
  89                     );
  90                 }
  91             }
  92         }
  93     }
  94 }
  95
  96 struct PeekableVisitor<'a, 'tcx> {
  97     cx: &'a LateContext<'tcx>,
  98     expected_hir_id: HirId,
  99     found_peek_call: bool,
 100 }
 101
 102 impl<'a, 'tcx> PeekableVisitor<'a, 'tcx> {
 103     fn new(cx: &'a LateContext<'tcx>, expected_hir_id: HirId) -> Self {
 104         Self {
 105             cx,
 106             expected_hir_id,
 107             found_peek_call: false,
 108         }
 109     }
 110 }
 111
 112 impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
 113     type NestedFilter = OnlyBodies;
 114
 115     fn nested_visit_map(&mut self) -> Self::Map {
 116         self.cx.tcx.hir()
 117     }
 118
 119     fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
 120         if self.found_peek_call {
 121             return;
 122         }
 123
 124         if path_to_local_id(ex, self.expected_hir_id) {
 125             for (_, node) in self.cx.tcx.hir().parent_iter(ex.hir_id) {
 126                 match node {
 127                     Node::Expr(expr) => {
 128                         match expr.kind {
 129                             // some_function(peekable)
 130                             //
 131                             // If the Peekable is passed to a function, stop
 132                             ExprKind::Call(_, args) => {
 133                                 if let Some(func_did) = fn_def_id(self.cx, expr)
 134                                     && let Some(into_iter_did) = self.cx.tcx.lang_items().into_iter_fn()
 135                                     && func_did == into_iter_did
 136                                 {
 137                                     // Probably a for loop desugar, stop searching
 138                                     return;
 139                                 }
 140
 141                                 if args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg)) {
 142                                     self.found_peek_call = true;
 143                                 }
 144
 145                                 return;
 146                             },
 147                             // Catch anything taking a Peekable mutably
 148                             ExprKind::MethodCall(
 149                                 PathSegment {
 150                                     ident: method_name_ident,
 151                                     ..
 152                                 },
 153                                 self_arg,
 154                                 remaining_args,
 155                                 _,
 156                             ) => {
 157                                 let method_name = method_name_ident.name.as_str();
 158
 159                                 // `Peekable` methods
 160                                 if matches!(method_name, "peek" | "peek_mut" | "next_if" | "next_if_eq")
 161                                     && arg_is_mut_peekable(self.cx, self_arg)
 162                                 {
 163                                     self.found_peek_call = true;
 164                                     return;
 165                                 }
 166
 167                                 // foo.some_method() excluding Iterator methods
 168                                 if remaining_args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg))
 169                                     && !is_trait_method(self.cx, expr, sym::Iterator)
 170                                 {
 171                                     self.found_peek_call = true;
 172                                     return;
 173                                 }
 174
 175                                 // foo.by_ref(), keep checking for `peek`
 176                                 if method_name == "by_ref" {
 177                                     continue;
 178                                 }
 179
 180                                 return;
 181                             },
 182                             ExprKind::AddrOf(_, Mutability::Mut, _) | ExprKind::Unary(..) | ExprKind::DropTemps(_) => {
 183                             },
 184                             ExprKind::AddrOf(_, Mutability::Not, _) => return,
 185                             _ => {
 186                                 self.found_peek_call = true;
 187                                 return;
 188                             },
 189                         }
 190                     },
 191                     Node::Local(Local { init: Some(init), .. }) => {
 192                         if arg_is_mut_peekable(self.cx, init) {
 193                             self.found_peek_call = true;
 194                         }
 195
 196                         return;
 197                     },
 198                     Node::Stmt(stmt) => {
 199                         match stmt.kind {
 200                             StmtKind::Local(_) | StmtKind::Item(_) => self.found_peek_call = true,
 201                             StmtKind::Expr(_) | StmtKind::Semi(_) => {},
 202                         }
 203
 204                         return;
 205                     },
 206                     Node::Block(_) | Node::ExprField(_) => {},
 207                     _ => {
 208                         return;
 209                     },
 210                 }
 211             }
 212         }
 213
 214         walk_expr(self, ex);
 215     }
 216 }
 217
 218 fn arg_is_mut_peekable(cx: &LateContext<'_>, arg: &Expr<'_>) -> bool {
 219     if let Some(ty) = cx.typeck_results().expr_ty_opt(arg)
 220         && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
 221         && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
 222     {
 223         true
 224     } else {
 225         false
 226     }
 227 }