fastring/

sync.rs

//! Atomic-reference-counted string type, with support for zero-cost literals
//! and more.
//!
//! This module is modified from [`arcstr`] crate.
//!
//! [`arcstr`]: https://crates.io/crates/arcstr

#![allow(clippy::inline_always, reason = "XXX")]
#![allow(clippy::must_use_candidate, reason = "XXX")]

use alloc::fmt;
use core::alloc::Layout;
use core::borrow::Borrow;
use core::convert::Infallible;
use core::hash::{Hash, Hasher};
use core::mem::{MaybeUninit, align_of, offset_of};
use core::ptr::NonNull;
use core::str::Utf8Error;
#[cfg(not(all(loom, test)))]
use core::sync::atomic;
#[cfg(not(all(loom, test)))]
use core::sync::atomic::{AtomicUsize, Ordering};
use core::{mem, ops, ptr, slice, str};

#[cfg(all(loom, test))]
use loom::sync::atomic;
#[cfg(all(loom, test))]
use loom::sync::atomic::{AtomicUsize, Ordering};

#[macro_export]
/// Constructs a static [`ArcStr`] from a string literal.
///
/// ## Examples
///
/// ```rust
/// use fastring::{ArcStr, arc};
///
/// // Creates an empty, static `ArcStr`
/// let empty = arc!("");
/// assert_eq!(&empty, "");
///
/// // Creates a non-empty, static `ArcStr`
/// let foobar = arc!("foobar");
/// assert_eq!(&foobar, "foobar");
///
/// // Cloning the static `ArcStr`.
/// let foobarr = foobar.clone();
/// assert!(ArcStr::ptr_eq(&foobar, &foobarr));
/// assert_eq!(&foobarr, "foobar");
///
/// // Dropping the `ArcStr` created by `arc!()` is a no-op.
/// drop(foobar);
/// assert_eq!(&foobarr, "foobar");
///
/// // Thanks to crate `constcat`, we support concatenation of string literals in `arc!()`.
/// # let foobar = arc!("testing",);
/// # assert_eq!(foobar, "testing");
/// let foobar = arc!("testing", " ", "foobar");
/// assert_eq!(foobar, "testing foobar");
/// # let foobar = arc!("testing", " ", "foobar",);
/// assert_eq!(foobar, "testing foobar");
/// ```
macro_rules! arc {
    ($text:expr $(,)?) => {{
        const __TEXT: &str = $text;

        const _: () = {
            $crate::sync::arc_inner_layout_check::<{ __TEXT.len() }>();
        };

        {
            const __ARC_INNER: &$crate::sync::ArcInner<usize, { __TEXT.len() }> =
                &$crate::sync::ArcInner::constified(*__TEXT.as_bytes().as_array().expect(
                    "infallible: the length of the array is exactly the length of the string",
                ));

            #[allow(unsafe_code, reason = "XXX")]
            const __ARC_STR: $crate::sync::ArcStr = unsafe {
                $crate::sync::ArcStr::from_raw(::core::ptr::NonNull::new_unchecked(
                    (&raw const *__ARC_INNER)
                        .cast::<$crate::sync::ArcInner>()
                        .cast_mut(),
                ))
            };

            __ARC_STR
        }
    }};
    ($($text:expr),+ $(,)?) => {
        $crate::arc!($crate::util::constcat::concat!($($text),+))
    };
}

#[macro_export]
/// Conceptually equivalent to `ArcStr::new(format!("...", args...))`.
///
/// If all your arguments are string literals / const strings, consider using
/// the [`arc!()`](crate::arc) macro instead.
///
/// ## Examples
///
/// ```rust
/// let foobar = fastring::arcfmt!("testing {}", "foobar");
///
/// assert_eq!(foobar, "testing foobar");
/// ```
macro_rules! arcfmt {
    ($($tt:tt)*) => {
        $crate::sync::ArcStr::new($crate::util::format(::core::format_args!($($tt)*)))
    };
}

wrapper_lite::wrapper!(
    #[repr(transparent)]
    /// An atomic-reference-counted string type, with support for zero-cost
    /// literals and more.
    pub struct ArcStr(NonNull<ArcInner>);
);

#[allow(
    unsafe_code,
    reason = "Thread safety is guaranteed by atomic reference counting."
)]
unsafe impl Send for ArcStr {}

#[allow(
    unsafe_code,
    reason = "Thread safety is guaranteed by atomic reference counting."
)]
unsafe impl Sync for ArcStr {}

impl ArcStr {
    #[inline]
    /// Constructs an empty [`ArcStr`].
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let foobar = ArcStr::empty();
    ///
    /// assert!(&foobar == "");
    /// assert!(&foobar != "barfoo");
    /// ```
    pub const fn empty() -> Self {
        crate::arc!("")
    }

