Fix tests

blyxyas · blyxyas · commit b3f22fd49bfa · 2024-05-29T19:56:01.000+02:00
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
@@ -7,6 +7,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -90,12 +91,14 @@ pub struct OppVisitor<'a, 'tcx> {
 }
 
 impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+    type Result = ControlFlow<()>;
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<()> {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
             self.found_mutex = Some(mutex);
-            return;
+            return ControlFlow::Break(());
         }
         visit::walk_expr(self, expr);
+        ControlFlow::Continue(())
     }
 }
 
@@ -106,12 +109,14 @@ pub struct ArmVisitor<'a, 'tcx> {
 }
 
 impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+    type Result = ControlFlow<()>;
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
             self.found_mutex = Some(mutex);
-            return;
+            return ControlFlow::Break(());
         }
         visit::walk_expr(self, expr);
+        ControlFlow::Continue(())
     }
 }
 
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
@@ -22,6 +22,7 @@ use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::Span;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -699,10 +700,13 @@ 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) {
+    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(())
     }
 }
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
@@ -8,6 +8,7 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty;
 use rustc_span::Span;
+use std::ops::ControlFlow;
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
     if let Some(higher::Range {
@@ -114,7 +115,6 @@ impl MutatePairDelegate<'_, '_> {
 struct BreakAfterExprVisitor {
     hir_id: HirId,
     past_expr: bool,
-    past_candidate: bool,
     break_after_expr: bool,
 }
 
@@ -123,7 +123,6 @@ impl BreakAfterExprVisitor {
         let mut visitor = BreakAfterExprVisitor {
             hir_id,
             past_expr: false,
-            past_candidate: false,
             break_after_expr: false,
         };
 
@@ -135,21 +134,18 @@ impl BreakAfterExprVisitor {
 }
 
 impl<'tcx> Visitor<'tcx> for BreakAfterExprVisitor {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if self.past_candidate {
-            return;
-        }
-
+    type Result = ControlFlow<()>;
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {
         if expr.hir_id == self.hir_id {
             self.past_expr = true;
         } else if self.past_expr {
             if matches!(&expr.kind, ExprKind::Break(..)) {
                 self.break_after_expr = true;
             }
 
-            self.past_candidate = true;
-        } else {
-            intravisit::walk_expr(self, expr);
+            return ControlFlow::Break(());
         }
+        intravisit::walk_expr(self, expr);
+        ControlFlow::Continue(())
     }
 }
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -7,6 +7,7 @@ use rustc_hir::def_id::DefIdMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Expr, ExprKind, HirIdSet, QPath};
 use rustc_lint::LateContext;
+use std::ops::ControlFlow;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
     if constant(cx, cx.typeck_results(), cond).is_some() {
@@ -64,20 +65,18 @@ struct HasBreakOrReturnVisitor {
 }
 
 impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.has_break_or_return {
-            return;
-        }
-
+    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;
+                return ControlFlow::Break(());
             },
             _ => {},
         }
 
         walk_expr(self, expr);
+        ControlFlow::Continue(())
     }
 }
 
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -10,6 +10,7 @@ use rustc_hir::{ExprKind, HirId, Node, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_span::{sym, Span};
+use std::ops::ControlFlow;
 
 use super::MAP_UNWRAP_OR;
 
@@ -157,23 +158,24 @@ struct ReferenceVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for ReferenceVisitor<'a, 'tcx> {
     type NestedFilter = nested_filter::All;
-    fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'_>) {
+    type Result = ControlFlow<()>;
+    fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'_>) -> ControlFlow<()> {
         // If we haven't found a reference yet, check if this references
         // one of the locals that was moved in the `unwrap_or` argument.
         // We are only interested in exprs that appear before the `unwrap_or` call.
-        if !self.found_reference {
-            if expr.span < self.unwrap_or_span
-                && let ExprKind::Path(ref path) = expr.kind
-                && let QPath::Resolved(_, path) = path
-                && let Res::Local(local_id) = path.res
-                && let Node::Pat(pat) = self.cx.tcx.hir_node(local_id)
-                && let PatKind::Binding(_, local_id, ..) = pat.kind
-                && self.identifiers.contains(&local_id)
-            {
-                self.found_reference = true;
-            }
-            rustc_hir::intravisit::walk_expr(self, expr);
+        if expr.span < self.unwrap_or_span
+            && let ExprKind::Path(ref path) = expr.kind
+            && let QPath::Resolved(_, path) = path
+            && let Res::Local(local_id) = path.res
+            && let Node::Pat(pat) = self.cx.tcx.hir_node(local_id)
+            && 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(())
     }
 
     fn nested_visit_map(&mut self) -> Self::Map {
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
@@ -14,6 +14,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 use rustc_span::ExpnKind;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -54,12 +55,14 @@ impl ReturnVisitor {
 }
 
 impl<'tcx> Visitor<'tcx> for ReturnVisitor {
-    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
+    type Result = ControlFlow<()>;
+    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) -> ControlFlow<()> {
         if let ExprKind::Ret(_) | ExprKind::Match(.., hir::MatchSource::TryDesugar(_)) = ex.kind {
             self.found_return = true;
-        } else {
-            hir_visit::walk_expr(self, ex);
+            return ControlFlow::Break(());
         }
+        hir_visit::walk_expr(self, ex);
+        ControlFlow::Continue(())
     }
 }
 
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
@@ -16,6 +16,7 @@ use rustc_session::impl_lint_pass;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -285,15 +286,13 @@ where
     'tcx: 'a,
 {
     type NestedFilter = nested_filter::OnlyBodies;
+    type Result = ControlFlow<()>;
 
     fn nested_visit_map(&mut self) -> Self::Map {
         self.map
     }
 
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if self.found_default_call {
-            return;
-        }
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {
         walk_expr(self, expr);
 
         if let ExprKind::Call(f, _) = expr.kind
@@ -305,7 +304,9 @@ where
         {
             self.found_default_call = true;
             span_error(self.cx, self.method_span, expr);
+            return ControlFlow::Break(());
         }
+        ControlFlow::Continue(())
     }
 }
 
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
@@ -8,6 +8,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -113,16 +114,13 @@ impl<'a, 'tcx> PeekableVisitor<'a, 'tcx> {
 
 impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
     type NestedFilter = OnlyBodies;
+    type Result = ControlFlow<()>;
 
     fn nested_visit_map(&mut self) -> Self::Map {
         self.cx.tcx.hir()
     }
 
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if self.found_peek_call {
-            return;
-        }
-
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) -> ControlFlow<()> {
         if path_to_local_id(ex, self.expected_hir_id) {
             for (_, node) in self.cx.tcx.hir().parent_iter(ex.hir_id) {
                 match node {
@@ -137,14 +135,15 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
                                     && func_did == into_iter_did
                                 {
                                     // Probably a for loop desugar, stop searching
-                                    return;
+                                    return ControlFlow::Continue(());
                                 }
 
                                 if args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg)) {
                                     self.found_peek_call = true;
+                                    return ControlFlow::Break(());
                                 }
 
-                                return;
+                                return ControlFlow::Continue(());
                             },
                             // Catch anything taking a Peekable mutably
                             ExprKind::MethodCall(
@@ -163,57 +162,62 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
                                     && arg_is_mut_peekable(self.cx, self_arg)
                                 {
                                     self.found_peek_call = true;
-                                    return;
+                                    return ControlFlow::Break(());
                                 }
 
                                 // foo.some_method() excluding Iterator methods
                                 if remaining_args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg))
                                     && !is_trait_method(self.cx, expr, sym::Iterator)
                                 {
                                     self.found_peek_call = true;
-                                    return;
+                                    return ControlFlow::Break(());
                                 }
 
                                 // foo.by_ref(), keep checking for `peek`
                                 if method_name == "by_ref" {
                                     continue;
                                 }
 
-                                return;
+                                return ControlFlow::Continue(());
                             },
                             ExprKind::AddrOf(_, Mutability::Mut, _) | ExprKind::Unary(..) | ExprKind::DropTemps(_) => {
                             },
-                            ExprKind::AddrOf(_, Mutability::Not, _) => return,
+                            ExprKind::AddrOf(_, Mutability::Not, _) => return ControlFlow::Continue(()),
                             _ => {
                                 self.found_peek_call = true;
-                                return;
+                                return ControlFlow::Break(());
                             },
                         }
                     },
                     Node::LetStmt(LetStmt { init: Some(init), .. }) => {
                         if arg_is_mut_peekable(self.cx, init) {
                             self.found_peek_call = true;
+                            return ControlFlow::Break(());
                         }
 
-                        return;
+                        return ControlFlow::Continue(());
                     },
                     Node::Stmt(stmt) => {
                         match stmt.kind {
-                            StmtKind::Let(_) | StmtKind::Item(_) => self.found_peek_call = true,
+                            StmtKind::Let(_) | StmtKind::Item(_) => {
+                                self.found_peek_call = true;
+                                return ControlFlow::Break(());
+                            },
                             StmtKind::Expr(_) | StmtKind::Semi(_) => {},
                         }
 
-                        return;
+                        return ControlFlow::Continue(());
                     },
                     Node::Block(_) | Node::ExprField(_) => {},
                     _ => {
-                        return;
+                        return ControlFlow::Continue(());
                     },
                 }
             }
         }
 
         walk_expr(self, ex);
