code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/rayon-1.10.0/src/vec.rs

@@ -1,283 +0,0 @@
-//! Parallel iterator types for [vectors][std::vec] (`Vec<T>`)
-//!
-//! You will rarely need to interact with this module directly unless you need
-//! to name one of the iterator types.
-//!
-//! [std::vec]: https://doc.rust-lang.org/stable/std/vec/
-
-use crate::iter::plumbing::*;
-use crate::iter::*;
-use crate::math::simplify_range;
-use crate::slice::{Iter, IterMut};
-use std::iter;
-use std::mem;
-use std::ops::{Range, RangeBounds};
-use std::ptr;
-use std::slice;
-
-impl<'data, T: Sync + 'data> IntoParallelIterator for &'data Vec<T> {
-    type Item = &'data T;
-    type Iter = Iter<'data, T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        <&[T]>::into_par_iter(self)
-    }
-}
-
-impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut Vec<T> {
-    type Item = &'data mut T;
-    type Iter = IterMut<'data, T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        <&mut [T]>::into_par_iter(self)
-    }
-}
-
-/// Parallel iterator that moves out of a vector.
-#[derive(Debug, Clone)]
-pub struct IntoIter<T: Send> {
-    vec: Vec<T>,
-}
-
-impl<T: Send> IntoParallelIterator for Vec<T> {
-    type Item = T;
-    type Iter = IntoIter<T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        IntoIter { vec: self }
-    }
-}
-
-impl<T: Send> ParallelIterator for IntoIter<T> {
-    type Item = T;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
-impl<T: Send> IndexedParallelIterator for IntoIter<T> {
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    fn with_producer<CB>(mut self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        // Drain every item, and then the vector only needs to free its buffer.
-        self.vec.par_drain(..).with_producer(callback)
-    }
-}
-
-impl<'data, T: Send> ParallelDrainRange<usize> for &'data mut Vec<T> {
-    type Iter = Drain<'data, T>;
-    type Item = T;
-
-    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
-        Drain {
-            orig_len: self.len(),
-            range: simplify_range(range, self.len()),
-            vec: self,
-        }
-    }
-}
-
-/// Draining parallel iterator that moves a range out of a vector, but keeps the total capacity.
-#[derive(Debug)]
-pub struct Drain<'data, T: Send> {
-    vec: &'data mut Vec<T>,
-    range: Range<usize>,
-    orig_len: usize,
-}
-
-impl<'data, T: Send> ParallelIterator for Drain<'data, T> {
-    type Item = T;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
-impl<'data, T: Send> IndexedParallelIterator for Drain<'data, T> {
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        unsafe {
-            // Make the vector forget about the drained items, and temporarily the tail too.
-            self.vec.set_len(self.range.start);
-
-            // Create the producer as the exclusive "owner" of the slice.
-            let producer = DrainProducer::from_vec(self.vec, self.range.len());
-
-            // The producer will move or drop each item from the drained range.
-            callback.callback(producer)
-        }
-    }
-}
-
-impl<'data, T: Send> Drop for Drain<'data, T> {
-    fn drop(&mut self) {
-        let Range { start, end } = self.range;
-        if self.vec.len() == self.orig_len {
-            // We must not have produced, so just call a normal drain to remove the items.
-            self.vec.drain(start..end);
-        } else if start == end {
-            // Empty range, so just restore the length to its original state
-            unsafe {
-                self.vec.set_len(self.orig_len);
-            }
-        } else if end < self.orig_len {
-            // The producer was responsible for consuming the drained items.
-            // Move the tail items to their new place, then set the length to include them.
-            unsafe {
-                let ptr = self.vec.as_mut_ptr().add(start);
-                let tail_ptr = self.vec.as_ptr().add(end);
-                let tail_len = self.orig_len - end;
-                ptr::copy(tail_ptr, ptr, tail_len);
-                self.vec.set_len(start + tail_len);
-            }
-        }
-    }
-}
-
-/// ////////////////////////////////////////////////////////////////////////
-
-pub(crate) struct DrainProducer<'data, T: Send> {
-    slice: &'data mut [T],
-}
-
-impl<T: Send> DrainProducer<'_, T> {
-    /// Creates a draining producer, which *moves* items from the slice.
-    ///
-    /// Unsafe because `!Copy` data must not be read after the borrow is released.
-    pub(crate) unsafe fn new(slice: &mut [T]) -> DrainProducer<'_, T> {
-        DrainProducer { slice }
-    }
-
-    /// Creates a draining producer, which *moves* items from the tail of the vector.
-    ///
-    /// Unsafe because we're moving from beyond `vec.len()`, so the caller must ensure
-    /// that data is initialized and not read after the borrow is released.
-    unsafe fn from_vec(vec: &mut Vec<T>, len: usize) -> DrainProducer<'_, T> {
-        let start = vec.len();
-        assert!(vec.capacity() - start >= len);
-
-        // The pointer is derived from `Vec` directly, not through a `Deref`,
-        // so it has provenance over the whole allocation.
-        let ptr = vec.as_mut_ptr().add(start);
-        DrainProducer::new(slice::from_raw_parts_mut(ptr, len))
-    }
-}
-
-impl<'data, T: 'data + Send> Producer for DrainProducer<'data, T> {
-    type Item = T;
-    type IntoIter = SliceDrain<'data, T>;
-
-    fn into_iter(mut self) -> Self::IntoIter {
-        // replace the slice so we don't drop it twice
-        let slice = mem::take(&mut self.slice);
-        SliceDrain {
-            iter: slice.iter_mut(),
-        }
-    }
-
-    fn split_at(mut self, index: usize) -> (Self, Self) {
-        // replace the slice so we don't drop it twice
-        let slice = mem::take(&mut self.slice);
-        let (left, right) = slice.split_at_mut(index);
-        unsafe { (DrainProducer::new(left), DrainProducer::new(right)) }
-    }
-}
-
-impl<'data, T: 'data + Send> Drop for DrainProducer<'data, T> {
-    fn drop(&mut self) {
-        // extract the slice so we can use `Drop for [T]`
-        let slice_ptr: *mut [T] = mem::take::<&'data mut [T]>(&mut self.slice);
-        unsafe { ptr::drop_in_place::<[T]>(slice_ptr) };
-    }
-}
-
-/// ////////////////////////////////////////////////////////////////////////
-
-// like std::vec::Drain, without updating a source Vec
-pub(crate) struct SliceDrain<'data, T> {
-    iter: slice::IterMut<'data, T>,
-}
-
-impl<'data, T: 'data> Iterator for SliceDrain<'data, T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        // Coerce the pointer early, so we don't keep the
-        // reference that's about to be invalidated.
-        let ptr: *const T = self.iter.next()?;
-        Some(unsafe { ptr::read(ptr) })
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-
-    fn count(self) -> usize {
-        self.iter.len()
-    }
-}
-
-impl<'data, T: 'data> DoubleEndedIterator for SliceDrain<'data, T> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        // Coerce the pointer early, so we don't keep the
-        // reference that's about to be invalidated.
-        let ptr: *const T = self.iter.next_back()?;
-        Some(unsafe { ptr::read(ptr) })
-    }
-}
-
-impl<'data, T: 'data> ExactSizeIterator for SliceDrain<'data, T> {
-    fn len(&self) -> usize {
-        self.iter.len()
-    }
-}
-
-impl<'data, T: 'data> iter::FusedIterator for SliceDrain<'data, T> {}
-
-impl<'data, T: 'data> Drop for SliceDrain<'data, T> {
-    fn drop(&mut self) {
-        // extract the iterator so we can use `Drop for [T]`
-        let slice_ptr: *mut [T] = mem::replace(&mut self.iter, [].iter_mut()).into_slice();
-        unsafe { ptr::drop_in_place::<[T]>(slice_ptr) };
-    }
-}

