ive been listening to 1989 on loop while writing this code and holy hell it's the only thing keeping my sanity up

Author: nia-e

library/core/src/alloc/mod.rs

@@ -184,6 +184,11 @@ pub const unsafe trait Allocator {
     /// * `ptr` must denote a block of memory [*currently allocated*] via this allocator, and
     /// * `layout` must [*fit*] that block of memory.
     ///
+    /// Note that it is UB for a deallocation or reallocation to invalidate any
+    /// outstanding references, `Rc<_>`s, etc.; thus, notably, an allocator that has
+    /// been moved into its own [*currently allocated*] memory must not be invalidated
+    /// by a call to this method, as it would invalidate the `&self` reference used.
+    ///
     /// [*currently allocated*]: #currently-allocated-memory
     /// [*fit*]: #memory-fitting
     #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
@@ -387,8 +392,8 @@ pub const unsafe trait Allocator {
 /// Marks a type's [`Clone`] implementation as sound with regard to [`Allocator`].
 /// Implementors must ensure that, upon cloning, the two allocators are interchangeable
 /// (i.e. is is possible to free memory with one that was allocated with the other).
-/// Further, accesses such as moving or dropping the allocator must not invalidate
-/// its pointed-to memory at least so long as clones exist.
+/// Further, mutable accesses such as moving or dropping the allocator must not invalidate
+/// its currently allocated blocks at least so long as clones exist.
 #[unstable(feature = "allocator_ext", issue = "32838", implied_by = "allocator_api")]
 pub unsafe trait AllocatorClone: Allocator + Clone {}
 
@@ -398,7 +403,11 @@ pub unsafe trait AllocatorClone: Allocator + Clone {}
 /// that the two allocators behave "as if" they are clones of each other as per
 /// [`AllocatorClone`].
 #[unstable(feature = "allocator_ext", issue = "32838", implied_by = "allocator_api")]
-pub unsafe trait AllocatorEq<T: ?Sized = Self>: Allocator + PartialEq<T> {}
+pub unsafe trait AllocatorEq<T = Self>: Allocator + PartialEq<T>
+where
+    T: ?Sized + AllocatorEq<Self>,
+{
+}
 
 /// Marks that an allocator will not break [`Pin`] guarantees, even if subtyped with a
 /// shorter lifetime. This trivially applies to allocators that always maintain