    /// Constructs an [`ArcStr`] and initializes it with the provided string.
    ///
    /// If you want to construct an [`ArcStr`] with a string literal, consider
    /// using the [`arc!()`](crate::arc) macro instead, which can avoid heap
    /// allocation and reference counting overhead.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let foobar = ArcStr::new("foobar");
    ///
    /// assert_eq!(foobar, "foobar");
    /// ```
    pub fn new<S>(data: S) -> Self
    where
        S: AsRef<str>,
    {
        let data = data.as_ref();

        if data.is_empty() {
            return Self::empty();
        }

        #[allow(
            unsafe_code,
            reason = "`data` is valid UTF-8; the given buf is fully initialized."
        )]
        unsafe {
            Self::unchecked_new_with(data.len(), false, |buf| {
                debug_assert!(buf.len() == data.len());
                ptr::copy_nonoverlapping(data.as_ptr().cast(), buf.as_mut_ptr(), data.len());
            })
        }
    }

    /// Constructs an [`ArcStr`] and initializes it with the provided callback.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let foobar = ArcStr::new_with(5, |slice| {
    ///     slice
    ///         .iter_mut()
    ///         .zip(b'0'..b'5')
    ///         .for_each(|(db, sb)| *db = sb);
    /// })
    /// .expect("unexpected: we know this initializer produces valid UTF-8");
    ///
    /// assert_eq!(foobar, "01234");
    /// ```
    ///
    /// # Errors
    ///
    /// The provided `initializer` produced invalid UTF-8 data.
    pub fn new_with<F>(n: usize, initializer: F) -> Result<Self, Utf8Error>
    where
        F: FnOnce(&mut [u8]),
    {
        let mut this = Ok(());

        let initializer = |buf: &mut [MaybeUninit<u8>]| {
            debug_assert!(buf.len() == n);

            #[allow(unsafe_code, reason = "The `buf` is zero-initialized")]
            let slice: &mut [u8] =
                unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr().cast(), buf.len()) };

            initializer(slice);

            if let Err(e) = str::from_utf8(slice) {
                this = Err(e);
            }
        };

        #[allow(unsafe_code, reason = "XXX")]
        let ret = unsafe { ArcInner::try_new_with(n, true, initializer) }
            .map_or_else(handle_alloc_error, Self::from_inner);

        this.map(|()| ret)
    }

    #[allow(
        unsafe_code,
        reason = "The caller must uphold the safety contract of this function."
    )]
    /// The unchecked version of [`ArcStr::new_with`].
    ///
    /// # Safety
    ///
    /// The provided `initializer` callback must initialize the provided
    /// buffer with `n` bytes of valid UTF-8 encoded string bytes.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// use fastring::ArcStr;
    ///
    /// let foobar = unsafe {
    ///     ArcStr::unchecked_new_with(10, false, |s| {
    ///         s.fill(MaybeUninit::new(b'a'));
    ///     })
    /// };
    ///
    /// assert_eq!(foobar, "aaaaaaaaaa");
    /// ```
    pub unsafe fn unchecked_new_with<F>(n: usize, zeroed: bool, initializer: F) -> Self
    where
        F: FnOnce(&mut [MaybeUninit<u8>]),
    {
        #[allow(
            unsafe_code,
            reason = "The caller must uphold the safety contract of this function."
        )]
        unsafe { ArcInner::try_new_with(n, zeroed, initializer) }
            .map_or_else(handle_alloc_error, Self::from_inner)
    }

    #[deprecated(
        since = "0.0.0",
        note = "Saying `len` of a string is confusing in non-ASCII contexts, since it can refer \
                to either the Unicode chars length or the underlying bytes length. Use \
                `len_bytes` or `len_chars` instead to disambiguate so."
    )]
    #[doc(hidden)]
    #[inline(always)]
    pub const fn len(&self) -> usize {
        self.len_bytes()
    }

    #[inline]
    /// Returns the **chars length** of this [`ArcStr`] .
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// assert_eq!(ArcStr::new("foo").len_chars(), 3);
    /// assert_eq!(ArcStr::new("你好").len_chars(), 2);
    /// ```
    pub fn len_chars(&self) -> usize {
        self.as_str().chars().count()
    }

    #[inline]
    /// Returns the length of this [`ArcStr`] in **bytes**.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// assert_eq!(ArcStr::new("foo").len_bytes(), 3);
    /// assert_eq!(ArcStr::new("你好").len_bytes(), 6);
    /// ```
    pub const fn len_bytes(&self) -> usize {
        self.lf().value()
    }

    #[inline]
    /// Returns true if this [`ArcStr`] is empty.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// // Empty is empty:
    /// assert!(ArcStr::empty().is_empty());
    /// // Empty strings are empty:
    /// assert!(ArcStr::new("").is_empty());
    /// // Non-empty strings aren't empty:
    /// assert!(!ArcStr::new("foo").is_empty());
    /// ```
    pub const fn is_empty(&self) -> bool {
        self.len_bytes() == 0
    }

    #[inline]
    /// Extracts a string slice containing the entire [`ArcStr`].
    ///
    /// ## Examples
    ///
    /// ```
    /// use fastring::ArcStr;
    ///
    /// assert_eq!(ArcStr::new("abc").as_str(), "abc");
    /// ```
    pub const fn as_str(&self) -> &str {
        #[allow(unsafe_code, reason = "The data is guaranteed to be valid UTF-8.")]
        unsafe {
            str::from_utf8_unchecked(self.as_bytes())
        }
    }

    /// Extracts a bytes slice containing the entire [`ArcStr`].
    ///
    /// ## Examples
    ///
    /// ```
    /// use fastring::ArcStr;
    ///
    /// assert_eq!(ArcStr::new("foobar").as_bytes(), b"foobar");
    /// ```
    #[inline]
    pub const fn as_bytes(&self) -> &[u8] {
        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            slice::from_raw_parts(self.data(), self.len_bytes())
        }
    }

    /// Consumes the [`ArcStr`], returning the wrapped pointer.
    ///
    /// To avoid a memory leak the pointer must be converted back to an
    /// [`ArcStr`] using [`ArcStr::from_raw`].
    ///
    /// Note that in addition to the `NonNull` constraint expressed in the type
    /// signature, we also guarantee the pointer has an alignment of at least 8
    /// bytes, even on platforms where a lower alignment would be acceptable.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let foobar = ArcStr::new("foobar");
    /// // ...
    /// let foobar_ptr = ArcStr::into_raw(foobar);
    /// // Some time later...
    /// let barfoo = unsafe { ArcStr::from_raw(foobar_ptr) };
    /// // Oh, we get the same string back!
    /// assert_eq!(barfoo, "foobar");
    /// ```
    #[inline]
    pub const fn into_raw(this: Self) -> NonNull<ArcInner> {
        let p = this.inner;

        #[allow(clippy::mem_forget, reason = "XXX")]
        mem::forget(this);

        p
    }

    #[allow(
        unsafe_code,
        reason = "The caller must uphold the safety contract of this function."
    )]
    #[inline]
    /// Constructs an [`ArcStr`] from a raw pointer.
    ///
    /// # Safety
    ///
    /// The raw pointer must have been previously returned by a call to
    /// [`ArcStr::into_raw`]; and the [`ArcStr`] instance can be only dropped
    /// once.
    ///
    /// ## Examples
    ///
    /// See [`ArcStr::into_raw`].
    pub const unsafe fn from_raw(ptr: NonNull<ArcInner>) -> Self {
        Self::from_inner(ptr)
    }

    #[inline]
    /// Returns whether this [`ArcStr`] is a static one.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// # use fastring::{ArcStr, arc};
    /// #
    /// let foobar = arc!("foobar");
    /// assert!(ArcStr::is_static(&foobar));
    /// let barfoo = ArcStr::new("barfoo");
    /// assert!(!ArcStr::is_static(&barfoo));
    /// ```
    pub const fn is_static(this: &Self) -> bool {
        this.lf().flag()
    }

    #[inline]
    /// Returns the reference count of this [`ArcStr`].
    ///
    /// When the [`ArcStr`] is originally static, we return None.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::{ArcStr, arc};
    ///
    /// # {
    /// let foobar = arc!("foobar");
    /// assert_eq!(ArcStr::reference_count(&foobar), None);
    /// # }
    /// # {
    /// let barfoo = ArcStr::new("barfoo");
    /// assert_eq!(ArcStr::reference_count(&barfoo), Some(1));
    /// let barfoor = barfoo.clone();
    /// assert_eq!(ArcStr::reference_count(&barfoo), Some(2));
    /// assert_eq!(ArcStr::reference_count(&barfoor), Some(2));
    /// # }
    /// ```
    pub fn reference_count(this: &Self) -> Option<usize> {
        this.rf().map(|rf| rf.load(Ordering::Acquire).value())
    }

    /// Returns whether the two [`ArcStr`]s point to the same allocation.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::{ArcStr, arc};
    ///
    /// # {
    /// // * Creating static `ArcStr`.
    /// let foobar = arc!("foobar");
    /// // * Cloning `foobar` gives us another pointer to the same allocation
    /// let foobarr = foobar.clone();
    /// assert!(ArcStr::ptr_eq(&foobar, &foobarr));
    /// // * Creating another static `ArcStr` with the same contents.
    /// let barfoo = arc!("foobar");
    /// // * The LLVM backend will merge the two same string literals into the same allocation in some
    /// // * circumstance (e.g., LTO is enabled). However, it's not guaranteed.
    /// // assert!(ArcStr::ptr_eq(&foobar, &barfoo));
    /// # }
    ///
    /// # {
    /// // * Creating non-static `ArcStr`.
    /// let foobar = ArcStr::new("foobar");
    /// // * Cloning `foobar` gives us another pointer to the same allocation:
    /// let foobarr = foobar.clone();
    /// assert!(ArcStr::ptr_eq(&foobar, &foobarr));
    /// // * Creating another `ArcStr` with the same contents.
    /// let barfoo = ArcStr::new("foobar");
    /// // * The two `ArcStr`s are different allocations, so they should not be pointer-equal.
    /// assert!(!ArcStr::ptr_eq(&foobar, &barfoo));
    /// # }
    /// ```
    #[inline]
    pub fn ptr_eq(lhs: &Self, rhs: &Self) -> bool {
        lhs.inner == rhs.inner
    }

    // === Internal APIs ===

    #[inline]
    /// Reads a copy of the field `lf`.
    const fn lf(&self) -> FlaggedUint<usize> {
        ArcInner::lf(self.inner)
    }

    #[inline]
    /// Gets a reference to the field `rf`.
    ///
    /// When the [`ArcStr`] is originally a static one, returns `None`.
    const fn rf(&self) -> Option<&FlaggedUint<AtomicUsize>> {
        if self.lf().flag() {
            None
        } else {
            #[allow(
                unsafe_code,
                reason = "`ArcStr` is not static; the lifetime of the returned reference is bound \
                          to `self`."
            )]
            Some(unsafe { ArcInner::rf(self.inner) })
        }
    }

    #[inline]
    /// Gets a pointer to the start of the string data.
    const fn data(&self) -> *const u8 {
        ArcInner::data(self.inner).cast()
    }
}