+        ControlFlow::Continue(())
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ use rustc_hir::{Expr, ExprKind};`
`7`	`7`	`use rustc_lint::{LateContext, LateLintPass};`
`8`	`8`	`use rustc_session::declare_lint_pass;`
`9`	`9`	`use rustc_span::sym;`
	`10`	`+use std::ops::ControlFlow;`
`10`	`11`
`11`	`12`	`declare_clippy_lint! {`
`12`	`13`	`/// ### What it does`
`@@ -90,12 +91,14 @@ pub struct OppVisitor<'a, 'tcx> {`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {`
`93`		`- fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {`
	`94`	`+ type Result = ControlFlow<()>;`
	`95`	`+ fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<()> {`
`94`	`96`	`if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {`
`95`	`97`	`self.found_mutex = Some(mutex);`
`96`		`- return;`
	`98`	`+ return ControlFlow::Break(());`
`97`	`99`	`}`
`98`	`100`	`visit::walk_expr(self, expr);`
	`101`	`+ ControlFlow::Continue(())`
`99`	`102`	`}`
`100`	`103`	`}`
`101`	`104`
`@@ -106,12 +109,14 @@ pub struct ArmVisitor<'a, 'tcx> {`
`106`	`109`	`}`
`107`	`110`
`108`	`111`	`impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {`
`109`		`- fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {`
	`112`	`+ type Result = ControlFlow<()>;`
	`113`	`+ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {`
`110`	`114`	`if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {`
`111`	`115`	`self.found_mutex = Some(mutex);`
`112`		`- return;`
	`116`	`+ return ControlFlow::Break(());`
`113`	`117`	`}`
`114`	`118`	`visit::walk_expr(self, expr);`
	`119`	`+ ControlFlow::Continue(())`
`115`	`120`	`}`
`116`	`121`	`}`
`117`	`122`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ use rustc_session::declare_lint_pass;`
`22`	`22`	`use rustc_span::def_id::LocalDefId;`
`23`	`23`	`use rustc_span::symbol::{kw, Ident, Symbol};`
`24`	`24`	`use rustc_span::Span;`
	`25`	`+use std::ops::ControlFlow;`
`25`	`26`
`26`	`27`	`declare_clippy_lint! {`
`27`	`28`	`/// ### What it does`
`@@ -699,10 +700,13 @@ struct BodyLifetimeChecker {`
`699`	`700`	`}`
`700`	`701`
`701`	`702`	`impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {`
	`703`	`+ type Result = ControlFlow<()>;`
`702`	`704`	`// for lifetimes as parameters of generics`
`703`		`- fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {`
	`705`	`+ fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) -> ControlFlow<()> {`
`704`	`706`	`if !lifetime.is_anonymous() && lifetime.ident.name != kw::StaticLifetime {`
`705`	`707`	`self.lifetimes_used_in_body = true;`
	`708`	`+ return ControlFlow::Break(());`
`706`	`709`	`}`
	`710`	`+ ControlFlow::Continue(())`
`707`	`711`	`}`
`708`	`712`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ use rustc_middle::lint::in_external_macro;`
`14`	`14`	`use rustc_middle::ty;`
`15`	`15`	`use rustc_session::declare_lint_pass;`
`16`	`16`	`use rustc_span::ExpnKind;`
	`17`	`+use std::ops::ControlFlow;`
`17`	`18`
`18`	`19`	`declare_clippy_lint! {`
`19`	`20`	`/// ### What it does`
`@@ -54,12 +55,14 @@ impl ReturnVisitor {`
`54`	`55`	`}`
`55`	`56`
`56`	`57`	`impl<'tcx> Visitor<'tcx> for ReturnVisitor {`
`57`		`- fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {`
	`58`	`+ type Result = ControlFlow<()>;`
	`59`	`+ fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) -> ControlFlow<()> {`
`58`	`60`	`if let ExprKind::Ret(_) \| ExprKind::Match(.., hir::MatchSource::TryDesugar(_)) = ex.kind {`
`59`	`61`	`self.found_return = true;`
`60`		`- } else {`
`61`		`- hir_visit::walk_expr(self, ex);`
	`62`	`+ return ControlFlow::Break(());`
`62`	`63`	`}`
	`64`	`+ hir_visit::walk_expr(self, ex);`
	`65`	`+ ControlFlow::Continue(())`
`63`	`66`	`}`
`64`	`67`	`}`
`65`	`68`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ use rustc_session::impl_lint_pass;`
`16`	`16`	`use rustc_span::symbol::{kw, Ident};`
`17`	`17`	`use rustc_span::{sym, Span};`
`18`	`18`	`use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;`
	`19`	`+use std::ops::ControlFlow;`
`19`	`20`
`20`	`21`	`declare_clippy_lint! {`
`21`	`22`	`/// ### What it does`
`@@ -285,15 +286,13 @@ where`
`285`	`286`	`'tcx: 'a,`
`286`	`287`	`{`
`287`	`288`	`type NestedFilter = nested_filter::OnlyBodies;`
	`289`	`+ type Result = ControlFlow<()>;`
`288`	`290`
`289`	`291`	`fn nested_visit_map(&mut self) -> Self::Map {`
`290`	`292`	`self.map`
`291`	`293`	`}`
`292`	`294`
`293`		`- fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {`
`294`		`- if self.found_default_call {`
`295`		`- return;`
`296`		`- }`
	`295`	`+ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {`
`297`	`296`	`walk_expr(self, expr);`
`298`	`297`
`299`	`298`	`if let ExprKind::Call(f, _) = expr.kind`
`@@ -305,7 +304,9 @@ where`
`305`	`304`	`{`
`306`	`305`	`self.found_default_call = true;`
`307`	`306`	`span_error(self.cx, self.method_span, expr);`
	`307`	`+ return ControlFlow::Break(());`
`308`	`308`	`}`
	`309`	`+ ControlFlow::Continue(())`
`309`	`310`	`}`
`310`	`311`	`}`
`311`	`312`