From 768ddf1ae6703cc1f5f57a9c036efe1a231b0a1d Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 7 Jul 2024 23:39:52 +0300
Subject: [PATCH] sparkle some #[inline]

---
 src/arc.rs       | 25 +++++++++++++++++++++++++
 src/arena.rs     | 30 +++++++++++++++++++++++++++---
 src/boxedset.rs  |  6 ++++++
 src/intern.rs    | 27 ++++++++++++++++++++++++---
 src/typearena.rs | 26 +++++++++++++++++++++++---
 5 files changed, 105 insertions(+), 9 deletions(-)

diff --git a/src/arc.rs b/src/arc.rs
index 0e92b3b..25b40b0 100644
--- a/src/arc.rs
+++ b/src/arc.rs
@@ -49,6 +49,7 @@ pub struct ArcIntern<T: ?Sized + Eq + Hash + Send + Sync + 'static> {
 
 #[cfg(feature = "deepsize")]
 impl<T: ?Sized + Eq + Hash + Send + Sync + 'static> deepsize::DeepSizeOf for ArcIntern<T> {
+    #[inline(always)]
     fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
         0
     }
@@ -80,11 +81,13 @@ pub(crate) struct RefCount<T: ?Sized> {
 
 impl<T: ?Sized + Eq> Eq for RefCount<T> {}
 impl<T: ?Sized + PartialEq> PartialEq for RefCount<T> {
+    #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.data == other.data
     }
 }
 impl<T: ?Sized + Hash> Hash for RefCount<T> {
+    #[inline]
     fn hash<H: Hasher>(&self, hasher: &mut H) {
         self.data.hash(hasher)
     }
@@ -93,28 +96,33 @@ impl<T: ?Sized + Hash> Hash for RefCount<T> {
 #[derive(Eq, PartialEq)]
 pub(crate) struct BoxRefCount<T: ?Sized>(pub Box<RefCount<T>>);
 impl<T: ?Sized + Hash> Hash for BoxRefCount<T> {
+    #[inline]
     fn hash<H: Hasher>(&self, hasher: &mut H) {
         self.0.data.hash(hasher)
     }
 }
 
 impl<T> BoxRefCount<T> {
+    #[inline(always)]
     fn into_inner(self) -> T {
         self.0.data
     }
 }
 
 impl<T: ?Sized> Borrow<T> for BoxRefCount<T> {
+    #[inline(always)]
     fn borrow(&self) -> &T {
         &self.0.data
     }
 }
 impl<T: ?Sized> Borrow<RefCount<T>> for BoxRefCount<T> {
+    #[inline(always)]
     fn borrow(&self) -> &RefCount<T> {
         &self.0
     }
 }
 impl<T: ?Sized> Deref for BoxRefCount<T> {
+    #[inline(always)]
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0.data
@@ -122,6 +130,7 @@ impl<T: ?Sized> Deref for BoxRefCount<T> {
 }
 
 impl<T: ?Sized + Eq + Hash + Send + Sync + 'static> ArcIntern<T> {
+    #[inline(always)]
     fn get_pointer(&self) -> *const RefCount<T> {
         self.pointer.as_ptr()
     }
@@ -299,6 +308,7 @@ impl<T: ?Sized + Eq + Hash + Send + Sync> Drop for ArcIntern<T> {
 }
 
 impl<T: ?Sized + Send + Sync + Hash + Eq> AsRef<T> for ArcIntern<T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         unsafe { &self.pointer.as_ref().data }
     }
@@ -306,18 +316,21 @@ impl<T: ?Sized + Send + Sync + Hash + Eq> AsRef<T> for ArcIntern<T> {
 
 impl<T: ?Sized + Eq + Hash + Send + Sync> Deref for ArcIntern<T> {
     type Target = T;
+    #[inline(always)]
     fn deref(&self) -> &T {
         self.as_ref()
     }
 }
 
 impl<T: ?Sized + Eq + Hash + Send + Sync + Display> Display for ArcIntern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.deref().fmt(f)
     }
 }
 
 impl<T: ?Sized + Eq + Hash + Send + Sync> Pointer for ArcIntern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         Pointer::fmt(&self.get_pointer(), f)
     }