impl Default for ArcStr {
    #[inline]
    fn default() -> Self {
        Self::empty()
    }
}

impl fmt::Debug for ArcStr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_str().fmt(f)
    }
}

impl fmt::Display for ArcStr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_str().fmt(f)
    }
}

impl Clone for ArcStr {
    #[inline]
    /// Makes a clone of the [`ArcStr`].
    ///
    /// This creates another pointer to the same allocation, increasing the
    /// strong reference count if the [`ArcStr`] is not a static one.
    ///
    /// ## Examples
    ///
    /// ```
    /// # use fastring::ArcStr;
    /// #
    /// let five = ArcStr::new("five");
    /// let evif = ArcStr::clone(&five);
    /// assert_eq!(five, evif);
    /// ```
    fn clone(&self) -> Self {
        const MAX_REFCOUNT: usize = FlaggedUint::MAX;

        if let Some(rf) = self.rf() {
            // Using a relaxed ordering is alright here, as knowledge of the
            // original reference prevents other threads from erroneously deleting
            // the object.
            //
            // As explained in the [Boost documentation][1], Increasing the
            // reference counter can always be done with memory_order_relaxed: New
            // references to an object can only be formed from an existing
            // reference, and passing an existing reference from one thread to
            // another must already provide any required synchronization.
            //
            // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
            let n = rf.increment(Ordering::Relaxed);

            #[allow(
                clippy::manual_assert,
                reason = "We may change to `abort` in the future; for now we want to panic in \
                          debug mode to alert the programmer of the issue."
            )]
            if !n.flag() && n.value() > MAX_REFCOUNT {
                // When overflow happens, leaving the reference count in an overflowed state is
                // actually not too bad: the `is_static` flag is set and we will leak the
                // allocation instead of trying to destroy it, which is arguably better than
                // accidentally destroying it too early. However, we still want to panic in
                // debug mode to alert the programmer of the issue.
                #[allow(clippy::panic, reason = "XXX")]
                #[cfg(debug_assertions)]
                {
                    panic!("reference count overflow");
                }
            }
        }

        Self::from_inner(self.inner)
    }
}

impl Drop for ArcStr {
    #[inline]
    fn drop(&mut self) {
        if let Some(rf) = self.rf() {
            let rf = rf.decrement(Ordering::Release);

            if rf.value() > 1 {
                return;
            }

            // This fence is needed to prevent reordering of use of the data and
            // deletion of the data. Because it is marked `Release`, the decreasing
            // of the reference count synchronizes with this `Acquire` fence. This
            // means that use of the data happens before decreasing the reference
            // count, which happens before this fence, which happens before the
            // deletion of the data.
            //
            // As explained in the [Boost documentation][1],
            //
            // > It is important to enforce any possible access to the object in one
            // > thread (through an existing reference) to *happen before* deleting
            // > the object in a different thread. This is achieved by a "release"
            // > operation after dropping a reference (any access to the object
            // > through this reference must obviously happened before), and an
            // > "acquire" operation before deleting the object.
            //
            // In particular, while the contents of an Arc are usually immutable, it's
            // possible to have interior writes to something like a Mutex<T>. Since a
            // Mutex is not acquired when it is deleted, we can't rely on its
            // synchronization logic to make writes in thread A visible to a destructor
            // running in thread B.
            //
            // Also note that the Acquire fence here could probably be replaced with an
            // Acquire load, which could improve performance in highly-contended
            // situations. See [2].
            //
            // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
            // [2]: (https://github.com/rust-lang/rust/pull/41714)
            atomic::fence(Ordering::Acquire);

            if !rf.flag() {
                // Not a static `ArcStr`, destroy it.
                #[allow(unsafe_code, reason = "XXX")]
                unsafe {
                    ArcInner::destroy(self.inner);
                }
            }
        }
    }
}

impl AsRef<str> for ArcStr {
    #[inline]
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl ops::Deref for ArcStr {
    type Target = str;

    #[inline]
    fn deref(&self) -> &Self::Target {
        self.as_str()
    }
}

impl Borrow<str> for ArcStr {
    #[inline]
    fn borrow(&self) -> &str {
        self.as_str()
    }
}

impl str::FromStr for ArcStr {
    type Err = Infallible;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Self::new(s))
    }
}

