Remove ControlFlow::{BREAK, CONTINUE}

scottmcm · scottmcm · commit 868d099a7222 · 2023-01-27T19:46:42.000-08:00
Libs-API decided to remove these in #102697. Follow-up to #107023, which removed them from `compiler/`, but a couple new ones showed up since that was merged.
diff --git a/compiler/rustc_trait_selection/src/solve/project_goals.rs b/compiler/rustc_trait_selection/src/solve/project_goals.rs
@@ -93,24 +93,24 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
             fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
                 if t.needs_infer() {
                     if ty::Term::from(t) == self.term {
-                        ControlFlow::BREAK
+                        ControlFlow::Break(())
                     } else {
                         t.super_visit_with(self)
                     }
                 } else {
-                    ControlFlow::CONTINUE
+                    ControlFlow::Continue(())
                 }
             }
 
             fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
                 if c.needs_infer() {
                     if ty::Term::from(c) == self.term {
-                        ControlFlow::BREAK
+                        ControlFlow::Break(())
                     } else {
                         c.super_visit_with(self)
                     }
                 } else {
-                    ControlFlow::CONTINUE
+                    ControlFlow::Continue(())
                 }
             }
         }
diff --git a/library/core/src/iter/adapters/filter_map.rs b/library/core/src/iter/adapters/filter_map.rs
@@ -99,7 +99,7 @@ where
         ) -> impl FnMut((), T) -> ControlFlow<B> + '_ {
             move |(), x| match f(x) {
                 Some(x) => ControlFlow::Break(x),
-                None => ControlFlow::CONTINUE,
+                None => ControlFlow::Continue(()),
             }
         }
 
diff --git a/library/core/src/iter/adapters/flatten.rs b/library/core/src/iter/adapters/flatten.rs
@@ -539,7 +539,7 @@ where
         #[rustc_inherit_overflow_checks]
         fn advance<U: Iterator>(n: usize, iter: &mut U) -> ControlFlow<(), usize> {
             match iter.advance_by(n) {
-                Ok(()) => ControlFlow::BREAK,
+                Ok(()) => ControlFlow::Break(()),
                 Err(advanced) => ControlFlow::Continue(n - advanced),
             }
         }
@@ -629,7 +629,7 @@ where
         #[rustc_inherit_overflow_checks]
         fn advance<U: DoubleEndedIterator>(n: usize, iter: &mut U) -> ControlFlow<(), usize> {
             match iter.advance_back_by(n) {
-                Ok(()) => ControlFlow::BREAK,
+                Ok(()) => ControlFlow::Break(()),
                 Err(advanced) => ControlFlow::Continue(n - advanced),
             }
         }
diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs
@@ -352,7 +352,7 @@ pub trait DoubleEndedIterator: Iterator {
         #[inline]
         fn check<T>(mut predicate: impl FnMut(&T) -> bool) -> impl FnMut((), T) -> ControlFlow<T> {
             move |(), x| {
-                if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::CONTINUE }
+                if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }
             }
         }
 
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
@@ -2601,10 +2601,10 @@ pub trait Iterator {
         #[inline]
         fn check<T>(mut f: impl FnMut(T) -> bool) -> impl FnMut((), T) -> ControlFlow<()> {
             move |(), x| {
-                if f(x) { ControlFlow::CONTINUE } else { ControlFlow::BREAK }
+                if f(x) { ControlFlow::Continue(()) } else { ControlFlow::Break(()) }
             }
         }
-        self.try_fold((), check(f)) == ControlFlow::CONTINUE
+        self.try_fold((), check(f)) == ControlFlow::Continue(())
     }
 
     /// Tests if any element of the iterator matches a predicate.
@@ -2654,11 +2654,11 @@ pub trait Iterator {
         #[inline]
         fn check<T>(mut f: impl FnMut(T) -> bool) -> impl FnMut((), T) -> ControlFlow<()> {
             move |(), x| {
-                if f(x) { ControlFlow::BREAK } else { ControlFlow::CONTINUE }
+                if f(x) { ControlFlow::Break(()) } else { ControlFlow::Continue(()) }
             }
         }
 
-        self.try_fold((), check(f)) == ControlFlow::BREAK
+        self.try_fold((), check(f)) == ControlFlow::Break(())
     }
 
     /// Searches for an element of an iterator that satisfies a predicate.
@@ -2717,7 +2717,7 @@ pub trait Iterator {
         #[inline]
         fn check<T>(mut predicate: impl FnMut(&T) -> bool) -> impl FnMut((), T) -> ControlFlow<T> {
             move |(), x| {
-                if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::CONTINUE }
+                if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }
             }
         }
 
