Use ControlFlow::is{break,continue}

LeSeulArtichaut · LeSeulArtichaut · commit 24e1a7e6564e · 2020-10-30T12:27:46.000+01:00
diff --git a/compiler/rustc_middle/src/mir/type_foldable.rs b/compiler/rustc_middle/src/mir/type_foldable.rs
@@ -109,7 +109,7 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> {
                 args.visit_with(visitor)
             }
             Assert { ref cond, ref msg, .. } => {
-                if cond.visit_with(visitor) == ControlFlow::BREAK {
+                if cond.visit_with(visitor).is_break() {
                     use AssertKind::*;
                     match msg {
                         BoundsCheck { ref len, ref index } => {
diff --git a/compiler/rustc_middle/src/ty/fold.rs b/compiler/rustc_middle/src/ty/fold.rs
@@ -59,8 +59,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
     /// If `binder` is `ty::INNERMOST`, this indicates whether
     /// there are any late-bound regions that appear free.
     fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool {
-        self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder })
-            == ControlFlow::Break(())
+        self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder }).is_break()
     }
 
     /// Returns `true` if this `self` has any regions that escape `binder` (and
@@ -74,7 +73,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
     }
 
     fn has_type_flags(&self, flags: TypeFlags) -> bool {
-        self.visit_with(&mut HasTypeFlagsVisitor { flags }) == ControlFlow::Break(())
+        self.visit_with(&mut HasTypeFlagsVisitor { flags }).is_break()
     }
     fn has_projections(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_PROJECTION)
@@ -368,8 +367,7 @@ impl<'tcx> TyCtxt<'tcx> {
             }
         }
 
-        value.visit_with(&mut RegionVisitor { outer_index: ty::INNERMOST, callback })
-            == ControlFlow::BREAK
+        value.visit_with(&mut RegionVisitor { outer_index: ty::INNERMOST, callback }).is_break()
     }
 }
 
@@ -685,7 +683,7 @@ impl<'tcx> TyCtxt<'tcx> {
     {
         let mut collector = LateBoundRegionsCollector::new(just_constraint);
         let result = value.as_ref().skip_binder().visit_with(&mut collector);
-        assert!(result == ControlFlow::Continue(())); // should never have stopped early
+        assert!(result.is_continue()); // should never have stopped early
         collector.regions
     }
 
diff --git a/compiler/rustc_mir/src/interpret/util.rs b/compiler/rustc_mir/src/interpret/util.rs
@@ -74,7 +74,7 @@ where
     }
 
     let mut vis = UsedParamsNeedSubstVisitor { tcx };
