Apply suggestions

Author: blyxyas

clippy_lints/src/if_let_mutex.rs

@@ -45,21 +45,23 @@ declare_lint_pass!(IfLetMutex => [IF_LET_MUTEX]);
 
 impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        let mut arm_visit = ArmVisitor { found_mutex: None, cx };
-        let mut op_visit = OppVisitor { found_mutex: None, cx };
+        let mut arm_visit = ArmVisitor { cx };
+        let mut op_visit = OppVisitor { cx };
         if let Some(higher::IfLet {
             let_expr,
             if_then,
             if_else: Some(if_else),
             ..
         }) = higher::IfLet::hir(cx, expr)
         {
-            op_visit.visit_expr(let_expr);
-            if let Some(op_mutex) = op_visit.found_mutex {
-                arm_visit.visit_expr(if_then);
-                arm_visit.visit_expr(if_else);
+            let found_op_mutex = op_visit.visit_expr(let_expr).break_value();
+            if let Some(op_mutex) = found_op_mutex {
+                let mut found_mutex = arm_visit.visit_expr(if_then).break_value();
+                if found_mutex.is_none() {
+                    found_mutex = arm_visit.visit_expr(if_else).break_value();
+                };
 
-                if let Some(arm_mutex) = arm_visit.found_mutex_if_same_as(op_mutex) {
+                if let Some(arm_mutex) = arm_visit.found_mutex_if_same_as(op_mutex, found_mutex) {
                     let diag = |diag: &mut Diag<'_, ()>| {
                         diag.span_label(
                             op_mutex.span,
@@ -86,43 +88,37 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
 
 /// Checks if `Mutex::lock` is called in the `if let` expr.
 pub struct OppVisitor<'a, 'tcx> {
-    found_mutex: Option<&'tcx Expr<'tcx>>,
     cx: &'a LateContext<'tcx>,
 }
 
 impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
-    type Result = ControlFlow<()>;
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<()> {
+    type Result = ControlFlow<&'tcx Expr<'tcx>>;
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<&'tcx Expr<'tcx>> {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
-            self.found_mutex = Some(mutex);
-            return ControlFlow::Break(());
+            return ControlFlow::Break(mutex);
         }
-        visit::walk_expr(self, expr);
-        ControlFlow::Continue(())
+        visit::walk_expr(self, expr)
     }
 }
 
 /// Checks if `Mutex::lock` is called in any of the branches.
 pub struct ArmVisitor<'a, 'tcx> {
-    found_mutex: Option<&'tcx Expr<'tcx>>,
     cx: &'a LateContext<'tcx>,
 }
 
 impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
-    type Result = ControlFlow<()>;
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {
+    type Result = ControlFlow<&'tcx Expr<'tcx>>;
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<&'tcx Expr<'tcx>> {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
-            self.found_mutex = Some(mutex);
-            return ControlFlow::Break(());
+            return ControlFlow::Break(mutex);
         }
-        visit::walk_expr(self, expr);
-        ControlFlow::Continue(())
+        visit::walk_expr(self, expr)
     }
 }
 
 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
-    fn found_mutex_if_same_as(&self, op_mutex: &Expr<'_>) -> Option<&Expr<'_>> {
-        self.found_mutex.and_then(|arm_mutex| {
+    fn found_mutex_if_same_as(&self, op_mutex: &Expr<'_>, found_mutex: Option<&'tcx Expr<'tcx>>) -> Option<&Expr<'_>> {
+        found_mutex.and_then(|arm_mutex| {
             SpanlessEq::new(self.cx)
                 .eq_expr(op_mutex, arm_mutex)
                 .then_some(arm_mutex)

clippy_lints/src/lib.rs

@@ -1,6 +1,7 @@
 #![feature(array_windows)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
+#![feature(control_flow_enum)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]

clippy_lints/src/lifetimes.rs

@@ -381,11 +381,8 @@ fn could_use_elision<'tcx>(
             return None;
         }
 
-        let mut checker = BodyLifetimeChecker {
-            lifetimes_used_in_body: false,
-        };
-        checker.visit_expr(body.value);
-        if checker.lifetimes_used_in_body {
+        let mut checker = BodyLifetimeChecker;
+        if checker.visit_expr(body.value).is_break() {
             return None;
         }
     }
@@ -695,16 +692,13 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
     }
 }
 
-struct BodyLifetimeChecker {
-    lifetimes_used_in_body: bool,
-}
+struct BodyLifetimeChecker;
 
 impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {
     type Result = ControlFlow<()>;
     // for lifetimes as parameters of generics
     fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) -> ControlFlow<()> {
         if !lifetime.is_anonymous() && lifetime.ident.name != kw::StaticLifetime {
-            self.lifetimes_used_in_body = true;
             return ControlFlow::Break(());
         }
         ControlFlow::Continue(())

clippy_lints/src/loops/mut_range_bound.rs

@@ -145,7 +145,6 @@ impl<'tcx> Visitor<'tcx> for BreakAfterExprVisitor {
 
             return ControlFlow::Break(());
         }
-        intravisit::walk_expr(self, expr);
-        ControlFlow::Continue(())
+        intravisit::walk_expr(self, expr)
     }
 }

clippy_lints/src/loops/while_immutable_condition.rs

@@ -36,11 +36,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
         };
     let mutable_static_in_cond = var_visitor.def_ids.items().any(|(_, v)| *v);
 
-    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
-        has_break_or_return: false,
-    };
-    has_break_or_return_visitor.visit_expr(expr);
-    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
+    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor;
+    let has_break_or_return = has_break_or_return_visitor.visit_expr(expr).is_break();
 
     if no_cond_variable_mutated && !mutable_static_in_cond {
         span_lint_and_then(
@@ -60,23 +57,19 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
     }
 }
 
-struct HasBreakOrReturnVisitor {
-    has_break_or_return: bool,
-}
+struct HasBreakOrReturnVisitor;
 
 impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
     type Result = ControlFlow<()>;
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<()> {
         match expr.kind {
             ExprKind::Ret(_) | ExprKind::Break(_, _) => {
-                self.has_break_or_return = true;
                 return ControlFlow::Break(());
             },
             _ => {},
         }
 
-        walk_expr(self, expr);
-        ControlFlow::Continue(())
+        walk_expr(self, expr)
     }
 }
 

clippy_lints/src/methods/option_map_unwrap_or.rs

@@ -55,17 +55,16 @@ pub(super) fn check<'tcx>(
             let mut reference_visitor = ReferenceVisitor {
                 cx,
                 identifiers: unwrap_visitor.identifiers,
-                found_reference: false,
                 unwrap_or_span: unwrap_arg.span,
             };
 
             let map = cx.tcx.hir();
             let body = map.body(map.body_owned_by(map.enclosing_body_owner(expr.hir_id)));
-            reference_visitor.visit_body(body);
-
-            if reference_visitor.found_reference {
+            
+            // Visit the body, and return if we've found a reference
+            if reference_visitor.visit_body(body).is_break() {
                 return;
-            }
+            };
         }
 
         if !unwrap_arg.span.eq_ctxt(map_span) {
@@ -152,7 +151,6 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrapVisitor<'a, 'tcx> {
 struct ReferenceVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     identifiers: FxHashSet<HirId>,
-    found_reference: bool,
     unwrap_or_span: Span,
 }
 
@@ -171,11 +169,9 @@ impl<'a, 'tcx> Visitor<'tcx> for ReferenceVisitor<'a, 'tcx> {
             && let PatKind::Binding(_, local_id, ..) = pat.kind
             && self.identifiers.contains(&local_id)
         {
-            self.found_reference = true;
             return ControlFlow::Break(());
         }
-        rustc_hir::intravisit::walk_expr(self, expr);
-        ControlFlow::Continue(())
+        rustc_hir::intravisit::walk_expr(self, expr)
     }
 
     fn nested_visit_map(&mut self) -> Self::Map {

clippy_lints/src/redundant_closure_call.rs

@@ -61,8 +61,7 @@ impl<'tcx> Visitor<'tcx> for ReturnVisitor {
             self.found_return = true;
             return ControlFlow::Break(());
         }
-        hir_visit::walk_expr(self, ex);
-        ControlFlow::Continue(())
+        hir_visit::walk_expr(self, ex)
     }
 }
 

clippy_lints/src/unused_peekable.rs

@@ -216,8 +216,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
             }
         }
 
-        walk_expr(self, ex);
-        ControlFlow::Continue(())
+        walk_expr(self, ex)
     }
 }