@@ -2749,7 +2749,7 @@ pub trait Iterator {
         fn check<T, B>(mut f: impl FnMut(T) -> Option<B>) -> impl FnMut((), T) -> ControlFlow<B> {
             move |(), x| match f(x) {
                 Some(x) => ControlFlow::Break(x),
-                None => ControlFlow::CONTINUE,
+                None => ControlFlow::Continue(()),
             }
         }
 
@@ -2812,7 +2812,7 @@ pub trait Iterator {
             R: Residual<Option<I>>,
         {
             move |(), x| match f(&x).branch() {
-                ControlFlow::Continue(false) => ControlFlow::CONTINUE,
+                ControlFlow::Continue(false) => ControlFlow::Continue(()),
                 ControlFlow::Continue(true) => ControlFlow::Break(Try::from_output(Some(x))),
                 ControlFlow::Break(r) => ControlFlow::Break(FromResidual::from_residual(r)),
             }
@@ -3491,7 +3491,7 @@ pub trait Iterator {
             F: FnMut(X, Y) -> Ordering,
         {
             move |x, y| match cmp(x, y) {
-                Ordering::Equal => ControlFlow::CONTINUE,
+                Ordering::Equal => ControlFlow::Continue(()),
                 non_eq => ControlFlow::Break(non_eq),
             }
         }
@@ -3567,7 +3567,7 @@ pub trait Iterator {
             F: FnMut(X, Y) -> Option<Ordering>,
         {
             move |x, y| match partial_cmp(x, y) {
-                Some(Ordering::Equal) => ControlFlow::CONTINUE,
+                Some(Ordering::Equal) => ControlFlow::Continue(()),
                 non_eq => ControlFlow::Break(non_eq),
             }
         }
@@ -3625,7 +3625,7 @@ pub trait Iterator {
             F: FnMut(X, Y) -> bool,
         {
             move |x, y| {
-                if eq(x, y) { ControlFlow::CONTINUE } else { ControlFlow::BREAK }
+                if eq(x, y) { ControlFlow::Continue(()) } else { ControlFlow::Break(()) }
             }
         }
 
@@ -3859,7 +3859,7 @@ pub trait Iterator {
 
 /// Compares two iterators element-wise using the given function.
 ///
-/// If `ControlFlow::CONTINUE` is returned from the function, the comparison moves on to the next
+/// If `ControlFlow::Continue(())` is returned from the function, the comparison moves on to the next
 /// elements of both iterators. Returning `ControlFlow::Break(x)` short-circuits the iteration and
 /// returns `ControlFlow::Break(x)`. If one of the iterators runs out of elements,
 /// `ControlFlow::Continue(ord)` is returned where `ord` is the result of comparing the lengths of
diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
@@ -259,46 +259,3 @@ impl<R: ops::Try> ControlFlow<R, R::Output> {
         }
     }
 }
-
-impl<B> ControlFlow<B, ()> {
-    /// It's frequently the case that there's no value needed with `Continue`,
-    /// so this provides a way to avoid typing `(())`, if you prefer it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(control_flow_enum)]
-    /// use std::ops::ControlFlow;
-    ///
-    /// let mut partial_sum = 0;
-    /// let last_used = (1..10).chain(20..25).try_for_each(|x| {
-    ///     partial_sum += x;
-    ///     if partial_sum > 100 { ControlFlow::Break(x) }
-    ///     else { ControlFlow::CONTINUE }
-    /// });
-    /// assert_eq!(last_used.break_value(), Some(22));
-    /// ```
-    #[unstable(feature = "control_flow_enum", reason = "new API", issue = "75744")]
-    pub const CONTINUE: Self = ControlFlow::Continue(());
-}
-
-impl<C> ControlFlow<(), C> {
-    /// APIs like `try_for_each` don't need values with `Break`,
-    /// so this provides a way to avoid typing `(())`, if you prefer it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(control_flow_enum)]
-    /// use std::ops::ControlFlow;
-    ///
-    /// let mut partial_sum = 0;
-    /// (1..10).chain(20..25).try_for_each(|x| {
-    ///     if partial_sum > 100 { ControlFlow::BREAK }
-    ///     else { partial_sum += x; ControlFlow::CONTINUE }
-    /// });
-    /// assert_eq!(partial_sum, 108);
-    /// ```
-    #[unstable(feature = "control_flow_enum", reason = "new API", issue = "75744")]
-    pub const BREAK: Self = ControlFlow::Break(());
-}

Original file line number	Diff line number	Diff line change
`@@ -93,24 +93,24 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {`
`93`	`93`	`fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {`
`94`	`94`	`if t.needs_infer() {`
`95`	`95`	`if ty::Term::from(t) == self.term {`
`96`		`- ControlFlow::BREAK`
	`96`	`+ ControlFlow::Break(())`
`97`	`97`	`} else {`
`98`	`98`	`t.super_visit_with(self)`
`99`	`99`	`}`
`100`	`100`	`} else {`
`101`		`- ControlFlow::CONTINUE`
	`101`	`+ ControlFlow::Continue(())`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {`
`106`	`106`	`if c.needs_infer() {`
`107`	`107`	`if ty::Term::from(c) == self.term {`
`108`		`- ControlFlow::BREAK`
	`108`	`+ ControlFlow::Break(())`
`109`	`109`	`} else {`
`110`	`110`	`c.super_visit_with(self)`
`111`	`111`	`}`
`112`	`112`	`} else {`
`113`		`- ControlFlow::CONTINUE`
	`113`	`+ ControlFlow::Continue(())`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ where`
`99`	`99`	`) -> impl FnMut((), T) -> ControlFlow<B> + '_ {`
`100`	`100`	`move \|(), x\| match f(x) {`
`101`	`101`	`Some(x) => ControlFlow::Break(x),`
`102`		`- None => ControlFlow::CONTINUE,`
	`102`	`+ None => ControlFlow::Continue(()),`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ where`
`539`	`539`	`#[rustc_inherit_overflow_checks]`
`540`	`540`	`fn advance<U: Iterator>(n: usize, iter: &mut U) -> ControlFlow<(), usize> {`
`541`	`541`	`match iter.advance_by(n) {`
`542`		`- Ok(()) => ControlFlow::BREAK,`
	`542`	`+ Ok(()) => ControlFlow::Break(()),`
`543`	`543`	`Err(advanced) => ControlFlow::Continue(n - advanced),`
`544`	`544`	`}`
`545`	`545`	`}`
`@@ -629,7 +629,7 @@ where`
`629`	`629`	`#[rustc_inherit_overflow_checks]`
`630`	`630`	`fn advance<U: DoubleEndedIterator>(n: usize, iter: &mut U) -> ControlFlow<(), usize> {`
`631`	`631`	`match iter.advance_back_by(n) {`
`632`		`- Ok(()) => ControlFlow::BREAK,`
	`632`	`+ Ok(()) => ControlFlow::Break(()),`
`633`	`633`	`Err(advanced) => ControlFlow::Continue(n - advanced),`
`634`	`634`	`}`
`635`	`635`	`}`
Original file line number	Diff line number	Diff line change
`@@ -352,7 +352,7 @@ pub trait DoubleEndedIterator: Iterator {`
`352`	`352`	`#[inline]`
`353`	`353`	`fn check<T>(mut predicate: impl FnMut(&T) -> bool) -> impl FnMut((), T) -> ControlFlow<T> {`
`354`	`354`	`move \|(), x\| {`
`355`		`- if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::CONTINUE }`
	`355`	`+ if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }`
`356`	`356`	`}`
`357`	`357`	`}`
`358`	`358`
Original file line number	Diff line number	Diff line change
`@@ -2601,10 +2601,10 @@ pub trait Iterator {`
`2601`	`2601`	`#[inline]`
`2602`	`2602`	`fn check<T>(mut f: impl FnMut(T) -> bool) -> impl FnMut((), T) -> ControlFlow<()> {`
`2603`	`2603`	`move \|(), x\| {`
`2604`		`- if f(x) { ControlFlow::CONTINUE } else { ControlFlow::BREAK }`
	`2604`	`+ if f(x) { ControlFlow::Continue(()) } else { ControlFlow::Break(()) }`
`2605`	`2605`	`}`
`2606`	`2606`	`}`
`2607`		`- self.try_fold((), check(f)) == ControlFlow::CONTINUE`
	`2607`	`+ self.try_fold((), check(f)) == ControlFlow::Continue(())`
`2608`	`2608`	`}`
`2609`	`2609`
`2610`	`2610`	`/// Tests if any element of the iterator matches a predicate.`
`@@ -2654,11 +2654,11 @@ pub trait Iterator {`
`2654`	`2654`	`#[inline]`
`2655`	`2655`	`fn check<T>(mut f: impl FnMut(T) -> bool) -> impl FnMut((), T) -> ControlFlow<()> {`
`2656`	`2656`	`move \|(), x\| {`
`2657`		`- if f(x) { ControlFlow::BREAK } else { ControlFlow::CONTINUE }`
	`2657`	`+ if f(x) { ControlFlow::Break(()) } else { ControlFlow::Continue(()) }`
`2658`	`2658`	`}`
`2659`	`2659`	`}`
`2660`	`2660`
`2661`		`- self.try_fold((), check(f)) == ControlFlow::BREAK`
	`2661`	`+ self.try_fold((), check(f)) == ControlFlow::Break(())`
`2662`	`2662`	`}`
`2663`	`2663`
`2664`	`2664`	`/// Searches for an element of an iterator that satisfies a predicate.`
`@@ -2717,7 +2717,7 @@ pub trait Iterator {`
`2717`	`2717`	`#[inline]`
`2718`	`2718`	`fn check<T>(mut predicate: impl FnMut(&T) -> bool) -> impl FnMut((), T) -> ControlFlow<T> {`
`2719`	`2719`	`move \|(), x\| {`
`2720`		`- if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::CONTINUE }`
	`2720`	`+ if predicate(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }`
`2721`	`2721`	`}`
`2722`	`2722`	`}`
`2723`	`2723`
`@@ -2749,7 +2749,7 @@ pub trait Iterator {`
`2749`	`2749`	`fn check<T, B>(mut f: impl FnMut(T) -> Option<B>) -> impl FnMut((), T) -> ControlFlow<B> {`
`2750`	`2750`	`move \|(), x\| match f(x) {`
`2751`	`2751`	`Some(x) => ControlFlow::Break(x),`
`2752`		`- None => ControlFlow::CONTINUE,`
	`2752`	`+ None => ControlFlow::Continue(()),`
`2753`	`2753`	`}`
`2754`	`2754`	`}`
`2755`	`2755`
`@@ -2812,7 +2812,7 @@ pub trait Iterator {`
`2812`	`2812`	`R: Residual<Option<I>>,`
`2813`	`2813`	`{`
`2814`	`2814`	`move \|(), x\| match f(&x).branch() {`
`2815`		`- ControlFlow::Continue(false) => ControlFlow::CONTINUE,`
	`2815`	`+ ControlFlow::Continue(false) => ControlFlow::Continue(()),`
`2816`	`2816`	`ControlFlow::Continue(true) => ControlFlow::Break(Try::from_output(Some(x))),`
`2817`	`2817`	`ControlFlow::Break(r) => ControlFlow::Break(FromResidual::from_residual(r)),`
`2818`	`2818`	`}`
`@@ -3491,7 +3491,7 @@ pub trait Iterator {`
`3491`	`3491`	`F: FnMut(X, Y) -> Ordering,`
`3492`	`3492`	`{`
`3493`	`3493`	`move \|x, y\| match cmp(x, y) {`
`3494`		`- Ordering::Equal => ControlFlow::CONTINUE,`
	`3494`	`+ Ordering::Equal => ControlFlow::Continue(()),`
`3495`	`3495`	`non_eq => ControlFlow::Break(non_eq),`
`3496`	`3496`	`}`
`3497`	`3497`	`}`
`@@ -3567,7 +3567,7 @@ pub trait Iterator {`
`3567`	`3567`	`F: FnMut(X, Y) -> Option<Ordering>,`
`3568`	`3568`	`{`
`3569`	`3569`	`move \|x, y\| match partial_cmp(x, y) {`
`3570`		`- Some(Ordering::Equal) => ControlFlow::CONTINUE,`
	`3570`	`+ Some(Ordering::Equal) => ControlFlow::Continue(()),`
`3571`	`3571`	`non_eq => ControlFlow::Break(non_eq),`
`3572`	`3572`	`}`
`3573`	`3573`	`}`
`@@ -3625,7 +3625,7 @@ pub trait Iterator {`
`3625`	`3625`	`F: FnMut(X, Y) -> bool,`
`3626`	`3626`	`{`
`3627`	`3627`	`move \|x, y\| {`
`3628`		`- if eq(x, y) { ControlFlow::CONTINUE } else { ControlFlow::BREAK }`
	`3628`	`+ if eq(x, y) { ControlFlow::Continue(()) } else { ControlFlow::Break(()) }`
`3629`	`3629`	`}`
`3630`	`3630`	`}`
`3631`	`3631`
`@@ -3859,7 +3859,7 @@ pub trait Iterator {`
`3859`	`3859`
`3860`	`3860`	`/// Compares two iterators element-wise using the given function.`
`3861`	`3861`	`///`
`3862`		-/// If `ControlFlow::CONTINUE` is returned from the function, the comparison moves on to the next
	`3862`	+/// If `ControlFlow::Continue(())` is returned from the function, the comparison moves on to the next
`3863`	`3863`	/// elements of both iterators. Returning `ControlFlow::Break(x)` short-circuits the iteration and
`3864`	`3864`	/// returns `ControlFlow::Break(x)`. If one of the iterators runs out of elements,
`3865`	`3865`	/// `ControlFlow::Continue(ord)` is returned where `ord` is the result of comparing the lengths of