move get_disjoint_mut impl to separate file to work around lexer error in old rust versions

Author: cmrschwarz

src/get_disjoint_mut.rs

@@ -0,0 +1,64 @@
+use crate::Slab;
+
+use core::mem::MaybeUninit;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// The error type returned by [`Slab::get_disjoint_mut`].
+pub enum GetDisjointMutError {
+    /// An index provided was not associated with a value.
+    IndexVacant,
+
+    /// An index provided was out-of-bounds for the slab.
+    IndexOutOfBounds,
+
+    /// Two indices provided were overlapping.
+    OverlappingIndices,
+}
+
+impl<T> Slab<T> {
+    /// Returns mutable references to many indices at once.
+    /// Returns [`GetDisjointMutError`] if the indices are out of bounds,
+    /// overlapping, or vacant.
+    #[cfg(not(slab_no_const_generics))]
+    pub fn get_disjoint_mut<const N: usize>(
+        &mut self,
+        keys: [usize; N],
+    ) -> Result<[&mut T; N], GetDisjointMutError> {
+        use crate::Entry;
+
+        let entries_cap = self.entries.capacity();
+
+        // NB: The optimizer should inline the loops into a sequence
+        // of instructions without additional branching.
+        for (i, &key) in keys.iter().enumerate() {
+            if key >= entries_cap {
+                return Err(GetDisjointMutError::IndexOutOfBounds);
+            }
+            for &prev_key in &keys[..i] {
+                if key == prev_key {
+                    return Err(GetDisjointMutError::OverlappingIndices);
+                }
+            }
+        }
+
+        let mut res = MaybeUninit::<[&mut T; N]>::uninit();
+        let res_ptr = res.as_mut_ptr() as *mut &mut T;
+
+        let entries_ptr = self.entries.as_mut_ptr();
+
+        for (i, &key) in keys.iter().enumerate() {
+            // SAFETY: we made sure above that this key is in bounds.
+            match unsafe { &mut *entries_ptr.add(key) } {
+                Entry::Vacant(_) => return Err(GetDisjointMutError::IndexVacant),
+                Entry::Occupied(entry) => {
+                    // SAFETY: `res` and `keys` both have N elements so `i` must be in bounds.
+                    // We checked above that all selected `entry`s are distinct.
+                    unsafe { res_ptr.add(i).write(entry) };
+                }
+            }
+        }
+        // SAFETY: the loop above only terminates successfully if it initialized
+        // all elements of this array.
+        Ok(unsafe { res.assume_init() })
+    }
+}

src/lib.rs

@@ -121,11 +121,16 @@ extern crate std as alloc;
 #[cfg(feature = "serde")]
 mod serde;
 
+#[cfg(not(slab_no_const_generics))]
+mod get_disjoint_mut;
+
+#[cfg(not(slab_no_const_generics))]
+pub use get_disjoint_mut::GetDisjointMutError;
+
 mod builder;
 
 use alloc::vec::{self, Vec};
 use core::iter::{self, FromIterator, FusedIterator};
-use core::mem::MaybeUninit;
 use core::{fmt, mem, ops, slice};
 
 /// Pre-allocated storage for a uniform data type
@@ -237,19 +242,6 @@ enum Entry<T> {
     Occupied(T),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-/// The error type returned by [`Slab::get_disjoint_mut`].
-pub enum GetDisjointMutError {
-    /// An index provided was not associated with a value.
-    IndexVacant,
-
-    /// An index provided was out-of-bounds for the slab.
-    IndexOutOfBounds,
-
-    /// Two indices provided were overlapping.
-    OverlappingIndices,
-}
-
 impl<T> Slab<T> {
     /// Construct a new, empty `Slab`.
     ///
@@ -807,50 +799,6 @@ impl<T> Slab<T> {
         }
     }
 
-    /// Returns mutable references to many indices at once.
-    /// Returns [`GetDisjointMutError`] if the indices are out of bounds,
-    /// overlapping, or vacant.
-    #[cfg(not(slab_no_const_generics))]
-    pub fn get_disjoint_mut<const N: usize>(
-        &mut self,
-        keys: [usize; N],
-    ) -> Result<[&mut T; N], GetDisjointMutError> {
-        let entries_cap = self.entries.capacity();
-
-        // NB: The optimizer should inline the loops into a sequence
-        // of instructions without additional branching.
-        for (i, &key) in keys.iter().enumerate() {
-            if key >= entries_cap {
-                return Err(GetDisjointMutError::IndexOutOfBounds);
-            }
-            for &prev_key in &keys[..i] {
-                if key == prev_key {
-                    return Err(GetDisjointMutError::OverlappingIndices);
-                }
-            }
-        }
-
-        let mut res = MaybeUninit::<[&mut T; N]>::uninit();
-        let res_ptr = res.as_mut_ptr() as *mut &mut T;
-
-        let entries_ptr = self.entries.as_mut_ptr();
-
-        for (i, &key) in keys.iter().enumerate() {
-            // SAFETY: we made sure above that this key is in bounds.
-            match unsafe { &mut *entries_ptr.add(key) } {
-                Entry::Vacant(_) => return Err(GetDisjointMutError::IndexVacant),
-                Entry::Occupied(entry) => {
-                    // SAFETY: `res` and `keys` both have N elements so `i` must be in bounds.
-                    // We checked above that all selected `entry`s are distinct.
-                    unsafe { res_ptr.add(i).write(entry) };
-                }
-            }
-        }
-        // SAFETY: the loop above only terminates successfully if it initialized
-        // all elements of this array.
-        Ok(unsafe { res.assume_init() })
-    }
-
     /// Return a reference to the value associated with the given key without
     /// performing bounds checking.
     ///