Swap Visitors to early exit, instead of storing poison flag

Author: GnomedDev

clippy_lints/src/copies.rs

@@ -540,24 +540,22 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbo
 .iter()
 .filter(|&&(_, name)| !name.as_str().starts_with('_'))
 .any(|&(_, name)| {
-letmut walker = ContainsName{
- name,
-result:false,
- cx,
-};
+letmut walker = ContainsName{ name, cx };
 
 // Scan block
- block
+letmut res = block
 .stmts
 .iter()
 .filter(|stmt| !ignore_span.overlaps(stmt.span))
-.for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
+.try_for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
 
 ifletSome(expr) = block.expr{
- intravisit::walk_expr(&mut walker, expr);
+if res.is_continue(){
+ res = intravisit::walk_expr(&mut walker, expr);
+}
 }
 
-walker.result
+res.is_break()
 })
 })
 }

clippy_lints/src/derive.rs

@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
 use clippy_utils::{has_non_exhaustive_attr, is_lint_allowed, match_def_path, paths};
@@ -371,9 +373,8 @@ fn check_unsafe_derive_deserialize<'tcx>(
 ty:Ty<'tcx>,
 ){
 fnhas_unsafe<'tcx>(cx:&LateContext<'tcx>,item:&'tcxItem<'_>) -> bool{
-letmut visitor = UnsafeVisitor{ cx,has_unsafe:false};
-walk_item(&mut visitor, item);
- visitor.has_unsafe
+letmut visitor = UnsafeVisitor{ cx };
+walk_item(&mut visitor, item).is_break()
 }
 
 ifletSome(trait_def_id) = trait_ref.trait_def_id()
