work with tree borrows

credit: ferrilab#266

Author: JieningYu

src/ptr/span.rs

@@ -243,10 +243,17 @@ where
 	/// [`::new`]: Self::new
 	#[cfg(feature = "alloc")]
 	pub(crate) unsafe fn set_address(&mut self, addr: Address<M, T>) {
-		let mut addr_value = addr.to_const() as usize;
-		addr_value &= Self::PTR_ADDR_MASK;
-		addr_value |= self.ptr.as_ptr() as usize & Self::PTR_HEAD_MASK;
-		self.ptr = NonNull::new_unchecked(addr_value as *mut ())
+		self.ptr = NonNull::new_unchecked(
+			addr.to_const()
+				.map_addr(|mut addr_value| {
+					addr_value &= Self::PTR_ADDR_MASK;
+					addr_value |=
+						self.ptr.as_ptr() as usize & Self::PTR_HEAD_MASK;
+					addr_value
+				})
+				.cast::<()>()
+				.cast_mut(),
+		)
 	}
 
 	/// Gets the starting bit index of the referent region.
@@ -283,11 +290,12 @@ where
 	#[cfg(feature = "alloc")]
 	pub(crate) unsafe fn set_head(&mut self, head: BitIdx<T::Mem>) {
 		let head = head.into_inner() as usize;
-		let mut ptr = self.ptr.as_ptr() as usize;
-
-		ptr &= Self::PTR_ADDR_MASK;
-		ptr |= head >> Self::LEN_HEAD_BITS;
-		self.ptr = NonNull::new_unchecked(ptr as *mut ());
+		self.ptr =
+			NonNull::new_unchecked(self.ptr.as_ptr().map_addr(|mut ptr| {
+				ptr &= Self::PTR_ADDR_MASK;
+				ptr |= head >> Self::LEN_HEAD_BITS;
+				ptr
+			}));
 
 		self.len &= !Self::LEN_HEAD_MASK;
 		self.len |= head & Self::LEN_HEAD_MASK;

src/ptr/tests.rs

@@ -7,13 +7,7 @@ use core::cmp;
 use crate::{
 	index::BitIdx,
 	prelude::*,
-	ptr::{
-		self as bv_ptr,
-		AddressExt,
-		BitSpan,
-		BitSpanError,
-		Mut,
-	},
+	ptr::{self as bv_ptr, AddressExt, BitSpan, BitSpanError, Mut},
 };
 
 #[test]
@@ -23,13 +17,15 @@ fn free_functions() {
 
 	let one = BitPtr::<Mut, u8, Lsb0>::from_slice_mut(&mut a[..]);
 	let two = one.wrapping_add(8);
-	let three = BitPtr::<Mut, u16, Msb0>::from_mut(&mut b);
-	let four = three.wrapping_add(8);
 
 	unsafe {
 		bv_ptr::copy(two.to_const(), one, 8);
 	}
 	assert_eq!(a[0], !0);
+
+	let one = BitPtr::<Mut, u8, Lsb0>::from_slice_mut(&mut a);
+	let three = BitPtr::<Mut, u16, Msb0>::from_mut(&mut b);
+
 	unsafe {
 		bv_ptr::copy(three.to_const(), one, 8);
 	}
@@ -43,6 +39,9 @@ fn free_functions() {
 	assert_eq!(a[1], 0);
 	assert_eq!(b, !0);
 
+	let three = BitPtr::<Mut, u16, Msb0>::from_mut(&mut b);
+	let four = three.wrapping_add(8);
+
 	unsafe {
 		bv_ptr::write_bits(four, false, 8);
 	}

src/slice.rs

@@ -2,44 +2,26 @@
 
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
-use core::{
-	marker::PhantomData,
-	ops::RangeBounds,
-};
+use core::{marker::PhantomData, ops::RangeBounds};
+use std::cell::UnsafeCell;
 
 use funty::Integral;
 use tap::Pipe;
 #[cfg(feature = "alloc")]
 use tap::Tap;
 use wyz::{
 	bidi::BidiIterator,
-	comu::{
-		Const,
-		Mut,
-	},
+	comu::{Const, Mut},
 	range::RangeExt,
 };
 
 #[cfg(feature = "alloc")]
 use crate::vec::BitVec;
 use crate::{
-	domain::{
-		BitDomain,
-		Domain,
-	},
+	domain::{BitDomain, Domain},
 	mem,
-	order::{
-		BitOrder,
-		Lsb0,
-		Msb0,
-	},
-	ptr::{
-		self as bv_ptr,
-		BitPtr,
-		BitPtrRange,
-		BitSpan,
-		BitSpanError,
-	},
+	order::{BitOrder, Lsb0, Msb0},
+	ptr::{self as bv_ptr, BitPtr, BitPtrRange, BitSpan, BitSpanError},
 	store::BitStore,
 };
 
@@ -50,10 +32,7 @@ mod specialization;
 mod tests;
 mod traits;
 
-pub use self::{
-	api::*,
-	iter::*,
-};
+pub use self::{api::*, iter::*};
 
 #[repr(transparent)]
 #[doc = include_str!("../doc/slice/BitSlice.md")]
@@ -82,7 +61,7 @@ where
 	///
 	/// See `ptr::span` for more information on the encoding scheme used in
 	/// references to `BitSlice`.
-	_mem: [()],
+	_mem: [UnsafeCell<()>],
 }
 
 /// Constructors.
@@ -289,8 +268,7 @@ where
 			elts.saturating_mul(mem::bits_of::<T::Mem>())
 				.pipe(BitSpanError::TooLong)
 				.pipe(Err)
-		}
-		else {
+		} else {
 			Ok(unsafe { Self::from_slice_unchecked(slice) })
 		}
 	}