-    if ty.visit_with(&mut vis) == ControlFlow::BREAK {
+    if ty.visit_with(&mut vis).is_break() {
         throw_inval!(TooGeneric);
     } else {
         Ok(())
diff --git a/compiler/rustc_mir/src/monomorphize/polymorphize.rs b/compiler/rustc_mir/src/monomorphize/polymorphize.rs
@@ -139,7 +139,7 @@ fn mark_used_by_predicates<'tcx>(
             // predicate is used.
             let any_param_used = {
                 let mut vis = HasUsedGenericParams { unused_parameters };
-                predicate.visit_with(&mut vis) == ControlFlow::BREAK
+                predicate.visit_with(&mut vis).is_break()
             };
 
             if any_param_used {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -1086,7 +1086,7 @@ impl<'tcx> TypePrivacyVisitor<'tcx> {
                 adjustments.iter().try_for_each(|adjustment| self.visit(adjustment.target))?;
             }
         };
-        result == ControlFlow::BREAK
+        result.is_break()
     }
 
     fn check_def_id(&mut self, def_id: DefId, kind: &str, descr: &dyn fmt::Display) -> bool {
@@ -1128,14 +1128,14 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
         self.span = hir_ty.span;
         if let Some(typeck_results) = self.maybe_typeck_results {
             // Types in bodies.
-            if self.visit(typeck_results.node_type(hir_ty.hir_id)) == ControlFlow::BREAK {
+            if self.visit(typeck_results.node_type(hir_ty.hir_id)).is_break() {
                 return;
             }
         } else {
             // Types in signatures.
             // FIXME: This is very ineffective. Ideally each HIR type should be converted
             // into a semantic type only once and the result should be cached somehow.
-            if self.visit(rustc_typeck::hir_ty_to_ty(self.tcx, hir_ty)) == ControlFlow::BREAK {
+            if self.visit(rustc_typeck::hir_ty_to_ty(self.tcx, hir_ty)).is_break() {
                 return;
             }
         }
@@ -1157,16 +1157,17 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
             );
 
             for (trait_predicate, _, _) in bounds.trait_bounds {
-                if self.visit_trait(trait_predicate.skip_binder()) == ControlFlow::BREAK {
+                if self.visit_trait(trait_predicate.skip_binder()).is_break() {
                     return;
                 }
             }
 
             for (poly_predicate, _) in bounds.projection_bounds {
                 let tcx = self.tcx;
-                if self.visit(poly_predicate.skip_binder().ty) == ControlFlow::BREAK
-                    || self.visit_trait(poly_predicate.skip_binder().projection_ty.trait_ref(tcx))
-                        == ControlFlow::BREAK
+                if self.visit(poly_predicate.skip_binder().ty).is_break()
+                    || self
+                        .visit_trait(poly_predicate.skip_binder().projection_ty.trait_ref(tcx))
+                        .is_break()
                 {
                     return;
                 }
@@ -1193,7 +1194,7 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
                 // Method calls have to be checked specially.
                 self.span = span;
                 if let Some(def_id) = self.typeck_results().type_dependent_def_id(expr.hir_id) {
-                    if self.visit(self.tcx.type_of(def_id)) == ControlFlow::BREAK {
+                    if self.visit(self.tcx.type_of(def_id)).is_break() {
                         return;
                     }
                 } else {
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -869,8 +869,9 @@ fn contains_illegal_self_type_reference<'tcx, T: TypeFoldable<'tcx>>(
         }
     }
 
-    value.visit_with(&mut IllegalSelfTypeVisitor { tcx, trait_def_id, supertraits: None })
-        == ControlFlow::BREAK
+    value
+        .visit_with(&mut IllegalSelfTypeVisitor { tcx, trait_def_id, supertraits: None })
+        .is_break()
 }
 
 pub fn provide(providers: &mut ty::query::Providers) {
diff --git a/compiler/rustc_trait_selection/src/traits/structural_match.rs b/compiler/rustc_trait_selection/src/traits/structural_match.rs
@@ -248,7 +248,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for Search<'a, 'tcx> {
             let ty = self.tcx().normalize_erasing_regions(ty::ParamEnv::empty(), field_ty);
             debug!("structural-match ADT: field_ty={:?}, ty={:?}", field_ty, ty);
 
-            if ty.visit_with(self) == ControlFlow::BREAK {
+            if ty.visit_with(self).is_break() {
                 // found an ADT without structural-match; halt visiting!
                 assert!(self.found.is_some());
                 return ControlFlow::BREAK;
diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs
@@ -452,7 +452,7 @@ pub(super) fn check_opaque_for_inheriting_lifetimes(
     impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
         fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<(), ()> {
             debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
-            if t != self.opaque_identity_ty && t.super_visit_with(self) == ControlFlow::BREAK {
+            if t != self.opaque_identity_ty && t.super_visit_with(self).is_break() {
                 self.ty = Some(t);
                 return ControlFlow::BREAK;
             }
@@ -499,7 +499,7 @@ pub(super) fn check_opaque_for_inheriting_lifetimes(
         let prohibit_opaque = tcx
             .explicit_item_bounds(def_id)
             .iter()
-            .any(|(predicate, _)| predicate.visit_with(&mut visitor) == ControlFlow::BREAK);
+            .any(|(predicate, _)| predicate.visit_with(&mut visitor).is_break());
         debug!(
             "check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}, visitor={:?}",
             prohibit_opaque, visitor
diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs
@@ -819,7 +819,7 @@ fn check_where_clauses<'tcx, 'fcx>(
                 }
             }
             let mut param_count = CountParams::default();
-            let has_region = pred.visit_with(&mut param_count) == ControlFlow::BREAK;
+            let has_region = pred.visit_with(&mut param_count).is_break();
             let substituted_pred = pred.subst(fcx.tcx, substs);
             // Don't check non-defaulted params, dependent defaults (including lifetimes)
             // or preds with multiple params.
diff --git a/src/tools/clippy/clippy_lints/src/redundant_clone.rs b/src/tools/clippy/clippy_lints/src/redundant_clone.rs
@@ -518,7 +518,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
                 self.possible_borrower.add(borrowed.local, lhs);
             },
             other => {
-                if ContainsRegion.visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty) == ControlFlow::CONTINUE {
+                if ContainsRegion.visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty).is_continue() {
                     return;
                 }
                 rvalue_locals(other, |rhs| {
@@ -540,7 +540,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
             // If the call returns something with lifetimes,
             // let's conservatively assume the returned value contains lifetime of all the arguments.
             // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
-            if ContainsRegion.visit_ty(&self.body.local_decls[*dest].ty) == ControlFlow::CONTINUE {
+            if ContainsRegion.visit_ty(&self.body.local_decls[*dest].ty).is_continue() {
                 return;
             }
 

Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> {`
`109`	`109`	`args.visit_with(visitor)`
`110`	`110`	`}`
`111`	`111`	`Assert { ref cond, ref msg, .. } => {`
`112`		`- if cond.visit_with(visitor) == ControlFlow::BREAK {`
	`112`	`+ if cond.visit_with(visitor).is_break() {`
`113`	`113`	`use AssertKind::*;`
`114`	`114`	`match msg {`
`115`	`115`	`BoundsCheck { ref len, ref index } => {`
Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {`
`59`	`59`	/// If `binder` is `ty::INNERMOST`, this indicates whether
`60`	`60`	`/// there are any late-bound regions that appear free.`
`61`	`61`	`fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool {`
`62`		`- self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder })`
`63`		`- == ControlFlow::Break(())`
	`62`	`+ self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder }).is_break()`
`64`	`63`	`}`
`65`	`64`
`66`	`65`	/// Returns `true` if this `self` has any regions that escape `binder` (and
`@@ -74,7 +73,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {`
`74`	`73`	`}`
`75`	`74`
`76`	`75`	`fn has_type_flags(&self, flags: TypeFlags) -> bool {`
`77`		`- self.visit_with(&mut HasTypeFlagsVisitor { flags }) == ControlFlow::Break(())`
	`76`	`+ self.visit_with(&mut HasTypeFlagsVisitor { flags }).is_break()`
`78`	`77`	`}`
`79`	`78`	`fn has_projections(&self) -> bool {`
`80`	`79`	`self.has_type_flags(TypeFlags::HAS_PROJECTION)`
`@@ -368,8 +367,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`368`	`367`	`}`
`369`	`368`	`}`
`370`	`369`
`371`		`- value.visit_with(&mut RegionVisitor { outer_index: ty::INNERMOST, callback })`
`372`		`- == ControlFlow::BREAK`
	`370`	`+ value.visit_with(&mut RegionVisitor { outer_index: ty::INNERMOST, callback }).is_break()`
`373`	`371`	`}`
`374`	`372`	`}`
`375`	`373`
`@@ -685,7 +683,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`685`	`683`	`{`
`686`	`684`	`let mut collector = LateBoundRegionsCollector::new(just_constraint);`
`687`	`685`	`let result = value.as_ref().skip_binder().visit_with(&mut collector);`
`688`		`- assert!(result == ControlFlow::Continue(())); // should never have stopped early`
	`686`	`+ assert!(result.is_continue()); // should never have stopped early`
`689`	`687`	`collector.regions`
`690`	`688`	`}`
`691`	`689`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ where`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`let mut vis = UsedParamsNeedSubstVisitor { tcx };`
`77`		`- if ty.visit_with(&mut vis) == ControlFlow::BREAK {`
	`77`	`+ if ty.visit_with(&mut vis).is_break() {`
`78`	`78`	`throw_inval!(TooGeneric);`
`79`	`79`	`} else {`
`80`	`80`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -1086,7 +1086,7 @@ impl<'tcx> TypePrivacyVisitor<'tcx> {`
`1086`	`1086`	`adjustments.iter().try_for_each(\|adjustment\| self.visit(adjustment.target))?;`
`1087`	`1087`	`}`
`1088`	`1088`	`};`
`1089`		`- result == ControlFlow::BREAK`
	`1089`	`+ result.is_break()`
`1090`	`1090`	`}`
`1091`	`1091`
`1092`	`1092`	`fn check_def_id(&mut self, def_id: DefId, kind: &str, descr: &dyn fmt::Display) -> bool {`
`@@ -1128,14 +1128,14 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {`
`1128`	`1128`	`self.span = hir_ty.span;`
`1129`	`1129`	`if let Some(typeck_results) = self.maybe_typeck_results {`
`1130`	`1130`	`// Types in bodies.`
`1131`		`- if self.visit(typeck_results.node_type(hir_ty.hir_id)) == ControlFlow::BREAK {`
	`1131`	`+ if self.visit(typeck_results.node_type(hir_ty.hir_id)).is_break() {`
`1132`	`1132`	`return;`
`1133`	`1133`	`}`
`1134`	`1134`	`} else {`
`1135`	`1135`	`// Types in signatures.`
`1136`	`1136`	`// FIXME: This is very ineffective. Ideally each HIR type should be converted`
`1137`	`1137`	`// into a semantic type only once and the result should be cached somehow.`
`1138`		`- if self.visit(rustc_typeck::hir_ty_to_ty(self.tcx, hir_ty)) == ControlFlow::BREAK {`
	`1138`	`+ if self.visit(rustc_typeck::hir_ty_to_ty(self.tcx, hir_ty)).is_break() {`
`1139`	`1139`	`return;`
`1140`	`1140`	`}`
`1141`	`1141`	`}`
`@@ -1157,16 +1157,17 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {`
`1157`	`1157`	`);`
`1158`	`1158`
`1159`	`1159`	`for (trait_predicate, _, _) in bounds.trait_bounds {`
`1160`		`- if self.visit_trait(trait_predicate.skip_binder()) == ControlFlow::BREAK {`
	`1160`	`+ if self.visit_trait(trait_predicate.skip_binder()).is_break() {`
`1161`	`1161`	`return;`
`1162`	`1162`	`}`
`1163`	`1163`	`}`
`1164`	`1164`
`1165`	`1165`	`for (poly_predicate, _) in bounds.projection_bounds {`
`1166`	`1166`	`let tcx = self.tcx;`
`1167`		`- if self.visit(poly_predicate.skip_binder().ty) == ControlFlow::BREAK`
`1168`		`- \|\| self.visit_trait(poly_predicate.skip_binder().projection_ty.trait_ref(tcx))`
`1169`		`- == ControlFlow::BREAK`
	`1167`	`+ if self.visit(poly_predicate.skip_binder().ty).is_break()`
	`1168`	`+ \|\| self`
	`1169`	`+ .visit_trait(poly_predicate.skip_binder().projection_ty.trait_ref(tcx))`
	`1170`	`+ .is_break()`
`1170`	`1171`	`{`
`1171`	`1172`	`return;`
`1172`	`1173`	`}`
`@@ -1193,7 +1194,7 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {`
`1193`	`1194`	`// Method calls have to be checked specially.`
`1194`	`1195`	`self.span = span;`
`1195`	`1196`	`if let Some(def_id) = self.typeck_results().type_dependent_def_id(expr.hir_id) {`
`1196`		`- if self.visit(self.tcx.type_of(def_id)) == ControlFlow::BREAK {`
	`1197`	`+ if self.visit(self.tcx.type_of(def_id)).is_break() {`
`1197`	`1198`	`return;`
`1198`	`1199`	`}`
`1199`	`1200`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -869,8 +869,9 @@ fn contains_illegal_self_type_reference<'tcx, T: TypeFoldable<'tcx>>(`
`869`	`869`	`}`
`870`	`870`	`}`
`871`	`871`
`872`		`- value.visit_with(&mut IllegalSelfTypeVisitor { tcx, trait_def_id, supertraits: None })`
`873`		`- == ControlFlow::BREAK`
	`872`	`+ value`
	`873`	`+ .visit_with(&mut IllegalSelfTypeVisitor { tcx, trait_def_id, supertraits: None })`
	`874`	`+ .is_break()`
`874`	`875`	`}`
`875`	`876`
`876`	`877`	`pub fn provide(providers: &mut ty::query::Providers) {`
Original file line number	Diff line number	Diff line change
`@@ -819,7 +819,7 @@ fn check_where_clauses<'tcx, 'fcx>(`
`819`	`819`	`}`
`820`	`820`	`}`
`821`	`821`	`let mut param_count = CountParams::default();`
`822`		`- let has_region = pred.visit_with(&mut param_count) == ControlFlow::BREAK;`
	`822`	`+ let has_region = pred.visit_with(&mut param_count).is_break();`
`823`	`823`	`let substituted_pred = pred.subst(fcx.tcx, substs);`
`824`	`824`	`// Don't check non-defaulted params, dependent defaults (including lifetimes)`
`825`	`825`	`// or preds with multiple params.`