macro_rules! impl_from {
    ($ty:ty) => {
        impl From<$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn from(data: $ty) -> Self {
                Self::new(&data[..])
            }
        }

        impl From<&$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn from(data: &$ty) -> Self {
                Self::new(&data[..])
            }
        }
    };
}

impl_from!(&str);
impl_from!(alloc::borrow::Cow<'_, str>);
impl_from!(alloc::boxed::Box<str>);
impl_from!(alloc::boxed::Box<alloc::string::String>);
impl_from!(alloc::string::String);
impl_from!(alloc::rc::Rc<str>);
impl_from!(alloc::rc::Rc<alloc::string::String>);
impl_from!(alloc::sync::Arc<str>);
impl_from!(alloc::sync::Arc<alloc::string::String>);

impl PartialEq for ArcStr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ArcStr::ptr_eq(self, other) || self.as_str() == other.as_str()
    }
}

impl Eq for ArcStr {}

impl Hash for ArcStr {
    #[inline]
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.as_str().hash(state);
    }
}

impl PartialOrd for ArcStr {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for ArcStr {
    #[inline]
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        Ord::cmp(self.as_str(), other.as_str())
    }
}

macro_rules! impl_partial_eq_partial_ord_ord {
    ($ty:ty) => {
        impl PartialEq<$ty> for &ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn eq(&self, other: &$ty) -> bool {
                self.as_str() == &other[..]
            }
        }

        impl PartialEq<$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn eq(&self, other: &$ty) -> bool {
                self.as_str() == &other[..]
            }
        }

        impl PartialEq<&$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn eq(&self, other: &&$ty) -> bool {
                self.as_str() == &other[..]
            }
        }

        impl PartialEq<&&$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn eq(&self, other: &&&$ty) -> bool {
                self.as_str() == &other[..]
            }
        }

        impl PartialOrd<$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn partial_cmp(&self, other: &$ty) -> Option<core::cmp::Ordering> {
                PartialOrd::partial_cmp(self.as_str(), &other[..])
            }
        }

        impl PartialOrd<&$ty> for ArcStr {
            #[inline]
            #[allow(clippy::string_slice, reason = "XXX")]
            fn partial_cmp(&self, other: &&$ty) -> Option<core::cmp::Ordering> {
                PartialOrd::partial_cmp(self.as_str(), &other[..])
            }
        }
    };
}

impl_partial_eq_partial_ord_ord!(str);
impl_partial_eq_partial_ord_ord!(alloc::borrow::Cow<'_, str>);
impl_partial_eq_partial_ord_ord!(alloc::boxed::Box<str>);
impl_partial_eq_partial_ord_ord!(alloc::boxed::Box<alloc::string::String>);
impl_partial_eq_partial_ord_ord!(alloc::string::String);
impl_partial_eq_partial_ord_ord!(alloc::rc::Rc<str>);
impl_partial_eq_partial_ord_ord!(alloc::rc::Rc<alloc::string::String>);
impl_partial_eq_partial_ord_ord!(alloc::sync::Arc<str>);
impl_partial_eq_partial_ord_ord!(alloc::sync::Arc<alloc::string::String>);

impl ops::Index<ops::RangeFull> for ArcStr {
    type Output = str;

    #[inline]
    fn index(&self, _: ops::RangeFull) -> &Self::Output {
        self.as_str()
    }
}

impl ops::Index<ops::Range<usize>> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified range of chars in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The range indices here are in terms of chars, not bytes! This is
    /// different from the standard behavior of string slicing in Rust, but it
    /// is more intuitive in non-ASCII contexts. If you want to slice by
    /// byte indices, you can use `as_str()` to get a `&str` and then
    /// slice that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    /// # assert_eq!(&s[0..0], "");
    /// # assert_eq!(&s[0..1], "H");
    /// assert_eq!(&s[0..5], "Hello");
    /// assert_eq!(&s[7..9], "世界");
    /// # assert_eq!(&s[7..10], "世界!");
    /// ```
    fn index(&self, range: ops::Range<usize>) -> &Self::Output {
        assert!(
            range.start <= range.end,
            "invalid range: start index must not be greater than end index"
        );

        let this = self.as_str();

        let mut iter = this.chars();

        let mut bs = 0;

        {
            let mut cs = 0;

            while cs < range.start {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the start index is out of bounds");
                    }
                };

                bs += c.len_utf8();
                cs += 1;
            }
        }

        if range.start == range.end {
            return "";
        }

        let mut be = bs;

        {
            let mut ce = range.start;

            while ce < range.end {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the end index is out of bounds");
                    }
                };

                be += c.len_utf8();
                ce += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(bs..be)
        }
    }
}

impl ops::Index<ops::RangeFrom<usize>> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified range of chars in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The range indices here are in terms of chars, not bytes! This is
    /// different from the standard behavior of string slicing in Rust, but it
    /// is more intuitive in non-ASCII contexts. If you want to slice by
    /// byte indices, you can use `as_str()` to get a `&str` and then
    /// slice that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    ///
    /// # assert_eq!(&s[0..], "Hello, 世界!");
    /// # assert_eq!(&s[1..], "ello, 世界!");
    /// assert_eq!(&s[7..], "世界!");
    /// assert_eq!(&s[8..], "界!");
    /// # assert_eq!(&s[9..], "!");
    /// ```
    fn index(&self, range: ops::RangeFrom<usize>) -> &Self::Output {
        let this = self.as_str();

        let mut iter = this.chars();

        let mut bs = 0;

        {
            let mut cs = 0;

            while cs < range.start {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the start index is out of bounds");
                    }
                };

                bs += c.len_utf8();
                cs += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(bs..)
        }
    }
}

impl ops::Index<ops::RangeTo<usize>> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified range of chars in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The range indices here are in terms of chars, not bytes! This is
    /// different from the standard behavior of string slicing in Rust, but it
    /// is more intuitive in non-ASCII contexts. If you want to slice by
    /// byte indices, you can use `as_str()` to get a `&str` and then
    /// slice that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    ///
    /// # assert_eq!(&s[..0], "");
    /// # assert_eq!(&s[..1], "H");
    /// assert_eq!(&s[..5], "Hello");
    /// # assert_eq!(&s[..7], "Hello, ");
    /// assert_eq!(&s[..8], "Hello, 世");
    /// assert_eq!(&s[..9], "Hello, 世界");
    /// # assert_eq!(&s[..10], "Hello, 世界!");
    /// ```
    fn index(&self, range: ops::RangeTo<usize>) -> &Self::Output {
        if range.end == 0 {
            return "";
        }

        let this = self.as_str();

        let mut iter = this.chars();

        let mut be = 0;

        {
            let mut ce = 0;

            while ce < range.end {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the end index is out of bounds");
                    }
                };

                be += c.len_utf8();
                ce += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(..be)
        }
    }
}