@@ -329,12 +342,14 @@ impl<T: ?Sized + Eq + Hash + Send + Sync> Pointer for ArcIntern<T> {
 /// value, but it *is* observable, since you could compare the
 /// hash of the pointer with hash of the data itself.
 impl<T: ?Sized + Eq + Hash + Send + Sync> Hash for ArcIntern<T> {
+    #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.get_pointer().hash(state);
     }
 }
 
 impl<T: ?Sized + Eq + Hash + Send + Sync> PartialEq for ArcIntern<T> {
+    #[inline(always)]
     fn eq(&self, other: &Self) -> bool {
         self.get_pointer() == other.get_pointer()
     }
@@ -342,23 +357,29 @@ impl<T: ?Sized + Eq + Hash + Send + Sync> PartialEq for ArcIntern<T> {
 impl<T: ?Sized + Eq + Hash + Send + Sync> Eq for ArcIntern<T> {}
 
 impl<T: ?Sized + Eq + Hash + Send + Sync + PartialOrd> PartialOrd for ArcIntern<T> {
+    #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.as_ref().partial_cmp(other)
     }
+    #[inline]
     fn lt(&self, other: &Self) -> bool {
         self.as_ref().lt(other)
     }
+    #[inline]
     fn le(&self, other: &Self) -> bool {
         self.as_ref().le(other)
     }
+    #[inline]
     fn gt(&self, other: &Self) -> bool {
         self.as_ref().gt(other)
     }
+    #[inline]
     fn ge(&self, other: &Self) -> bool {
         self.as_ref().ge(other)
     }
 }
 impl<T: ?Sized + Eq + Hash + Send + Sync + Ord> Ord for ArcIntern<T> {
+    #[inline]
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.as_ref().cmp(other)
     }
@@ -367,18 +388,21 @@ impl<T: ?Sized + Eq + Hash + Send + Sync + Ord> Ord for ArcIntern<T> {
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 #[cfg(feature = "serde")]
 impl<T: ?Sized + Eq + Hash + Send + Sync + Serialize> Serialize for ArcIntern<T> {
+    #[inline]
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.as_ref().serialize(serializer)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + 'static> From<T> for ArcIntern<T> {
+    #[inline]
     fn from(t: T) -> Self {
         ArcIntern::new(t)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + Default + 'static> Default for ArcIntern<T> {
+    #[inline]
     fn default() -> Self {
         ArcIntern::new(Default::default())
     }
@@ -390,6 +414,7 @@ impl<'de, T> Deserialize<'de> for ArcIntern<T>
 where
     T: Eq + Hash + Send + Sync + 'static + Deserialize<'de>,
 {
+    #[inline]
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         T::deserialize(deserializer).map(|x: T| Self::new(x))
     }
diff --git a/src/arena.rs b/src/arena.rs
index dbfca93..09ee130 100644
--- a/src/arena.rs
+++ b/src/arena.rs
@@ -64,16 +64,16 @@ impl<'a, T: ?Sized + deepsize::DeepSizeOf> deepsize::DeepSizeOf for ArenaIntern<
 }
 
 impl<'a, T: ?Sized> Clone for ArenaIntern<'a, T> {
+    #[inline(always)]
     fn clone(&self) -> Self {
-        ArenaIntern {
-            pointer: self.pointer,
-        }
+        *self
     }
 }
 impl<'a, T: ?Sized> Copy for ArenaIntern<'a, T> {}
 
 impl<T: ?Sized> Arena<T> {
     /// Allocate a new `Arena`
+    #[inline]
     pub fn new() -> Self {
         Arena {
             data: Mutex::new(HashSet::new()),
@@ -150,6 +150,7 @@ impl Arena<str> {
     /// If this value has not previously been interned, then `intern` will
     /// allocate a spot for the value on the heap.  Otherwise, it will return a
     /// pointer to the `str` previously allocated.
+    #[inline]
     pub fn intern<'a, 'b>(&'a self, val: &'b str) -> ArenaIntern<'a, str> {
         self.intern_ref(val)
     }
@@ -158,6 +159,7 @@ impl Arena<str> {
     /// If this value has not previously been interned, then `intern` will save
     /// the provided `String`.  Otherwise, it will free its input `String` and
     /// return a pointer to the `str` previously saved.
+    #[inline]
     pub fn intern_string(&self, val: String) -> ArenaIntern<str> {
         self.intern_from_owned(val)
     }
@@ -166,6 +168,7 @@ impl Arena<str> {
     /// If this value has not previously been interned, then `intern` will save
     /// the provided `Box<str>`.  Otherwise, it will free its input `Box<str>`
     /// and return a pointer to the `str` previously saved.
+    #[inline]
     pub fn intern_box(&self, val: Box<str>) -> ArenaIntern<str> {
         self.intern_from_owned(val)
     }
@@ -185,6 +188,7 @@ impl Arena<std::ffi::CStr> {
     /// let y = arena.intern(std::ffi::CString::new("hello").unwrap().as_c_str());
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern<'a, 'b>(&'a self, val: &'b std::ffi::CStr) -> ArenaIntern<'a, std::ffi::CStr> {
         self.intern_ref(val)
     }
@@ -202,6 +206,7 @@ impl Arena<std::ffi::CStr> {
     /// let y = arena.intern_cstring(std::ffi::CString::new("hello").unwrap());
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_cstring(&self, val: std::ffi::CString) -> ArenaIntern<std::ffi::CStr> {
         self.intern_from_owned(val)
     }
@@ -219,6 +224,7 @@ impl Arena<std::ffi::CStr> {
     /// let y = arena.intern_box(std::ffi::CString::new("hello").unwrap().into_boxed_c_str());
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_box(&self, val: Box<std::ffi::CStr>) -> ArenaIntern<std::ffi::CStr> {
         self.intern_from_owned(val)
     }
@@ -238,6 +244,7 @@ impl Arena<std::ffi::OsStr> {
     /// let y = arena.intern(std::ffi::OsStr::new("hello"));
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern<'a, 'b>(&'a self, val: &'b std::ffi::OsStr) -> ArenaIntern<'a, std::ffi::OsStr> {
         self.intern_ref(val)
     }
@@ -255,6 +262,7 @@ impl Arena<std::ffi::OsStr> {
     /// let y = arena.intern_osstring(std::ffi::OsString::from("hello"));
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_osstring(&self, val: std::ffi::OsString) -> ArenaIntern<std::ffi::OsStr> {
         self.intern_from_owned(val)
     }
@@ -272,6 +280,7 @@ impl Arena<std::ffi::OsStr> {
     /// let y = arena.intern_box(std::ffi::OsString::from("hello").into_boxed_os_str());
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_box(&self, val: Box<std::ffi::OsStr>) -> ArenaIntern<std::ffi::OsStr> {
         self.intern_from_owned(val)
     }
@@ -291,6 +300,7 @@ impl Arena<std::path::Path> {
     /// let y = arena.intern(std::path::Path::new("hello"));
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern<'a, 'b>(&'a self, val: &'b std::path::Path) -> ArenaIntern<'a, std::path::Path> {
         self.intern_ref(val)
     }
@@ -308,6 +318,7 @@ impl Arena<std::path::Path> {
     /// let y = arena.intern_pathbuf(std::path::PathBuf::from("hello"));
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_pathbuf(&self, val: std::path::PathBuf) -> ArenaIntern<std::path::Path> {
         self.intern_from_owned(val)
     }
@@ -325,6 +336,7 @@ impl Arena<std::path::Path> {
     /// let y = arena.intern_box(std::path::PathBuf::from("hello").into_boxed_path());
     /// assert_eq!(x, y);
     /// ```
+    #[inline]
     pub fn intern_box(&self, val: Box<std::path::Path>) -> ArenaIntern<std::path::Path> {
         self.intern_from_owned(val)
     }
@@ -335,6 +347,7 @@ impl<T: Eq + Hash + Copy> Arena<[T]> {
     /// If this value has not previously been interned, then `intern` will
     /// allocate a spot for the value on the heap.  Otherwise, it will return a
     /// pointer to the `[T]` previously allocated.
+    #[inline]
     pub fn intern<'a, 'b>(&'a self, val: &'b [T]) -> ArenaIntern<'a, [T]> {
         self.intern_ref(val)
     }
@@ -343,6 +356,7 @@ impl<T: Eq + Hash + Copy> Arena<[T]> {
     /// If this value has not previously been interned, then `intern` will save
     /// the provided `Vec<T>`.  Otherwise, it will free its input `Vec<T>` and
     /// return a pointer to the `[T]` previously saved.
+    #[inline]
     pub fn intern_vec(&self, val: Vec<T>) -> ArenaIntern<[T]> {
         self.intern_from_owned(val)
     }
@@ -351,6 +365,7 @@ impl<T: Eq + Hash + Copy> Arena<[T]> {
     /// If this value has not previously been interned, then `intern` will save
     /// the provided `Box<CSr>`.  Otherwise, it will free its input `Box<[T]>`
     /// and return a pointer to the `[T]` previously saved.
+    #[inline]
     pub fn intern_box(&self, val: Box<[T]>) -> ArenaIntern<[T]> {
         self.intern_from_owned(val)
     }
@@ -379,12 +394,14 @@ impl<T: Eq + Hash + ?Sized> Arena<T> {
 }
 
 impl<T> Default for Arena<T> {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }
 }
 
 impl<'a, T: ?Sized> AsRef<T> for ArenaIntern<'a, T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         self.pointer
     }
@@ -392,12 +409,14 @@ impl<'a, T: ?Sized> AsRef<T> for ArenaIntern<'a, T> {
 
 impl<'a, T: ?Sized> std::ops::Deref for ArenaIntern<'a, T> {
     type Target = T;
+    #[inline(always)]
     fn deref(&self) -> &Self::Target {
         self.as_ref()
     }
 }
 
 impl<'a, T: ?Sized> ArenaIntern<'a, T> {
+    #[inline(always)]
     fn get_pointer(&self) -> *const T {
         self.pointer as *const T
     }
@@ -456,6 +475,7 @@ impl<'a, T: ?Sized> ArenaIntern<'a, T> {
     ///     }
     /// }
     /// ```
+    #[inline(always)]
     pub fn into_ref(self) -> &'a T {
         self.pointer
     }
@@ -467,12 +487,14 @@ impl<'a, T: ?Sized> ArenaIntern<'a, T> {
 /// value, but it *is* observable, since you could compare the
 /// hash of the pointer with hash of the data itself.
 impl<'a, T: ?Sized> Hash for ArenaIntern<'a, T> {
+    #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.get_pointer().hash(state);
     }
 }
 
 impl<'a, T: ?Sized> PartialEq for ArenaIntern<'a, T> {
+    #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.get_pointer() == other.get_pointer()
     }
@@ -483,12 +505,14 @@ impl<'a, T: ?Sized> Eq for ArenaIntern<'a, T> {}
 // create_impls_no_new!(ArenaIntern, arenaintern_impl_tests, ['a], [Eq, Hash], [Eq, Hash]);
 
 impl<'a, T: std::fmt::Debug + ?Sized> std::fmt::Debug for ArenaIntern<'a, T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.as_ref().fmt(f)
     }
 }
 
 impl<'a, T: std::fmt::Display + ?Sized> std::fmt::Display for ArenaIntern<'a, T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.as_ref().fmt(f)
     }
diff --git a/src/boxedset.rs b/src/boxedset.rs
index 15c98ec..c5a3b5d 100644
--- a/src/boxedset.rs
+++ b/src/boxedset.rs
@@ -7,11 +7,13 @@ use std::{
 pub struct HashSet<P>(HashMap<P, ()>);
 
 impl<P: Deref + Eq + Hash> Default for HashSet<P> {
+    #[inline]
     fn default() -> Self {
         HashSet::new()
     }
 }
 impl<P> HashSet<P> {
+    #[inline]
     pub fn new() -> Self {
         HashSet(HashMap::new())
     }
@@ -71,17 +73,21 @@ impl<P: Deref + Eq + Hash> HashSet<P> {
         // };
         // let x = self.0.raw_entry_mut().from_hash(hash, |k| <P::Target as Borrow<Q>>::borrow(k) == key)
     }
+    #[inline]
     pub fn insert(&mut self, x: P) {
         self.0.insert(x, ());
     }
+    #[inline]
     pub fn len(&self) -> usize {
         self.0.len()
     }
     #[allow(dead_code)] // maybe unused without `deepsize` feature
+    #[inline]
     pub fn capacity(&self) -> usize {
         self.0.capacity()
     }
     #[cfg(feature = "bench")]
+    #[inline]
     pub fn clear(&mut self) {
         self.0.clear()
     }
diff --git a/src/intern.rs b/src/intern.rs
index 3ed38f9..82d0758 100644
--- a/src/intern.rs
+++ b/src/intern.rs
@@ -6,6 +6,7 @@ use std::convert::AsRef;
 use std::fmt::{Debug, Display, Pointer};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
+use std::ptr;
 
 use super::container;
 
@@ -91,10 +92,9 @@ fn has_niche() {
 }
 
 impl<T: ?Sized> Clone for Intern<T> {
+    #[inline(always)]
     fn clone(&self) -> Self {
-        Intern {
-            pointer: self.pointer,
-        }
+        *self
     }
 }
 
@@ -103,6 +103,7 @@ impl<T: ?Sized> Clone for Intern<T> {
 impl<T: ?Sized> Copy for Intern<T> {}
 
 impl<T: ?Sized> Intern<T> {
+    #[inline(always)]
     fn get_pointer(&self) -> *const T {
         self.pointer as *const T
     }
@@ -113,6 +114,7 @@ static INTERN_CONTAINERS: container::Arena = container::Arena::new();
 macro_rules! from_via_box {
     ($t:ty) => {
         impl From<&$t> for Intern<$t> {
+            #[inline]
             fn from(val: &$t) -> Self {
                 Self::via_box(val)
             }
@@ -123,6 +125,7 @@ from_via_box!(std::ffi::CStr);
 from_via_box!(str);
 from_via_box!(std::path::Path);
 impl<T: Eq + Hash + Send + Sync + 'static + Copy> From<&[T]> for Intern<[T]> {
+    #[inline]
     fn from(val: &[T]) -> Self {
         Self::via_box(val)
     }
@@ -130,6 +133,7 @@ impl<T: Eq + Hash + Send + Sync + 'static + Copy> From<&[T]> for Intern<[T]> {
 
 impl<T: Eq + Hash + Send + Sync + 'static + Copy, const N: usize> From<&[T; N]> for Intern<[T]> {
     /// Converts a `[T; N]` into a `Intern<[T]>`
+    #[inline]
     fn from(val: &[T; N]) -> Self {
         Self::via_box(val)
     }
@@ -228,6 +232,7 @@ impl<T: Eq + Hash + Send + Sync + 'static> Intern<T> {
 impl<T: Eq + Hash + Send + Sync + 'static + ?Sized> Intern<T> {
     /// Get a long-lived reference to the data pointed to by an `Intern`, which
     /// is never freed from the intern pool.
+    #[inline(always)]
     pub fn as_ref(self) -> &'static T {
         self.pointer
     }
@@ -322,6 +327,7 @@ fn test_intern_set64() {
 }
 
 impl<T: ?Sized> AsRef<T> for Intern<T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         self.pointer
     }
@@ -329,18 +335,21 @@ impl<T: ?Sized> AsRef<T> for Intern<T> {
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> Deref for Intern<T> {
     type Target = T;
+    #[inline(always)]
     fn deref(&self) -> &T {
         self.as_ref()
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + Display + ?Sized> Display for Intern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.deref().fmt(f)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> Pointer for Intern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         Pointer::fmt(&self.get_pointer(), f)
     }
@@ -352,12 +361,14 @@ impl<T: Eq + Hash + Send + Sync + ?Sized> Pointer for Intern<T> {
 /// value, but it *is* observable, since you could compare the
 /// hash of the pointer with hash of the data itself.
 impl<T: Eq + Hash + Send + Sync + ?Sized> Hash for Intern<T> {
+    #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.get_pointer().hash(state);
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> PartialEq for Intern<T> {
+    #[inline]
     fn eq(&self, other: &Self) -> bool {
         std::ptr::eq(self.get_pointer(), other.get_pointer())
     }
@@ -365,23 +376,29 @@ impl<T: Eq + Hash + Send + Sync + ?Sized> PartialEq for Intern<T> {
 impl<T: Eq + Hash + Send + Sync + ?Sized> Eq for Intern<T> {}
 
 impl<T: Eq + Hash + Send + Sync + PartialOrd + ?Sized> PartialOrd for Intern<T> {
+    #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.as_ref().partial_cmp(other)
     }
+    #[inline]
     fn lt(&self, other: &Self) -> bool {
         self.as_ref().lt(other)
     }
+    #[inline]
     fn le(&self, other: &Self) -> bool {
         self.as_ref().le(other)
     }
+    #[inline]
     fn gt(&self, other: &Self) -> bool {
         self.as_ref().gt(other)
     }
+    #[inline]
     fn ge(&self, other: &Self) -> bool {
         self.as_ref().ge(other)
     }
 }
 impl<T: Eq + Hash + Send + Sync + Ord + ?Sized> Ord for Intern<T> {
+    #[inline]
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.as_ref().cmp(other)
     }
@@ -390,17 +407,20 @@ impl<T: Eq + Hash + Send + Sync + Ord + ?Sized> Ord for Intern<T> {
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 #[cfg(feature = "serde")]
 impl<T: Eq + Hash + Send + Sync + Serialize + ?Sized> Serialize for Intern<T> {
+    #[inline]
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.as_ref().serialize(serializer)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + 'static> From<T> for Intern<T> {
+    #[inline]
     fn from(t: T) -> Self {
         Intern::new(t)
     }
 }
 impl<T: Eq + Hash + Send + Sync + Default + 'static> Default for Intern<T> {
+    #[inline]
     fn default() -> Self {
         Intern::new(Default::default())
     }
@@ -631,6 +651,7 @@ mod intern_tests {
 }
 
 impl<T: Debug + ?Sized> Debug for Intern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.as_ref().fmt(f)
     }
diff --git a/src/typearena.rs b/src/typearena.rs
index 82bdec2..037ebfe 100644
--- a/src/typearena.rs
+++ b/src/typearena.rs
@@ -149,10 +149,9 @@ fn has_niche() {
 }
 
 impl<T: ?Sized> Clone for Intern<T> {
+    #[inline(always)]
     fn clone(&self) -> Self {
-        Intern {
-            pointer: self.pointer,
-        }
+        *self
     }
 }
 
@@ -161,6 +160,7 @@ impl<T: ?Sized> Clone for Intern<T> {
 impl<T: ?Sized> Copy for Intern<T> {}
 
 impl<T: ?Sized> Intern<T> {
+    #[inline(always)]
     fn get_pointer(&self) -> *const T {
         self.pointer as *const T
     }
@@ -169,6 +169,7 @@ impl<T: ?Sized> Intern<T> {
 macro_rules! from_via_box {
     ($t:ty) => {
         impl From<&$t> for Intern<$t> {
+            #[inline]
             fn from(val: &$t) -> Self {
                 Self::via_box(val)
             }
@@ -179,6 +180,7 @@ from_via_box!(std::ffi::CStr);
 from_via_box!(str);
 from_via_box!(std::path::Path);
 impl<T: Eq + Hash + Send + Sync + 'static + Copy> From<&[T]> for Intern<[T]> {
+    #[inline]
     fn from(val: &[T]) -> Self {
         Self::via_box(val)
     }
@@ -186,6 +188,7 @@ impl<T: Eq + Hash + Send + Sync + 'static + Copy> From<&[T]> for Intern<[T]> {
 
 impl<T: Eq + Hash + Send + Sync + 'static + Copy, const N: usize> From<&[T; N]> for Intern<[T]> {
     /// Converts a `[T; N]` into a `Intern<[T]>`
+    #[inline]
     fn from(val: &[T; N]) -> Self {
         Self::via_box(val)
     }
@@ -278,6 +281,7 @@ impl<T: Eq + Hash + Send + Sync + 'static> Intern<T> {
 impl<T: Any + Eq + Hash + Send + Sync + ?Sized> Intern<T> {
     /// Get a long-lived reference to the data pointed to by an `Intern`, which
     /// is never freed from the intern pool.
+    #[inline(always)]
     pub fn as_ref(self) -> &'static T {
         self.pointer
     }
@@ -363,6 +367,7 @@ fn test_intern_set64() {
 }
 
 impl<T: ?Sized> AsRef<T> for Intern<T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         self.pointer
     }
@@ -370,18 +375,21 @@ impl<T: ?Sized> AsRef<T> for Intern<T> {
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> Deref for Intern<T> {
     type Target = T;
+    #[inline(always)]
     fn deref(&self) -> &T {
         self.as_ref()
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + Display + ?Sized> Display for Intern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.deref().fmt(f)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> Pointer for Intern<T> {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         Pointer::fmt(&self.get_pointer(), f)
     }
@@ -393,12 +401,14 @@ impl<T: Eq + Hash + Send + Sync + ?Sized> Pointer for Intern<T> {
 /// value, but it *is* observable, since you could compare the
 /// hash of the pointer with hash of the data itself.
 impl<T: Eq + Hash + Send + Sync + ?Sized> Hash for Intern<T> {
+    #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.get_pointer().hash(state);
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + ?Sized> PartialEq for Intern<T> {
+    #[inline(always)]
     fn eq(&self, other: &Self) -> bool {
         self.get_pointer() == other.get_pointer()
     }
@@ -406,23 +416,29 @@ impl<T: Eq + Hash + Send + Sync + ?Sized> PartialEq for Intern<T> {
 impl<T: Eq + Hash + Send + Sync + ?Sized> Eq for Intern<T> {}
 
 impl<T: Eq + Hash + Send + Sync + PartialOrd + ?Sized> PartialOrd for Intern<T> {
+    #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.as_ref().partial_cmp(other)
     }
+    #[inline]
     fn lt(&self, other: &Self) -> bool {
         self.as_ref().lt(other)
     }
+    #[inline]
     fn le(&self, other: &Self) -> bool {
         self.as_ref().le(other)
     }
+    #[inline]
     fn gt(&self, other: &Self) -> bool {
         self.as_ref().gt(other)
     }
+    #[inline]
     fn ge(&self, other: &Self) -> bool {
         self.as_ref().ge(other)
     }
 }
 impl<T: Eq + Hash + Send + Sync + Ord + ?Sized> Ord for Intern<T> {
+    #[inline]
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.as_ref().cmp(other)
     }
@@ -431,17 +447,20 @@ impl<T: Eq + Hash + Send + Sync + Ord + ?Sized> Ord for Intern<T> {
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 #[cfg(feature = "serde")]
 impl<T: Eq + Hash + Send + Sync + Serialize> Serialize for Intern<T> {
+    #[inline]
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.as_ref().serialize(serializer)
     }
 }
 
 impl<T: Eq + Hash + Send + Sync + 'static> From<T> for Intern<T> {
+    #[inline]
     fn from(t: T) -> Self {
         Intern::new(t)
     }
 }
 impl<T: Eq + Hash + Send + Sync + Default + 'static> Default for Intern<T> {
+    #[inline]
     fn default() -> Self {
         Intern::new(Default::default())
     }
@@ -450,6 +469,7 @@ impl<T: Eq + Hash + Send + Sync + Default + 'static> Default for Intern<T> {
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 #[cfg(feature = "serde")]
 impl<'de, T: Eq + Hash + Send + Sync + 'static + Deserialize<'de>> Deserialize<'de> for Intern<T> {
+    #[inline]
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         T::deserialize(deserializer).map(|x: T| Self::new(x))
     }