unnecessary_reserve: address review comments

Author: wowinter13

clippy_lints/src/unnecessary_reserve.rs

@@ -6,7 +6,7 @@ use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{SpanlessEq, get_enclosing_block, match_def_path, paths};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, PathSegment};
+use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
@@ -56,11 +56,11 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve {
             return;
         }
 
-        if let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, args_a, _) = expr.kind
-            && method.name.as_str() == "reserve"
-            && acceptable_type(cx, struct_calling_on)
+        if let ExprKind::MethodCall(method, receiver, [arg], _) = expr.kind
+            && method.ident.name.as_str() == "reserve"
+            && acceptable_type(cx, receiver)
             && let Some(block) = get_enclosing_block(cx, expr.hir_id)
-            && let Some(next_stmt_span) = check_extend_method(cx, block, struct_calling_on, &args_a[0])
+            && let Some(next_stmt_span) = check_extend_method(cx, block, receiver, arg)
             && !next_stmt_span.from_expansion()
         {
             let stmt_span = cx
@@ -91,50 +91,36 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve {
 }
 
 fn acceptable_type(cx: &LateContext<'_>, struct_calling_on: &Expr<'_>) -> bool {
-    if let Some(did) = adt_def_id(cx.typeck_results().expr_ty_adjusted(struct_calling_on)) {
-        matches!(cx.tcx.get_diagnostic_name(did), Some(sym::Vec | sym::VecDeque))
-    } else {
-        false
-    }
+    adt_def_id(cx.typeck_results().expr_ty_adjusted(struct_calling_on))
+        .is_some_and(|did| matches!(cx.tcx.get_diagnostic_name(did), Some(sym::Vec | sym::VecDeque)))
 }
 
 #[must_use]
 fn check_extend_method<'tcx>(
     cx: &LateContext<'tcx>,
     block: &'tcx Block<'tcx>,
     struct_expr: &Expr<'tcx>,
-    args_a: &Expr<'tcx>,
+    arg: &Expr<'tcx>,
 ) -> Option<rustc_span::Span> {
     let mut found_reserve = false;
-    let mut read_found = false;
-    let mut spanless_eq = SpanlessEq::new(cx);
+    let mut spanless_eq = SpanlessEq::new(cx).deny_side_effects();
 
-    let _: Option<!> = for_each_expr(cx, block, |expr: &Expr<'tcx>| {
+    for_each_expr(cx, block, |expr: &Expr<'tcx>| {
         if !found_reserve {
-            if expr.hir_id == args_a.hir_id {
-                found_reserve = true;
-            }
+            found_reserve = expr.hir_id == arg.hir_id;
             return ControlFlow::Continue(());
         }
 
-        if let ExprKind::MethodCall(_, struct_calling_on, _, _) = expr.kind
+        if let ExprKind::MethodCall(_method, struct_calling_on, _, _) = expr.kind
             && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-            && let ExprKind::MethodCall(
-                PathSegment {
-                    ident: method_call_a, ..
-                },
-                ..,
-            ) = args_a.kind
-            && method_call_a.name == sym::len
+            && let ExprKind::MethodCall(len_method, ..) = arg.kind
+            && len_method.ident.name == sym::len
             && match_def_path(cx, expr_def_id, &paths::ITER_EXTEND)
             && acceptable_type(cx, struct_calling_on)
             && spanless_eq.eq_expr(struct_calling_on, struct_expr)
         {
-            read_found = true;
+            return ControlFlow::Break(block.span);
         }
-        let _: bool = !read_found;
         ControlFlow::Continue(())
-    });
-
-    if read_found { Some(block.span) } else { None }
+    })
 }