impl ops::Index<ops::RangeInclusive<usize>> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified range of chars in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The range indices here are in terms of chars, not bytes! This is
    /// different from the standard behavior of string slicing in Rust, but it
    /// is more intuitive in non-ASCII contexts. If you want to slice by
    /// byte indices, you can use `as_str()` to get a `&str` and then
    /// slice that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    ///
    /// # assert_eq!(&s[0..=0], "H");
    /// assert_eq!(&s[0..=4], "Hello");
    /// assert_eq!(&s[7..=8], "世界");
    /// # assert_eq!(&s[7..=9], "世界!");
    /// ```
    fn index(&self, range: ops::RangeInclusive<usize>) -> &Self::Output {
        assert!(
            range.start() <= range.end(),
            "invalid range: the start index is greater than the end index"
        );

        let this = self.as_str();

        let mut iter = this.chars();

        let mut bs = 0;

        {
            let mut cs = 0;

            while cs < *range.start() {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the start index is out of bounds");
                    }
                };

                bs += c.len_utf8();
                cs += 1;
            }
        }

        let mut be = bs;

        {
            let mut ce = *range.start();

            while ce <= *range.end() {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the end index is out of bounds");
                    }
                };

                be += c.len_utf8();
                ce += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(bs..be)
        }
    }
}

impl ops::Index<ops::RangeToInclusive<usize>> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified range of chars in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The range indices here are in terms of chars, not bytes! This is
    /// different from the standard behavior of string slicing in Rust, but it
    /// is more intuitive in non-ASCII contexts. If you want to slice by
    /// byte indices, you can use `as_str()` to get a `&str` and then
    /// slice that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    ///
    /// # assert_eq!(&s[..=0], "H");
    /// assert_eq!(&s[..=4], "Hello");
    /// assert_eq!(&s[..=6], "Hello, ");
    /// assert_eq!(&s[..=7], "Hello, 世");
    /// assert_eq!(&s[..=8], "Hello, 世界");
    /// # assert_eq!(&s[..=9], "Hello, 世界!");
    /// ```
    fn index(&self, range: ops::RangeToInclusive<usize>) -> &Self::Output {
        let this = self.as_str();

        let mut iter = this.chars();

        let mut be = 0;

        {
            let mut ce = 0;

            while ce <= range.end {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid range: the end index is out of bounds");
                    }
                };

                be += c.len_utf8();
                ce += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(..be)
        }
    }
}

impl ops::Index<usize> for ArcStr {
    type Output = str;

    #[inline]
    /// Returns a string slice containing the specified char in this
    /// [`ArcStr`].
    ///
    /// ## Notes
    ///
    /// The index here is in terms of chars, not bytes! This is different from
    /// the standard behavior of string indexing in Rust, but it is more
    /// intuitive in non-ASCII contexts. If you want to index by byte indices,
    /// you can use `as_str()` to get a `&str` and then index that.
    ///
    /// ## Examples
    ///
    /// ```rust
    /// use fastring::ArcStr;
    ///
    /// let s = ArcStr::new("Hello, 世界!");
    ///
    /// assert_eq!(&s[0], "H");
    /// assert_eq!(&s[1], "e");
    /// assert_eq!(&s[2], "l");
    /// assert_eq!(&s[3], "l");
    /// assert_eq!(&s[4], "o");
    /// assert_eq!(&s[5], ",");
    /// assert_eq!(&s[6], " ");
    /// assert_eq!(&s[7], "世");
    /// assert_eq!(&s[8], "界");
    /// assert_eq!(&s[9], "!");
    /// ```
    fn index(&self, index: usize) -> &Self::Output {
        let this = self.as_str();

        let mut iter = this.chars();

        let mut bs = 0;
        let mut be = iter
            .next()
            .expect("invalid index: indexing into empty string")
            .len_utf8();

        {
            let mut ce = 1;

            while ce <= index {
                let Some(c) = iter.next() else {
                    #[allow(clippy::panic, reason = "XXX")]
                    {
                        panic!("invalid index: the index is out of bounds");
                    }
                };

                bs = be;
                be += c.len_utf8();
                ce += 1;
            }
        }

        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            this.get_unchecked(bs..be)
        }
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for ArcStr {
    #[inline]
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        self.as_str().serialize(serializer)
    }
}

#[cfg(feature = "serde")]
#[allow(clippy::elidable_lifetime_names, reason = "XXX")]
impl<'de> serde::Deserialize<'de> for ArcStr {
    #[inline]
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        // Visitor for string
        struct ArcStrVisitor;

        impl<'de> serde::de::Visitor<'de> for ArcStrVisitor {
            type Value = ArcStr;

            #[inline]
            fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
                Ok(ArcStr::new(v))
            }

            #[inline]
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("string")
            }
        }

        deserializer.deserialize_str(ArcStrVisitor)
    }
}

#[allow(missing_debug_implementations, reason = "XXX")]
#[doc(hidden)]
#[repr(C, align(8))]
/// Caveat on the `static`/`strong` fields: "is_static" indicates if we're
/// located in static data (as with empty string). is_static being false meanse
/// we are a normal arc-ed string.
///
///
/// We do this by keeping a flag in `len_flag` flag to indicate which case we're
/// in, and maintaining the invariant that if we're a `StaticArcStrInner` **we
/// may never access `.strong` in any way or produce a `&ThinInner` pointing to
/// our data**.
///
/// This is more subtle than you might think, sinc AFAIK we're not legally
/// allowed to create an `&ThinInner` until we're 100% sure it's nonstatic, and
/// prior to determining it, we are forced to work from entirely behind a raw
/// pointer...
///
/// That said, a bit of this hoop jumping might be not required in the future,
/// but for now what we're doing works and is apparently sound:
/// https://github.com/rust-lang/unsafe-code-guidelines/issues/246
pub struct ArcInner<RF = AtomicUsize, const N: usize = 0> {
    /// The length of the data.
    ///
    /// The flag bit is used to indicate if the data is *static*.
    lf: FlaggedUint<usize>,

