BucketBackend panics with "encountered invalid head capacity" on cloning when using get_or_intern_static

[twinkle-mouse]

Here's a test:

#[test]
fn bucket_backend_clone() {
    let mut interner = StringInterner::<BucketBackend>::new();
    let hello = interner.get_or_intern_static("hello");
    let goodbye = interner.get_or_intern_static("goodbye");
    let foo = interner.get_or_intern_static("foo");
    let bar = interner.get_or_intern_static("bar");

    let cloned = interner.clone();
    assert_eq!(Some(hello), cloned.get("hello"));
    assert_eq!(Some(goodbye), cloned.get("goodbye"));
    assert_eq!(Some(foo), cloned.get("foo"));
    assert_eq!(Some(bar), cloned.get("bar"));
}

It panics at .clone()

[twinkle-mouse]

Upon closer inspection it only panics with get_or_intern_static

[twinkle-mouse]

Here's a patch:

From ae3aeb6f0a822b52249e58bf0e4cadc1feec8550 Mon Sep 17 00:00:00 2001
Date: Sat, 25 Apr 2026 13:54:03 +0200
Subject: [PATCH 1/2] add test for `get_or_intern_static_works` accounting for
 cloning the Interner

---
 tests/tests.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/tests.rs b/tests/tests.rs
index 1f4a55c..b3e579a 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -270,10 +270,12 @@ macro_rules! gen_tests_for_backend {
             assert_ne!(c, a);
             // The length of the string interner must be 3 at this point.
             assert_eq!(interner.len(), 3);
+            // Cloning should work too.
+            let mut cloned = interner.clone();
             // Insert the same 3 unique strings, yield the same symbols:
-            assert_eq!(interner.get_or_intern_static("aa").to_usize(), a);
-            assert_eq!(interner.get_or_intern_static("bb").to_usize(), b);
-            assert_eq!(interner.get_or_intern_static("cc").to_usize(), c);
+            assert_eq!(cloned.get_or_intern_static("aa").to_usize(), a);
+            assert_eq!(cloned.get_or_intern_static("bb").to_usize(), b);
+            assert_eq!(cloned.get_or_intern_static("cc").to_usize(), c);
             assert_eq!(interner.len(), 3);
         }
 
-- 
2.54.0

From 547fc6b9f4e65c83dbc9ed6c7435547c6356aec9 Mon Sep 17 00:00:00 2001
Date: Sat, 25 Apr 2026 13:54:24 +0200
Subject: [PATCH 2/2] fix BucketBackend cloning when get_or_intern_static is
 used

---
 src/backend/bucket/fixed_str.rs |  8 ++++++
 src/backend/bucket/mod.rs       | 47 ++++++++++++++++++++++++++++++---
 2 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/src/backend/bucket/fixed_str.rs b/src/backend/bucket/fixed_str.rs
index c3fac0c..5c62fa2 100644
--- a/src/backend/bucket/fixed_str.rs
+++ b/src/backend/bucket/fixed_str.rs
@@ -37,6 +37,14 @@ impl FixedString {
         self.contents.len()
     }
 
+    /// Checks whether the fixed string "contains" `other` by checking their pointer addresses.
+    ///
+    /// Returns true when `other` is a substring of the fixed string, otherwise false.
+    #[inline]
+    pub fn contains_substr(&self, other: &str) -> bool {
+        super::str_contains_substr(&self.contents, other)
+    }
+
     /// Pushes the given string into the fixed string if there is enough capacity.
     ///
     /// Returns a reference to the pushed string if there was enough capacity to
diff --git a/src/backend/bucket/mod.rs b/src/backend/bucket/mod.rs
index 5e5ad48..a9959c1 100644
--- a/src/backend/bucket/mod.rs
+++ b/src/backend/bucket/mod.rs
@@ -177,10 +177,19 @@ impl<S> Clone for BucketBackend<S> {
         let mut spans = Vec::with_capacity(self.spans.len());
         for span in &self.spans {
             let string = span.as_str();
-            let interned = head
-                .push_str(string)
-                .expect("encountered invalid head capacity");
-            spans.push(interned);
+
+            // BucketBackend supports `intern_static`, we need to check if we actually allocated this string.
+            if self.head.contains_substr(string)
+                || self.full.iter().any(|s| str_contains_substr(s, string))
+            {
+                let interned: InternedStr = head
+                    .push_str(string)
+                    .expect("encountered invalid head capacity");
+                spans.push(interned);
+            } else {
+                // We didn't allocate this string, it must be static.
+                spans.push(InternedStr::new(string));
+            }
         }
         Self {
             spans,
@@ -249,3 +258,33 @@ where
             .map(|(id, interned)| (expect_valid_symbol(id), interned.as_str()))
     }
 }
+
+/// Checks whether `this` "contains" `other` by checking their pointer addresses.
+///
+/// Returns true when `other` is a substring of `this`, otherwise false.
+#[inline]
+pub(crate) fn str_contains_substr(this: &str, other: &str) -> bool {
+    let range = unsafe { this.as_ptr()..(this.as_ptr().add(this.len())) };
+
+    range.contains(&other.as_ptr())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FixedString;
+
+    #[test]
+    fn fixed_str_contains_ptr() {
+        let mut fixed = FixedString::with_capacity(20);
+        let hello = fixed.push_str("hello").unwrap();
+        let world = fixed.push_str("world").unwrap();
+        let foooo = fixed.push_str("foooo").unwrap();
+        let barrr = fixed.push_str("barrr").unwrap();
+
+        assert!(fixed.contains_substr(hello.as_str()));
+        assert!(fixed.contains_substr(world.as_str()));
+        assert!(fixed.contains_substr(foooo.as_str()));
+        assert!(fixed.contains_substr(barrr.as_str()));
+        assert!(!fixed.contains_substr("hello"));
+    }
+}
-- 
2.54.0

[twinkle-mouse]

Basically: the code first checks if we actually allocated the string by checking if any of our strings is the superstring, and if it's not allocated by us we assume it's a static string and just push it as InternedString, skipping allocation onto head