@@ -378,8 +356,7 @@ where
 			elts.saturating_mul(mem::bits_of::<T::Mem>())
 				.pipe(BitSpanError::TooLong)
 				.pipe(Err)
-		}
-		else {
+		} else {
 			Ok(unsafe { Self::from_slice_unchecked_mut(slice) })
 		}
 	}
@@ -805,7 +782,7 @@ where
 	/// ```
 	#[inline]
 	pub fn replace(&mut self, index: usize, value: bool) -> bool {
-		self.assert_in_bounds(index, 0 .. self.len());
+		self.assert_in_bounds(index, 0..self.len());
 		unsafe { self.replace_unchecked(index, value) }
 	}
 
@@ -948,7 +925,9 @@ where
 	/// ```
 	#[inline]
 	pub unsafe fn copy_within_unchecked<R>(&mut self, src: R, dest: usize)
-	where R: RangeExt<usize> {
+	where
+		R: RangeExt<usize>,
+	{
 		if let Some(this) = self.coerce_mut::<T, Lsb0>() {
 			return this.sp_copy_within_unchecked(src, dest);
 		}
@@ -958,7 +937,7 @@ where
 		let source = src.normalize(0, self.len());
 		let source_len = source.len();
 		let rev = source.contains(&dest);
-		let dest = dest .. dest + source_len;
+		let dest = dest..dest + source_len;
 		for (from, to) in self
 			.get_unchecked(source)
 			.as_bitptr_range()
@@ -1490,8 +1469,8 @@ where
 		);
 
 		unsafe {
-			self.copy_within_unchecked(by .., 0);
-			self.get_unchecked_mut(len - by ..).fill(false);
+			self.copy_within_unchecked(by.., 0);
+			self.get_unchecked_mut(len - by..).fill(false);
 		}
 	}
 
@@ -1556,8 +1535,8 @@ where
 		);
 
 		unsafe {
-			self.copy_within_unchecked(.. len - by, by);
-			self.get_unchecked_mut(.. by).fill(false);
+			self.copy_within_unchecked(..len - by, by);
+			self.get_unchecked_mut(..by).fill(false);
 		}
 	}
 