    /// The (atomic) reference count.
    ///
    /// The flag bit is used to indicate if the data is *static*, including the
    /// circumstance that we have leaked the allocation.
    ///
    /// ## Caveat
    ///
    /// While `ArcStr` claims to hold a pointer to a `ThinInner`, for the
    /// static case we actually are using a pointer to a
    /// `StaticArcStrInner<[u8; N]>`. These have almost identical layouts,
    /// except the static contains a explicit trailing array, and does not
    /// have a `AtomicUsize` The issue is: We kind of want the static ones
    /// to not have any interior mutability, so that `const`s can use them,
    /// and so that they may be stored in read-only memory.
    ///
    /// When `lf.flag` is true, this field is not actually a valid
    /// [`AtomicUsize`]: doing atomic reading against read-only memory is
    /// technically undefined behavior (UB).
    rf: FlaggedUint<RF>,

    /// The string data.
    ///
    /// - In the static case, this is actually a trailing array.
    /// - In the heap-allocated case, this is just the start of the data, and
    ///   the actual length is stored in `lf`.
    data: [u8; N],
}

impl<RF, const N: usize> ArcInner<RF, N> {
    #[inline(always)]
    /// Reads a copy of the field `lf`.
    const fn lf(this: NonNull<Self>) -> FlaggedUint<usize> {
        #[allow(unsafe_code, reason = "`this` is non-null; field `lf` is initialized.")]
        unsafe {
            (*this.as_ptr()).lf
        }
    }

    #[inline(always)]
    /// Gets a pointer to the start of the string data.
    const fn data(this: NonNull<Self>) -> *const MaybeUninit<u8> {
        #[allow(unsafe_code, reason = "XXX")]
        unsafe {
            (&raw const (*this.as_ptr()).data).cast()
        }
    }
}

impl<const N: usize> ArcInner<AtomicUsize, N> {
    #[allow(unsafe_code, reason = "See below.")]
    #[inline(always)]
    /// Gets a reference to the field `rf`.
    ///
    /// Safety:
    ///
    /// The caller must ensure that:
    ///
    /// - the returned reference's lifetime does not outlive the [`ArcInner`]
    ///   instance;
    /// - the [`ArcInner`] instance is not a static one.
    const unsafe fn rf<'a>(this: NonNull<Self>) -> &'a FlaggedUint<AtomicUsize> {
        #[allow(unsafe_code, reason = "`this` is non-null; field `rf` is initialized.")]
        unsafe {
            &(*this.as_ptr()).rf
        }
    }
}

impl<const N: usize> ArcInner<usize, N> {
    #[doc(hidden)]
    /// Not a public API. Use [`arc!()`](crate::arc) instead.
    pub const fn constified(data: [u8; N]) -> Self {
        Self {
            lf: FlaggedUint::<usize>::unchecked_new(true, N),
            rf: FlaggedUint::<usize>::unchecked_new(true, 1),
            data,
        }
    }
}

impl ArcInner {
    #[allow(
        unsafe_code,
        reason = "The caller must ensure that the given `initializer` will write `len` bytes of \
                  valid UTF-8 encoded string into the provided buffer"
    )]
    #[inline]
    unsafe fn try_new_with<F>(
        len: usize,
        zeroed: bool,
        initializer: F,
    ) -> Result<NonNull<Self>, Option<Layout>>
    where
        F: FnOnce(&mut [MaybeUninit<u8>]),
    {
        #[allow(unsafe_code, reason = "XXX")]
        let this = unsafe { Self::try_allocate(len, zeroed) }?;

        #[allow(unsafe_code, reason = "XXX")]
        initializer(unsafe {
            slice::from_raw_parts_mut(
                this.as_ptr()
                    .cast::<MaybeUninit<u8>>()
                    .add(offset_of!(Self, data)),
                len,
            )
        });

        Ok(this)
    }

    #[allow(unsafe_code, reason = "XXX")]
    /// Allocates memory for an [`ArcInner`] with exact `capacity` reserved for
    /// string data.
    ///
    /// The field `lf` is set to `capacity`, while the field `rf` is set to 1.
    /// Both flags are set to false.
    ///
    /// # Safety
    ///
    /// The caller must ensure that all reserved capacity is properly
    /// initialized before the `ArcInner` is used in any way.
    unsafe fn try_allocate(capacity: usize, zeroed: bool) -> Result<NonNull<Self>, Option<Layout>> {
        let Ok(layout) =
            Layout::from_size_align(offset_of!(Self, data) + capacity, align_of::<Self>())
        else {
            return Err(None);
        };

        #[allow(
            unsafe_code,
            reason = "Allocating memory according to the given layout"
        )]
        let ptr = unsafe {
            if zeroed {
                alloc::alloc::alloc_zeroed(layout)
            } else {
                alloc::alloc::alloc(layout)
            }
        };

        #[allow(clippy::cast_ptr_alignment, reason = "XXX")]
        let Some(ptr) = NonNull::new(ptr.cast::<Self>()) else {
            return Err(Some(layout));
        };

        #[allow(unsafe_code, reason = "Initializing fields `lf` / `rf`")]
        unsafe {
            (&raw mut ((*ptr.as_ptr()).lf))
                .write(FlaggedUint::<usize>::unchecked_new(false, capacity));
            (&raw mut ((*ptr.as_ptr()).rf))
                .write(FlaggedUint::<AtomicUsize>::unchecked_new(false, 1));
        };

        Ok(ptr)
    }

    #[allow(unsafe_code, reason = "XXX")]
    #[inline(never)]
    /// Destroys the allocated `ArcInner`.
    unsafe fn destroy(this: NonNull<Self>) {
        let lf = Self::lf(this);

        debug_assert!(
            !lf.flag(),
            "implementation bug: cannot destroy static `ArcInner`"
        );

        #[allow(
            unsafe_code,
            reason = "Deallocating memory according to how it was allocated"
        )]
        unsafe {
            alloc::alloc::dealloc(
                this.as_ptr().cast(),
                Layout::from_size_align_unchecked(
                    offset_of!(Self, data) + lf.value(),
                    align_of::<Self>(),
                ),
            );
        };
    }
}

#[repr(transparent)]
#[derive(Clone, Copy)]
/// A `usize` whose MSB is used as a flag.
struct FlaggedUint<V = usize> {
    value: V,
}

impl FlaggedUint {
    /// The maximum value of the uint part.
    const MAX: usize = Self::MSB - 1;
    /// The flag bit, which is the MSB of the `usize`.
    const MSB: usize = 1 << (usize::BITS - 1);

    // #[inline(always)]
    // const fn new(flag: bool, value: usize) -> Option<Self> {
    //     if value <= Self::MAX {
    //         Some(Self::unchecked_new(flag, value))
    //     } else {
    //         None
    //     }
    // }

    #[inline(always)]
    /// Creates a new [`Flagged`] without checking if `value` is within
    /// bounds.
    const fn unchecked_new(flag: bool, value: usize) -> Self {
        debug_assert!(value <= Self::MAX);

        Self { value }.flagged(flag)
    }