@@ -406,38 +407,37 @@ fn check_unsafe_derive_deserialize<'tcx>(
 
 structUnsafeVisitor<'a,'tcx>{
 cx:&'aLateContext<'tcx>,
-has_unsafe:bool,
 }
 
 impl<'tcx>Visitor<'tcx>forUnsafeVisitor<'_,'tcx>{
+typeResult = ControlFlow<()>;
 typeNestedFilter = nested_filter::All;
 
-fnvisit_fn(&mutself,kind:FnKind<'tcx>,decl:&'tcxFnDecl<'_>,body_id:BodyId, _:Span,id:LocalDefId){
-ifself.has_unsafe{
-return;
-}
-
+fnvisit_fn(
+&mutself,
+kind:FnKind<'tcx>,
+decl:&'tcxFnDecl<'_>,
+body_id:BodyId,
+ _:Span,
+id:LocalDefId,
+) -> Self::Result{
 ifletSome(header) = kind.header()
  && header.safety == Safety::Unsafe
 {
-self.has_unsafe = true;
+ControlFlow::Break(())
+}else{
+walk_fn(self, kind, decl, body_id, id)
 }
-
-walk_fn(self, kind, decl, body_id, id);
 }
 
-fnvisit_expr(&mutself,expr:&'tcxExpr<'_>){
-ifself.has_unsafe{
-return;
-}
-
+fnvisit_expr(&mutself,expr:&'tcxExpr<'_>) -> Self::Result{
 ifletExprKind::Block(block, _) = expr.kind{
 if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided){
-self.has_unsafe = true;
+returnControlFlow::Break(());
 }
 }
 
-walk_expr(self, expr);
+walk_expr(self, expr)
 }
 
 fnnested_visit_map(&mutself) -> Self::Map{

clippy_lints/src/from_over_into.rs

@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 use clippy_config::Conf;
 use clippy_config::msrvs::{self,Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
@@ -115,43 +117,46 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
 }
 
 /// Finds the occurrences of `Self` and `self`
+///
+/// Returns `ControlFlow::break` if any of the `self`/`Self` usages were from an expansion, or the
+/// body contained a binding already named `val`.
 structSelfFinder<'a,'tcx>{
 cx:&'aLateContext<'tcx>,
 /// Occurrences of `Self`
 upper:Vec<Span>,
 /// Occurrences of `self`
 lower:Vec<Span>,
-/// If any of the `self`/`Self` usages were from an expansion, or the body contained a binding
-/// already named `val`
-invalid:bool,
 }
 
 impl<'tcx>Visitor<'tcx>forSelfFinder<'_,'tcx>{
+typeResult = ControlFlow<()>;
 typeNestedFilter = OnlyBodies;
 
 fnnested_visit_map(&mutself) -> Self::Map{
 self.cx.tcx.hir()
 }
 
-fnvisit_path(&mutself,path:&Path<'tcx>,_id:HirId){
+fnvisit_path(&mutself,path:&Path<'tcx>,_id:HirId)-> Self::Result{
 for segment in path.segments{
 match segment.ident.name{
  kw::SelfLower => self.lower.push(segment.ident.span),
  kw::SelfUpper => self.upper.push(segment.ident.span),
  _ => continue,
 }
 
-self.invalid |= segment.ident.span.from_expansion();
+if segment.ident.span.from_expansion(){
+returnControlFlow::Break(());
+}
 }
 
-if !self.invalid{
-walk_path(self, path);
-}
+walk_path(self, path)
 }
 
-fnvisit_name(&mutself,name:Symbol){
+fnvisit_name(&mutself,name:Symbol)-> Self::Result{
 if name == sym::val {
-self.invalid = true;
+ControlFlow::Break(())
+}else{
+ControlFlow::Continue(())
 }
 }
 }
@@ -209,11 +214,9 @@ fn convert_to_from(
  cx,
 upper:Vec::new(),
 lower:Vec::new(),
-invalid:false,
 };
- finder.visit_expr(body.value);
 
-if finder.invalid{
+if finder.visit_expr(body.value).is_break(){
 returnNone;
 }
 

clippy_lints/src/loops/while_immutable_condition.rs

@@ -19,10 +19,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
  cx,
 ids:HirIdSet::default(),
 def_ids:DefIdMap::default(),
-skip:false,
 };
- var_visitor.visit_expr(cond);
-if var_visitor.skip{
+if var_visitor.visit_expr(cond).is_break(){
 return;
 }
 let used_in_condition = &var_visitor.ids;
@@ -81,7 +79,6 @@ struct VarCollectorVisitor<'a, 'tcx> {
 cx:&'aLateContext<'tcx>,
 ids:HirIdSet,
 def_ids:DefIdMap<bool>,
-skip:bool,
 }
 
 impl<'tcx>VarCollectorVisitor<'_,'tcx>{
@@ -104,11 +101,15 @@ impl<'tcx> VarCollectorVisitor<'_, 'tcx> {
 }
 
 impl<'tcx>Visitor<'tcx>forVarCollectorVisitor<'_,'tcx>{
-fnvisit_expr(&mutself,ex:&'tcxExpr<'_>){
+typeResult = ControlFlow<()>;
+fnvisit_expr(&mutself,ex:&'tcxExpr<'_>) -> Self::Result{
 match ex.kind{
-ExprKind::Path(_) => self.insert_def_id(ex),
+ExprKind::Path(_) => {
+self.insert_def_id(ex);
+ControlFlow::Continue(())
+},
 // If there is any function/method call… we just stop analysis
-ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
+ExprKind::Call(..) | ExprKind::MethodCall(..) => ControlFlow::Break(()),
 
  _ => walk_expr(self, ex),
 }

clippy_lints/src/loops/while_let_on_iterator.rs

@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 usesuper::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
@@ -204,35 +206,32 @@ fn uses_iter<'tcx>(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tc
 structV<'a,'b,'tcx>{
 cx:&'aLateContext<'tcx>,
 iter_expr:&'bIterExpr,
-uses_iter:bool,
 }
 impl<'tcx>Visitor<'tcx>forV<'_,'_,'tcx>{
-fnvisit_expr(&mutself,e:&'tcxExpr<'_>){
-ifself.uses_iter{
-// return
-}elseifis_expr_same_child_or_parent_field(self.cx, e,&self.iter_expr.fields,self.iter_expr.path){
-self.uses_iter = true;
+typeResult = ControlFlow<()>;
+fnvisit_expr(&mutself,e:&'tcxExpr<'_>) -> Self::Result{
+ifis_expr_same_child_or_parent_field(self.cx, e,&self.iter_expr.fields,self.iter_expr.path){
+ControlFlow::Break(())
 }elseiflet(e,true) = skip_fields_and_path(e){
 ifletSome(e) = e {
-self.visit_expr(e);
+self.visit_expr(e)
+}else{
+ControlFlow::Continue(())
 }
 }elseifletExprKind::Closure(&Closure{body: id, .. }) = e.kind{
 ifis_res_used(self.cx,self.iter_expr.path, id){
-self.uses_iter = true;
+ControlFlow::Break(())
+}else{
+ControlFlow::Continue(())
 }
 }else{
-walk_expr(self, e);
+walk_expr(self, e)
 }
 }
 }
 
-letmut v = V{
- cx,
- iter_expr,
-uses_iter:false,
-};
- v.visit_expr(container);
- v.uses_iter
+letmut v = V{ cx, iter_expr };
+ v.visit_expr(container).is_break()
 }
 
 #[expect(clippy::too_many_lines)]
@@ -242,34 +241,38 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
 iter_expr:&'bIterExpr,
 loop_id:HirId,
 after_loop:bool,
-used_iter:bool,
 }
 impl<'tcx>Visitor<'tcx>forAfterLoopVisitor<'_,'_,'tcx>{
 typeNestedFilter = OnlyBodies;
+typeResult = ControlFlow<()>;
 fnnested_visit_map(&mutself) -> Self::Map{
 self.cx.tcx.hir()
 }
 
-fnvisit_expr(&mutself,e:&'tcxExpr<'_>){
-ifself.used_iter{
-return;
-}
+fnvisit_expr(&mutself,e:&'tcxExpr<'_>) -> Self::Result{
 ifself.after_loop{
 ifis_expr_same_child_or_parent_field(self.cx, e,&self.iter_expr.fields,self.iter_expr.path){
-self.used_iter = true;
+ControlFlow::Break(())
 }elseiflet(e,true) = skip_fields_and_path(e){
 ifletSome(e) = e {
-self.visit_expr(e);
+self.visit_expr(e)
+}else{
+ControlFlow::Continue(())
 }
 }elseifletExprKind::Closure(&Closure{body: id, .. }) = e.kind{
-self.used_iter = is_res_used(self.cx,self.iter_expr.path, id);
+ifis_res_used(self.cx,self.iter_expr.path, id){
+ControlFlow::Break(())
+}else{
+ControlFlow::Continue(())
+}
 }else{
-walk_expr(self, e);
+walk_expr(self, e)
 }
 }elseifself.loop_id == e.hir_id{
 self.after_loop = true;
+ControlFlow::Continue(())
 }else{
-walk_expr(self, e);
+walk_expr(self, e)
 }
 }
 }
@@ -347,9 +350,8 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
  iter_expr,
 loop_id: loop_expr.hir_id,
 after_loop:false,
-used_iter:false,
 };
- v.visit_expr(cx.tcx.hir().body(cx.enclosing_body.unwrap()).value);
-v.used_iter
+ v.visit_expr(cx.tcx.hir().body(cx.enclosing_body.unwrap()).value)
+.is_break()
 }
 }

clippy_lints/src/matches/match_str_case_mismatch.rs

@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_lang_item;
 use rustc_ast::ast::LitKind;
@@ -23,11 +25,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arm
 iflet ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind()
  && let ty::Str = ty.kind()
 {
-letmut visitor = MatchExprVisitor{ cx,case_method:None};
-
- visitor.visit_expr(scrutinee);
-
-ifletSome(case_method) = visitor.case_method{
+letmut visitor = MatchExprVisitor{ cx };
+ifletControlFlow::Break(case_method) = visitor.visit_expr(scrutinee){
 ifletSome((bad_case_span, bad_case_sym)) = verify_case(&case_method, arms){
 lint(cx,&case_method, bad_case_span, bad_case_sym.as_str());
 }
@@ -37,30 +36,33 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arm
 
 structMatchExprVisitor<'a,'tcx>{
 cx:&'aLateContext<'tcx>,
-case_method:Option<CaseMethod>,
 }
 
 impl<'tcx>Visitor<'tcx>forMatchExprVisitor<'_,'tcx>{
-fnvisit_expr(&mutself,ex:&'tcxExpr<'_>){
-match ex.kind{
-ExprKind::MethodCall(segment, receiver,[], _)ifself.case_altered(segment.ident.as_str(), receiver) => {},
- _ => walk_expr(self, ex),
+typeResult = ControlFlow<CaseMethod>;
+fnvisit_expr(&mutself,ex:&'tcxExpr<'_>) -> Self::Result{
+ifletExprKind::MethodCall(segment, receiver,[], _) = ex.kind{
+let result = self.case_altered(segment.ident.as_str(), receiver);
+if result.is_break(){
+return result;
+}
 }
+
+walk_expr(self, ex)
 }
 }
 
 implMatchExprVisitor<'_,'_>{
-fncase_altered(&mutself,segment_ident:&str,receiver:&Expr<'_>) -> bool{
+fncase_altered(&mutself,segment_ident:&str,receiver:&Expr<'_>) -> ControlFlow<CaseMethod>{
 ifletSome(case_method) = get_case_method(segment_ident){
 let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs();
 
 ifis_type_lang_item(self.cx, ty,LangItem::String) || ty.kind() == &ty::Str{
-self.case_method = Some(case_method);
-returntrue;
+returnControlFlow::Break(case_method);
 }
 }
 
-false
+ControlFlow::Continue(())
 }
 }