@@ -1598,7 +1577,9 @@ where
 	///
 	/// This panics if `bounds` is outside `index`.
 	pub(crate) fn assert_in_bounds<R>(&self, index: usize, bounds: R)
-	where R: RangeExt<usize> {
+	where
+		R: RangeExt<usize>,
+	{
 		let bounds = bounds.normalize(0, self.len());
 		assert!(
 			bounds.contains(&index),
@@ -1690,7 +1671,7 @@ where
 	/// [`.set()`]: Self::set
 	#[inline]
 	pub fn set_aliased(&self, index: usize, value: bool) {
-		self.assert_in_bounds(index, 0 .. self.len());
+		self.assert_in_bounds(index, 0..self.len());
 		unsafe {
 			self.set_aliased_unchecked(index, value);
 		}

src/slice/traits.rs

@@ -6,22 +6,13 @@ use core::{
 	cmp,
 	convert::TryFrom,
 	fmt::{
-		self,
-		Binary,
-		Debug,
-		Display,
-		Formatter,
-		LowerHex,
-		Octal,
-		Pointer,
+		self, Binary, Debug, Display, Formatter, LowerHex, Octal, Pointer,
 		UpperHex,
 	},
-	hash::{
-		Hash,
-		Hasher,
-	},
+	hash::{Hash, Hasher},
 	str,
 };
+use std::panic::RefUnwindSafe;
 
 use wyz::fmt::FmtForward;
 
@@ -31,11 +22,7 @@ use crate::vec::BitVec;
 use crate::{
 	domain::Domain,
 	mem,
-	order::{
-		BitOrder,
-		Lsb0,
-		Msb0,
-	},
+	order::{BitOrder, Lsb0, Msb0},
 	store::BitStore,
 	view::BitView,
 };
@@ -107,13 +94,11 @@ where
 			(self.coerce::<T1, Lsb0>(), rhs.coerce::<T1, Lsb0>())
 		{
 			this.sp_eq(that)
-		}
-		else if let (Some(this), Some(that)) =
+		} else if let (Some(this), Some(that)) =
 			(self.coerce::<T1, Msb0>(), rhs.coerce::<T1, Msb0>())
 		{
 			this.sp_eq(that)
-		}
-		else {
+		} else {
 			self.len() == rhs.len()
 				&& self
 					.iter()
@@ -410,8 +395,8 @@ where
 		val |= bit as u8;
 	}
 	match val {
-		v @ 0 ..= 9 => b'0' + v,
-		v @ 10 ..= 35 => alpha - 10 + v,
+		v @ 0..=9 => b'0' + v,
+		v @ 10..=35 => alpha - 10 + v,
 		_ => unreachable!(
 			"bit-slices wider than five bits cannot be rendered to ASCII b36"
 		),
@@ -450,7 +435,7 @@ where
 		*slot = bits_to_ascii(chunk, alpha);
 		skip += 1;
 	}
-	unsafe { str::from_utf8_unchecked(&into[.. skip]) }
+	unsafe { str::from_utf8_unchecked(&into[..skip]) }
 }
 
 /// Constructs the numeric formatting implementations.
@@ -536,11 +521,20 @@ where
 {
 	#[inline]
 	fn hash<H>(&self, hasher: &mut H)
-	where H: Hasher {
+	where
+		H: Hasher,
+	{
 		self.iter().by_vals().for_each(|bit| bit.hash(hasher));
 	}
 }
 
+impl<T, O> RefUnwindSafe for BitSlice<T, O>
+where
+	T: BitStore + RefUnwindSafe,
+	O: BitOrder,
+{
+}
+
 #[doc = include_str!("../../doc/slice/threadsafe.md")]
 unsafe impl<T, O> Send for BitSlice<T, O>
 where