    #[inline(always)]
    const fn value(self) -> usize {
        self.value & Self::MAX
    }

    #[inline(always)]
    const fn flag(self) -> bool {
        (self.value & Self::MSB) != 0
    }

    #[inline(always)]
    const fn flagged(mut self, flag: bool) -> Self {
        if flag {
            self.value |= Self::MSB;
        } else {
            self.value &= !Self::MSB;
        }

        self
    }
}

impl FlaggedUint<AtomicUsize> {
    // #[inline(always)]
    // const fn new(flag: bool, value: usize) -> Option<Self> {
    //     if value <= Flagged::MAX {
    //         Some(Self::unchecked_new(flag, value))
    //     } else {
    //         None
    //     }
    // }

    #[inline(always)]
    /// Creates a new [`Flagged`] without checking if `value` is within
    /// bounds.
    const fn unchecked_new(flag: bool, value: usize) -> Self {
        debug_assert!(value <= FlaggedUint::MAX);

        Self {
            value: AtomicUsize::new(FlaggedUint::<usize>::unchecked_new(flag, value).value),
        }
    }

    #[inline(always)]
    /// Reads a snapshot.
    fn load(&self, order: Ordering) -> FlaggedUint<usize> {
        FlaggedUint::<usize> {
            value: self.value.load(order),
        }
    }

    // #[inline(always)]
    // /// Stores a new value.
    // fn store(&self, val: Flagged, order: Ordering) {
    //     self.value.store(val.value, order);
    // }

    #[inline(always)]
    /// Increments the value by 1, returning the previous value.
    fn increment(&self, order: Ordering) -> FlaggedUint {
        FlaggedUint {
            value: self.value.fetch_add(1, order),
        }
    }

    #[inline(always)]
    /// Decrements the value by 1, returning the previous value.
    fn decrement(&self, order: Ordering) -> FlaggedUint {
        FlaggedUint {
            value: self.value.fetch_sub(1, order),
        }
    }
}

#[cold]
#[inline(never)]
fn handle_alloc_error<T>(layout: Option<Layout>) -> T {
    match layout {
        Some(layout) => alloc::alloc::handle_alloc_error(layout),
        None => {
            #[allow(clippy::panic, reason = "XXX")]
            {
                // TODO: panic or abort?
                panic!("unlikely: capacity overflow");
            }
        }
    }
}

#[doc(hidden)]
/// For sanity check.
pub const fn arc_inner_layout_check<const N: usize>() {
    assert!(align_of::<ArcInner<AtomicUsize, N>>() == align_of::<ArcInner>());
    assert!(align_of::<ArcInner>() >= 8);

    assert!(offset_of!(ArcInner<AtomicUsize, N>, lf) == offset_of!(ArcInner, lf),);
    assert!(offset_of!(ArcInner<AtomicUsize, N>, rf) == offset_of!(ArcInner, rf),);
    assert!(offset_of!(ArcInner<AtomicUsize, N>, data) == offset_of!(ArcInner, data),);
}

#[cfg(all(test, not(loom)))]
mod tests {
    use alloc::borrow::Cow;
    use alloc::boxed::Box;
    use alloc::rc::Rc;
    use alloc::string::String;
    use alloc::sync::Arc;
    use alloc::vec::Vec;
    use alloc::{format, vec};
    use std::collections::{BTreeMap, HashMap};

    use super::{ArcStr, arc_inner_layout_check};

    const _: () = {
        arc_inner_layout_check::<0>();
        arc_inner_layout_check::<1>();
        arc_inner_layout_check::<2>();
        arc_inner_layout_check::<3>();
        arc_inner_layout_check::<4>();
        arc_inner_layout_check::<5>();
        arc_inner_layout_check::<6>();
        arc_inner_layout_check::<7>();
        arc_inner_layout_check::<8>();
        arc_inner_layout_check::<15>();
        arc_inner_layout_check::<16>();
        arc_inner_layout_check::<31>();
        arc_inner_layout_check::<32>();
        arc_inner_layout_check::<63>();
        arc_inner_layout_check::<64>();
        arc_inner_layout_check::<128>();
        arc_inner_layout_check::<1024>();
        arc_inner_layout_check::<4095>();
        arc_inner_layout_check::<4096>();
    };

    #[test]
    fn test_loose_ends() {
        assert_eq!(ArcStr::default(), "");
        assert_eq!("abc".parse::<ArcStr>().unwrap(), "abc");

        let abc_arc = ArcStr::from("abc");
        let abc_str: &str = abc_arc.as_ref();
        let abc_bytes: &[u8] = abc_arc.as_bytes();

        assert_eq!(abc_str, "abc");
        assert_eq!(abc_bytes, b"abc");
    }

    #[allow(unsafe_code, reason = "XXX")]
    #[test]
    fn test_from_into_raw() {
        let foo = vec![
            ArcStr::default(),
            ArcStr::new("1234"),
            ArcStr::new(format!("test {}", 1)),
        ]
        .into_iter()
        .cycle()
        .take(100)
        .collect::<Vec<ArcStr>>();

        let bar = foo
            .iter()
            .map(|s| ArcStr::into_raw(s.clone()))
            .collect::<Vec<_>>();

        drop(foo);

        let barfoo = bar
            .iter()
            .map(|s| unsafe { ArcStr::from_raw(*s) })
            .collect::<Vec<_>>();

        let foobar = [
            ArcStr::default(),
            ArcStr::from("1234"),
            ArcStr::from(format!("test {}", 1)),
        ]
        .iter()
        .cloned()
        .cycle()
        .take(100)
        .collect::<Vec<_>>();

        assert_eq!(barfoo, foobar);

        drop(barfoo);
    }

    #[test]
    fn test_static_include_str() {
        const APACHE: ArcStr = arc!(include_str!("../LICENSE-APACHE"));
        assert!(APACHE.len_bytes() > 10000);
        assert!(APACHE.trim_start().starts_with("Apache License"));
        assert!(
            APACHE
                .trim_end()
                .ends_with("limitations under the License.")
        );
    }

    #[test]
    fn test_inherent_overrides() {
        let s = ArcStr::from("abc");
        assert_eq!(s.as_str(), "abc");

        let a = ArcStr::from("foo");
        assert_eq!(a.len_chars(), 3);
        assert_eq!(a.len_bytes(), 3);

        assert!(!ArcStr::from("foo").is_empty());
        assert!(ArcStr::empty().is_empty());
    }

