New upstream version 1.63.0+dfsg1

[rustc.git] / vendor / rustc-rayon / src / iter / try_reduce.rs

diff --git a/vendor/rustc-rayon/src/iter/try_reduce.rs b/vendor/rustc-rayon/src/iter/try_reduce.rs
index 76b38505d11da17275c75d61c015b415b9cb2d47..7bf6cc4a5c3b9d43e1d0055bf328b30c86102cb2 100644 (file)
--- a/vendor/rustc-rayon/src/iter/try_reduce.rs
+++ b/vendor/rustc-rayon/src/iter/try_reduce.rs
@@ -1,14 +1,16 @@
 use super::plumbing::*;
 use super::ParallelIterator;
+use super::Try;
+
+use super::private::ControlFlow::{self, Break, Continue};
 
-use super::private::Try;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 pub(super) fn try_reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
 where
     PI: ParallelIterator<Item = T>,
-    R: Fn(T::Ok, T::Ok) -> T + Sync,
-    ID: Fn() -> T::Ok + Sync,
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
     T: Try + Send,
 {
     let full = AtomicBool::new(false);
@@ -36,8 +38,8 @@ impl<'r, R, ID> Clone for TryReduceConsumer<'r, R, ID> {
 
 impl<'r, R, ID, T> Consumer<T> for TryReduceConsumer<'r, R, ID>
 where
-    R: Fn(T::Ok, T::Ok) -> T + Sync,
-    ID: Fn() -> T::Ok + Sync,
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
     T: Try + Send,
 {
     type Folder = TryReduceFolder<'r, R, T>;
@@ -51,7 +53,7 @@ where
     fn into_folder(self) -> Self::Folder {
         TryReduceFolder {
             reduce_op: self.reduce_op,
-            result: Ok((self.identity)()),
+            control: Continue((self.identity)()),
             full: self.full,
         }
     }
@@ -63,8 +65,8 @@ where
 
 impl<'r, R, ID, T> UnindexedConsumer<T> for TryReduceConsumer<'r, R, ID>
 where
-    R: Fn(T::Ok, T::Ok) -> T + Sync,
-    ID: Fn() -> T::Ok + Sync,
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
     T: Try + Send,
 {
     fn split_off_left(&self) -> Self {
@@ -78,52 +80,53 @@ where
 
 impl<'r, R, ID, T> Reducer<T> for TryReduceConsumer<'r, R, ID>
 where
-    R: Fn(T::Ok, T::Ok) -> T + Sync,
+    R: Fn(T::Output, T::Output) -> T + Sync,
     T: Try,
 {
     fn reduce(self, left: T, right: T) -> T {
-        match (left.into_result(), right.into_result()) {
-            (Ok(left), Ok(right)) => (self.reduce_op)(left, right),
-            (Err(e), _) | (_, Err(e)) => T::from_error(e),
+        match (left.branch(), right.branch()) {
+            (Continue(left), Continue(right)) => (self.reduce_op)(left, right),
+            (Break(r), _) | (_, Break(r)) => T::from_residual(r),
         }
     }
 }
 
 struct TryReduceFolder<'r, R, T: Try> {
     reduce_op: &'r R,
-    result: Result<T::Ok, T::Error>,
+    control: ControlFlow<T::Residual, T::Output>,
     full: &'r AtomicBool,
 }
 
 impl<'r, R, T> Folder<T> for TryReduceFolder<'r, R, T>
 where
-    R: Fn(T::Ok, T::Ok) -> T,
+    R: Fn(T::Output, T::Output) -> T,
     T: Try,
 {
     type Result = T;
 
     fn consume(mut self, item: T) -> Self {
         let reduce_op = self.reduce_op;
-        if let Ok(left) = self.result {
-            self.result = match item.into_result() {
-                Ok(right) => reduce_op(left, right).into_result(),
-                Err(error) => Err(error),
-            };
-        }
-        if self.result.is_err() {
-            self.full.store(true, Ordering::Relaxed)
+        self.control = match (self.control, item.branch()) {
+            (Continue(left), Continue(right)) => reduce_op(left, right).branch(),
+            (control @ Break(_), _) | (_, control @ Break(_)) => control,
+        };
+        if let Break(_) = self.control {
+            self.full.store(true, Ordering::Relaxed);
         }
         self
     }
 
     fn complete(self) -> T {
-        match self.result {
-            Ok(ok) => T::from_ok(ok),
-            Err(error) => T::from_error(error),
+        match self.control {
+            Continue(c) => T::from_output(c),
+            Break(r) => T::from_residual(r),
         }
     }
 
     fn full(&self) -> bool {
-        self.full.load(Ordering::Relaxed)
+        match self.control {
+            Break(_) => true,
+            _ => self.full.load(Ordering::Relaxed),
+        }
     }
 }