From fd682be902665c591c6c6036417078cd6aad2d49 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     | 26 ++++++++++++++++++++++++++
 src/boxedset.rs  |  6 ++++++
 src/intern.rs    | 23 ++++++++++++++++++++++-
 src/typearena.rs | 22 ++++++++++++++++++++++
 5 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/src/arc.rs b/src/arc.rs
index 6f0d69e..9757c60 100644
--- a/src/arc.rs
+++ b/src/arc.rs
@@ -51,6 +51,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
     }
@@ -82,11 +83,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)
     }
@@ -95,35 +98,41 @@ 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> {
     type Target = T;
+    #[inline(always)]
     fn deref(&self) -> &Self::Target {
         &self.0.data
     }
 }
 
 impl<T: ?Sized + Eq + Hash + Send + Sync + 'static> ArcIntern<T> {
+    #[inline(always)]
     fn get_pointer(&self) -> *const RefCount<T> {
         self.pointer.as_ptr()
     }
@@ -302,6 +311,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 }
     }
@@ -326,18 +336,21 @@ impl_as_ref!(Path => OsStr);
 
 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)
     }
@@ -349,12 +362,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 {
         std::ptr::eq(self.get_pointer(), other.get_pointer())
     }
@@ -362,23 +377,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)
     }
@@ -387,18 +408,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())
     }
@@ -410,6 +434,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 248b1e4..647d8dc 100644
--- a/src/arena.rs
+++ b/src/arena.rs
@@ -64,6 +64,7 @@ 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 {
         *self
     }
@@ -72,6 +73,7 @@ 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()),
@@ -148,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>(&'a self, val: &str) -> ArenaIntern<'a, str> {
         self.intern_ref(val)
     }
@@ -156,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)
     }
@@ -164,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)
     }
@@ -183,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>(&'a self, val: &std::ffi::CStr) -> ArenaIntern<'a, std::ffi::CStr> {
         self.intern_ref(val)
     }
@@ -200,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)
     }
@@ -217,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)
     }
@@ -236,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>(&'a self, val: &std::ffi::OsStr) -> ArenaIntern<'a, std::ffi::OsStr> {
         self.intern_ref(val)
     }
@@ -253,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)
     }
@@ -270,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)
     }
@@ -289,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>(&'a self, val: &std::path::Path) -> ArenaIntern<'a, std::path::Path> {
         self.intern_ref(val)
     }
@@ -306,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)
     }
@@ -323,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)
     }
@@ -333,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>(&'a self, val: &[T]) -> ArenaIntern<'a, [T]> {
         self.intern_ref(val)
     }
@@ -341,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)
     }
@@ -349,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)
     }
@@ -377,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
     }
@@ -390,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
     }
@@ -454,6 +475,7 @@ impl<'a, T: ?Sized> ArenaIntern<'a, T> {
     ///     }
     /// }
     /// ```
+    #[inline(always)]
     pub fn into_ref(self) -> &'a T {
         self.pointer
     }
@@ -465,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 {
         std::ptr::eq(self.get_pointer(), other.get_pointer())
     }
@@ -481,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 063efc4..de992d1 100644
--- a/src/intern.rs
+++ b/src/intern.rs
@@ -60,7 +60,6 @@ fn like_doctest_intern() {
     assert_eq!(&*x, "hello"); // dereference a Intern like a pointer\
 }
 
-
 #[cfg(feature = "deepsize")]
 impl<T: 'static + ?Sized> deepsize::DeepSizeOf for Intern<T> {
     fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
@@ -90,6 +89,7 @@ fn has_niche() {
 }
 
 impl<T: ?Sized> Clone for Intern<T> {
+    #[inline(always)]
     fn clone(&self) -> Self {
         *self
     }
@@ -100,6 +100,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
     }
@@ -110,6 +111,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)
             }
@@ -120,6 +122,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)
     }
@@ -127,6 +130,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)
     }
@@ -226,6 +230,7 @@ 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.
     #[allow(clippy::should_implement_trait)]
+    #[inline]
     pub fn as_ref(self) -> &'static T {
         self.pointer
     }
@@ -320,6 +325,7 @@ fn test_intern_set64() {
 }
 
 impl<T: ?Sized> AsRef<T> for Intern<T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         self.pointer
     }
@@ -343,18 +349,21 @@ impl_as_ref!(Path => OsStr);
 
 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)
     }
@@ -366,12 +375,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())
     }
@@ -379,23 +390,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)
     }
@@ -404,17 +421,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())
     }
@@ -645,6 +665,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 837348d..347b493 100644
--- a/src/typearena.rs
+++ b/src/typearena.rs
@@ -151,6 +151,7 @@ fn has_niche() {
 }
 
 impl<T: ?Sized> Clone for Intern<T> {
+    #[inline(always)]
     fn clone(&self) -> Self {
         *self
     }
@@ -161,6 +162,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 +171,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 +182,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 +190,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)
     }
@@ -279,6 +284,7 @@ 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.
     #[allow(clippy::should_implement_trait)]
+    #[inline(always)]
     pub fn as_ref(self) -> &'static T {
         self.pointer
     }
@@ -364,6 +370,7 @@ fn test_intern_set64() {
 }
 
 impl<T: ?Sized> AsRef<T> for Intern<T> {
+    #[inline(always)]
     fn as_ref(&self) -> &T {
         self.pointer
     }
@@ -387,18 +394,21 @@ impl_as_ref!(Path => OsStr);
 
 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)
     }
@@ -410,12 +420,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 {
         std::ptr::eq(self.get_pointer(), other.get_pointer())
     }
@@ -423,23 +435,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)
     }
@@ -448,17 +466,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())
     }
@@ -467,6 +488,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))
     }