data/ext/cargo-vendor/rayon-1.10.0/tests/clones.rs

@@ -1,222 +0,0 @@
-use rayon::prelude::*;
-
-fn check<I>(iter: I)
-where
-    I: ParallelIterator + Clone,
-    I::Item: std::fmt::Debug + PartialEq,
-{
-    let a: Vec<_> = iter.clone().collect();
-    let b: Vec<_> = iter.collect();
-    assert_eq!(a, b);
-}
-
-fn check_count<I>(iter: I)
-where
-    I: ParallelIterator + Clone,
-{
-    assert_eq!(iter.clone().count(), iter.count());
-}
-
-#[test]
-fn clone_binary_heap() {
-    use std::collections::BinaryHeap;
-    let heap: BinaryHeap<_> = (0..1000).collect();
-    check(heap.par_iter());
-    check(heap.into_par_iter());
-}
-
-#[test]
-fn clone_btree_map() {
-    use std::collections::BTreeMap;
-    let map: BTreeMap<_, _> = (0..1000).enumerate().collect();
-    check(map.par_iter());
-}
-
-#[test]
-fn clone_btree_set() {
-    use std::collections::BTreeSet;
-    let set: BTreeSet<_> = (0..1000).collect();
-    check(set.par_iter());
-}
-
-#[test]
-fn clone_hash_map() {
-    use std::collections::HashMap;
-    let map: HashMap<_, _> = (0..1000).enumerate().collect();
-    check(map.par_iter());
-}
-
-#[test]
-fn clone_hash_set() {
-    use std::collections::HashSet;
-    let set: HashSet<_> = (0..1000).collect();
-    check(set.par_iter());
-}
-
-#[test]
-fn clone_linked_list() {
-    use std::collections::LinkedList;
-    let list: LinkedList<_> = (0..1000).collect();
-    check(list.par_iter());
-    check(list.into_par_iter());
-}
-
-#[test]
-fn clone_vec_deque() {
-    use std::collections::VecDeque;
-    let deque: VecDeque<_> = (0..1000).collect();
-    check(deque.par_iter());
-    check(deque.into_par_iter());
-}
-
-#[test]
-fn clone_option() {
-    let option = Some(0);
-    check(option.par_iter());
-    check(option.into_par_iter());
-}
-
-#[test]
-fn clone_result() {
-    let result = Ok::<_, ()>(0);
-    check(result.par_iter());
-    check(result.into_par_iter());
-}
-
-#[test]
-fn clone_range() {
-    check((0..1000).into_par_iter());
-}
-
-#[test]
-fn clone_range_inclusive() {
-    check((0..=1000).into_par_iter());
-}
-
-#[test]
-fn clone_str() {
-    let s = include_str!("clones.rs");
-    check(s.par_chars());
-    check(s.par_lines());
-    check(s.par_split('\n'));
-    check(s.par_split_inclusive('\n'));
-    check(s.par_split_terminator('\n'));
-    check(s.par_split_whitespace());
-    check(s.par_split_ascii_whitespace());
-}
-
-#[test]
-fn clone_vec() {
-    let v: Vec<_> = (0..1000).collect();
-    check(v.par_iter());
-    check(v.par_chunk_by(i32::eq));
-    check(v.par_chunks(42));
-    check(v.par_chunks_exact(42));
-    check(v.par_rchunks(42));
-    check(v.par_rchunks_exact(42));
-    check(v.par_windows(42));
-    check(v.par_split(|x| x % 3 == 0));
-    check(v.par_split_inclusive(|x| x % 3 == 0));
-    check(v.into_par_iter());
-}
-
-#[test]
-fn clone_array() {
-    let a = [0i32; 100];
-    check(a.into_par_iter());
-}
-
-#[test]
-fn clone_adaptors() {
-    let v: Vec<_> = (0..1000).map(Some).collect();
-    check(v.par_iter().by_exponential_blocks());
-    check(v.par_iter().by_uniform_blocks(100));
-    check(v.par_iter().chain(&v));
-    check(v.par_iter().cloned());
-    check(v.par_iter().copied());
-    check(v.par_iter().enumerate());
-    check(v.par_iter().filter(|_| true));
-    check(v.par_iter().filter_map(|x| *x));
-    check(v.par_iter().flat_map(|x| *x));
-    check(v.par_iter().flat_map_iter(|x| *x));
-    check(v.par_iter().flatten());
-    check(v.par_iter().flatten_iter());
-    check(v.par_iter().with_max_len(1).fold(|| 0, |x, _| x));
-    check(v.par_iter().with_max_len(1).fold_with(0, |x, _| x));
-    check(v.par_iter().with_max_len(1).fold_chunks(1, || 0, |x, _| x));
-    check(
-        v.par_iter()
-            .with_max_len(1)
-            .fold_chunks_with(1, 0, |x, _| x),
-    );
-    check(v.par_iter().with_max_len(1).try_fold(|| 0, |_, &x| x));
-    check(v.par_iter().with_max_len(1).try_fold_with(0, |_, &x| x));
-    check(v.par_iter().inspect(|_| ()));
-    check(v.par_iter().update(|_| ()));
-    check(v.par_iter().interleave(&v));
-    check(v.par_iter().interleave_shortest(&v));
-    check(v.par_iter().intersperse(&None));
-    check(v.par_iter().chunks(3));
-    check(v.par_iter().map(|x| x));
-    check(v.par_iter().map_with(0, |_, x| x));
-    check(v.par_iter().map_init(|| 0, |_, x| x));
-    check(v.par_iter().panic_fuse());
-    check(v.par_iter().positions(|_| true));
-    check(v.par_iter().rev());
-    check(v.par_iter().skip(42));
-    check(v.par_iter().skip_any_while(|_| false));
-    check(v.par_iter().take(42));
-    check(v.par_iter().take_any_while(|_| true));
-    check(v.par_iter().cloned().while_some());
-    check(v.par_iter().with_max_len(1));
-    check(v.par_iter().with_min_len(1));
-    check(v.par_iter().zip(&v));
-    check(v.par_iter().zip_eq(&v));
-    check(v.par_iter().step_by(2));
-}
-
-#[test]
-fn clone_counted_adaptors() {
-    let v: Vec<_> = (0..1000).collect();
-    check_count(v.par_iter().skip_any(42));
-    check_count(v.par_iter().take_any(42));
-}
-
-#[test]
-fn clone_empty() {
-    check(rayon::iter::empty::<i32>());
-}
-
-#[test]
-fn clone_once() {
-    check(rayon::iter::once(10));
-}
-
-#[test]
-fn clone_repeat() {
-    let x: Option<i32> = None;
-    check(rayon::iter::repeat(x).while_some());
-    check(rayon::iter::repeatn(x, 1000));
-}
-
-#[test]
-fn clone_splitter() {
-    check(rayon::iter::split(0..1000, |x| (x, None)));
-}
-
-#[test]
-fn clone_multizip() {
-    let v: &Vec<_> = &(0..1000).collect();
-    check((v,).into_par_iter());
-    check((v, v).into_par_iter());
-    check((v, v, v).into_par_iter());
-    check((v, v, v, v).into_par_iter());
-    check((v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
-}

data/ext/cargo-vendor/rayon-1.10.0/tests/collect.rs

@@ -1,113 +0,0 @@
-use rayon::prelude::*;
-
-use std::panic;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
-use std::sync::Mutex;
-
-#[test]
-#[cfg_attr(not(panic = "unwind"), ignore)]
-fn collect_drop_on_unwind() {
-    struct Recorddrop<'a>(i64, &'a Mutex<Vec<i64>>);
-
-    impl<'a> Drop for Recorddrop<'a> {
-        fn drop(&mut self) {
-            self.1.lock().unwrap().push(self.0);
-        }
-    }
-
-    let test_collect_panic = |will_panic: bool| {
-        let test_vec_len = 1024;
-        let panic_point = 740;
-
-        let mut inserts = Mutex::new(Vec::new());
-        let mut drops = Mutex::new(Vec::new());
-
-        let mut a = (0..test_vec_len).collect::<Vec<_>>();
-        let b = (0..test_vec_len).collect::<Vec<_>>();
-
-        let _result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            let mut result = Vec::new();
-            a.par_iter_mut()
-                .zip(&b)
-                .map(|(&mut a, &b)| {
-                    if a > panic_point && will_panic {
-                        panic!("unwinding for test");
-                    }
-                    let elt = a + b;
-                    inserts.lock().unwrap().push(elt);
-                    Recorddrop(elt, &drops)
-                })
-                .collect_into_vec(&mut result);
-
-            // If we reach this point, this must pass
-            assert_eq!(a.len(), result.len());
-        }));
-
-        let inserts = inserts.get_mut().unwrap();
-        let drops = drops.get_mut().unwrap();
-        println!("{:?}", inserts);
-        println!("{:?}", drops);
-
-        assert_eq!(inserts.len(), drops.len(), "Incorrect number of drops");
-        // sort to normalize order
-        inserts.sort();
-        drops.sort();
-        assert_eq!(inserts, drops, "Incorrect elements were dropped");
-    };
-
-    for &should_panic in &[true, false] {
-        test_collect_panic(should_panic);
-    }
-}
-
-#[test]
-#[cfg_attr(not(panic = "unwind"), ignore)]
-fn collect_drop_on_unwind_zst() {
-    static INSERTS: AtomicUsize = AtomicUsize::new(0);
-    static DROPS: AtomicUsize = AtomicUsize::new(0);
-
-    struct RecorddropZst;
-
-    impl Drop for RecorddropZst {
-        fn drop(&mut self) {
-            DROPS.fetch_add(1, Ordering::SeqCst);
-        }
-    }
-
-    let test_collect_panic = |will_panic: bool| {
-        INSERTS.store(0, Ordering::SeqCst);
-        DROPS.store(0, Ordering::SeqCst);
-
-        let test_vec_len = 1024;
-        let panic_point = 740;
-
-        let a = (0..test_vec_len).collect::<Vec<_>>();
-
-        let _result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            let mut result = Vec::new();
-            a.par_iter()
-                .map(|&a| {
-                    if a > panic_point && will_panic {
-                        panic!("unwinding for test");
-                    }
-                    INSERTS.fetch_add(1, Ordering::SeqCst);
-                    RecorddropZst
-                })
-                .collect_into_vec(&mut result);
-
-            // If we reach this point, this must pass
-            assert_eq!(a.len(), result.len());
-        }));
-
-        let inserts = INSERTS.load(Ordering::SeqCst);
-        let drops = DROPS.load(Ordering::SeqCst);
-
-        assert_eq!(inserts, drops, "Incorrect number of drops");
-        assert!(will_panic || drops == test_vec_len)
-    };
-
-    for &should_panic in &[true, false] {
-        test_collect_panic(should_panic);
-    }
-}