    #[test]
    fn test_clone() {
        let count = if cfg!(miri) { 64 } else { 256 };

        for count in 0..count {
            {
                let string = ArcStr::new("");
                drop(vec![string; count]);
            }

            {
                let string = ArcStr::new("foobar");
                drop(vec![string; count]);
            }

            {
                let literal = arc!("");
                drop(vec![literal; count]);
            }

            {
                let literal = arc!("foobar");
                drop(vec![literal; count]);
            }
        }

        drop(vec![ArcStr::empty(); count]);
    }

    #[test]
    fn test_fmt() {
        macro_rules! test {
            ($text:expr) => {
                assert_eq!(format!("{}", arc!($text)), $text);
                assert_eq!(format!("{}", ArcStr::new($text)), $text);
            };
        }

        test!("");
        test!("foobar");
        test!("Hello, 世界");
    }

    #[test]
    fn test_from() {
        macro_rules! test {
            ($expected:expr) => {
                assert_eq!(ArcStr::from(Cow::from($expected)), $expected);
                assert_eq!(ArcStr::from(Box::<str>::from($expected)), $expected);
                assert_eq!(ArcStr::from(String::from($expected)), $expected);
                assert_eq!(ArcStr::from(Rc::<str>::from($expected)), $expected);
                assert_eq!(ArcStr::from(Arc::<str>::from($expected)), $expected);
            };
        }

        test!("");
        test!("foobar");
    }

    #[test]
    fn test_ord() {
        let mut arr = [ArcStr::new("foo"), ArcStr::new("bar"), ArcStr::new("baz")];

        // Sort the array in-place.
        arr.sort();

        assert_eq!(
            &arr,
            &[ArcStr::new("bar"), ArcStr::new("baz"), ArcStr::new("foo")]
        );
    }

    #[test]
    fn test_partial_eq() {
        macro_rules! test {
            ($this:expr, $expected:expr) => {
                assert_eq!($this, $expected);
                assert_eq!(&$this, $expected);
                assert_eq!($this, &$expected);
                assert_eq!(&$this, &$expected);

                assert_eq!($this, Cow::from($expected));
                assert_eq!(&$this, Cow::from($expected));
                assert_eq!($this, &Cow::from($expected));
                assert_eq!(&$this, &Cow::from($expected));

                assert_eq!($this, Box::<str>::from($expected));
                assert_eq!(&$this, Box::<str>::from($expected));
                assert_eq!($this, &Box::<str>::from($expected));
                assert_eq!(&$this, &Box::<str>::from($expected));

                assert_eq!($this, String::from($expected));
                assert_eq!(&$this, String::from($expected));
                assert_eq!($this, &String::from($expected));
                assert_eq!(&$this, &String::from($expected));

                assert_eq!($this, Rc::<str>::from($expected));
                assert_eq!(&$this, Rc::<str>::from($expected));
                assert_eq!($this, &Rc::<str>::from($expected));
                assert_eq!(&$this, &Rc::<str>::from($expected));

                assert_eq!($this, Arc::<str>::from($expected));
                assert_eq!(&$this, Arc::<str>::from($expected));
                assert_eq!($this, &Arc::<str>::from($expected));
                assert_eq!(&$this, &Arc::<str>::from($expected));
            };
        }

        let this = ArcStr::new("");
        test!(this, "");

        let this = ArcStr::new("foobar");
        test!(this, "foobar");

        let this = arc!("");
        test!(this, "");

        let this = arc!("foobar");
        test!(this, "foobar");
    }

    #[test]
    fn test_hash_map() {
        let mut m = HashMap::new();
        for i in 0..100 {
            let prev = m.insert(ArcStr::new(format!("key {i}")), i);
            assert_eq!(prev, None);
        }
        for i in 0..100 {
            let key = format!("key {i}");
            let search = key.as_str();
            assert_eq!(m[search], i);
            assert_eq!(m.remove(search), Some(i));
        }
    }

    #[test]
    fn test_btree_map() {
        let mut m = BTreeMap::new();

        for i in 0..100 {
            let prev = m.insert(ArcStr::new(format!("key {i}")), i);
            assert_eq!(prev, None);
        }

        for i in 0..100 {
            let s = format!("key {i}");
            assert_eq!(m.remove(s.as_str()), Some(i));
        }
    }

    #[cfg(feature = "serde")]
    #[test]
    fn test_serde() {
        use serde_test::{Token, assert_de_tokens, assert_tokens};

        let teststr = ArcStr::from("test test 123 456");

        assert_tokens(&teststr, &[Token::BorrowedStr("test test 123 456")]);
        assert_tokens(&teststr.clone(), &[Token::BorrowedStr("test test 123 456")]);
        assert_tokens(&ArcStr::default(), &[Token::BorrowedStr("")]);

        let checks = &[
            [Token::Str("123")],
            [Token::BorrowedStr("123")],
            [Token::String("123")],
        ];
        for check in checks {
            assert_de_tokens(&ArcStr::from("123"), check);
        }
    }
}

#[cfg(all(test, loom))]
mod loomtest {
    use loom::sync::Arc;
    use loom::thread;

    use super::ArcStr;

    #[test]
    fn cloning_threads() {
        loom::model(|| {
            let a = ArcStr::new("abcdefgh");
            let addr = a.as_ptr() as usize;

            let a1 = Arc::new(a);
            let a2 = Arc::clone(&a1);

            let t1 = thread::spawn(move || {
                let b: ArcStr = (*a1).clone();
                assert_eq!(b.as_ptr() as usize, addr);
            });
            let t2 = thread::spawn(move || {
                let b: ArcStr = (*a2).clone();
                assert_eq!(b.as_ptr() as usize, addr);
            });

            t1.join().unwrap();
            t2.join().unwrap();
        });
    }

    #[test]
    fn drop_timing() {
        loom::model(|| {
            let a1 = alloc::vec![
                ArcStr::from("s1"),
                ArcStr::from("s2"),
                ArcStr::from("s3"),
                ArcStr::from("s4"),
            ];
            let a2 = a1.clone();

            let t1 = thread::spawn(move || {
                let mut a1 = a1;
                while let Some(s) = a1.pop() {
                    assert!(s.starts_with("s"));
                }
            });
            let t2 = thread::spawn(move || {
                let mut a2 = a2;
                while let Some(s) = a2.pop() {
                    assert!(s.starts_with("s"));
                }
            });

            t1.join().unwrap();
            t2.join().unwrap();
        });
    }

    // #[test]
    // fn leak_drop() {
    //     loom::model(|| {
    //         let a1 = ArcStr::from("foo");
    //         let a2 = a1.clone();

    //         let t1 = thread::spawn(move || {
    //             drop(a1);
    //         });
    //         let t2 = thread::spawn(move || a2.leak());
    //         t1.join().unwrap();
    //         let leaked: &'static str = t2.join().unwrap();
    //         assert_eq!(leaked, "foo");
    //     });
    // }
}