Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 158 insertions, 0 deletions

diff --git a/third_party/rust/indexmap/src/rustc.rs b/third_party/rust/indexmap/src/rustc.rs
new file mode 100644
index 0000000000..b843858b32
--- /dev/null
+++ b/third_party/rust/indexmap/src/rustc.rs
@@ -0,0 +1,158 @@
+//! Minimal support for `rustc-rayon`, not intended for general use.
+
+use crate::vec::Vec;
+use crate::{Bucket, Entries, IndexMap, IndexSet};
+
+use rustc_rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
+use rustc_rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator};
+
+mod map {
+    use super::*;
+
+    impl<K, V, S> IntoParallelIterator for IndexMap<K, V, S>
+    where
+        K: Send,
+        V: Send,
+    {
+        type Item = (K, V);
+        type Iter = IntoParIter<K, V>;
+
+        fn into_par_iter(self) -> Self::Iter {
+            IntoParIter {
+                entries: self.into_entries(),
+            }
+        }
+    }
+
+    pub struct IntoParIter<K, V> {
+        entries: Vec<Bucket<K, V>>,
+    }
+
+    impl<K: Send, V: Send> ParallelIterator for IntoParIter<K, V> {
+        type Item = (K, V);
+
+        parallel_iterator_methods!(Bucket::key_value);
+    }
+
+    impl<K: Send, V: Send> IndexedParallelIterator for IntoParIter<K, V> {
+        indexed_parallel_iterator_methods!(Bucket::key_value);
+    }
+
+    impl<'a, K, V, S> IntoParallelIterator for &'a IndexMap<K, V, S>
+    where
+        K: Sync,
+        V: Sync,
+    {
+        type Item = (&'a K, &'a V);
+        type Iter = ParIter<'a, K, V>;
+
+        fn into_par_iter(self) -> Self::Iter {
+            ParIter {
+                entries: self.as_entries(),
+            }
+        }
+    }
+
+    pub struct ParIter<'a, K, V> {
+        entries: &'a [Bucket<K, V>],
+    }
+
+    impl<'a, K: Sync, V: Sync> ParallelIterator for ParIter<'a, K, V> {
+        type Item = (&'a K, &'a V);
+
+        parallel_iterator_methods!(Bucket::refs);
+    }
+
+    impl<K: Sync, V: Sync> IndexedParallelIterator for ParIter<'_, K, V> {
+        indexed_parallel_iterator_methods!(Bucket::refs);
+    }
+
+    impl<'a, K, V, S> IntoParallelIterator for &'a mut IndexMap<K, V, S>
+    where
+        K: Sync + Send,
+        V: Send,
+    {
+        type Item = (&'a K, &'a mut V);
+        type Iter = ParIterMut<'a, K, V>;
+
+        fn into_par_iter(self) -> Self::Iter {
+            ParIterMut {
+                entries: self.as_entries_mut(),
+            }
+        }
+    }
+
+    pub struct ParIterMut<'a, K, V> {
+        entries: &'a mut [Bucket<K, V>],
+    }
+
+    impl<'a, K: Sync + Send, V: Send> ParallelIterator for ParIterMut<'a, K, V> {
+        type Item = (&'a K, &'a mut V);
+
+        parallel_iterator_methods!(Bucket::ref_mut);
+    }
+
+    impl<K: Sync + Send, V: Send> IndexedParallelIterator for ParIterMut<'_, K, V> {
+        indexed_parallel_iterator_methods!(Bucket::ref_mut);
+    }
+}
+
+mod set {
+    use super::*;
+
+    impl<T, S> IntoParallelIterator for IndexSet<T, S>
+    where
+        T: Send,
+    {
+        type Item = T;
+        type Iter = IntoParIter<T>;
+
+        fn into_par_iter(self) -> Self::Iter {
+            IntoParIter {
+                entries: self.into_entries(),
+            }
+        }
+    }
+
+    pub struct IntoParIter<T> {
+        entries: Vec<Bucket<T, ()>>,
+    }
+
+    impl<T: Send> ParallelIterator for IntoParIter<T> {
+        type Item = T;
+
+        parallel_iterator_methods!(Bucket::key);
+    }
+
+    impl<T: Send> IndexedParallelIterator for IntoParIter<T> {
+        indexed_parallel_iterator_methods!(Bucket::key);
+    }
+
+    impl<'a, T, S> IntoParallelIterator for &'a IndexSet<T, S>
+    where
+        T: Sync,
+    {
+        type Item = &'a T;
+        type Iter = ParIter<'a, T>;
+
+        fn into_par_iter(self) -> Self::Iter {
+            ParIter {
+                entries: self.as_entries(),
+            }
+        }
+    }
+
+    pub struct ParIter<'a, T> {
+        entries: &'a [Bucket<T, ()>],
+    }
+
+    impl<'a, T: Sync> ParallelIterator for ParIter<'a, T> {
+        type Item = &'a T;
+
+        parallel_iterator_methods!(Bucket::key_ref);
+    }
+
+    impl<T: Sync> IndexedParallelIterator for ParIter<'_, T> {
+        indexed_parallel_iterator_methods!(Bucket::key_ref);
+    }
+}