diff --git a/README.md b/README.md
index 3a3fbf1..0a54418 100644
--- a/README.md
+++ b/README.md
@@ -4,35 +4,32 @@ An easy-to-use, incremental, multi-threaded garbage collector for Rust.
 
 ```rust
 //! A basic usage example demonstrating the garbage collector.
-use refuse::{collected, CollectionGuard, Ref, Root};
-
-#[collected]
-fn main() {
-    let guard = CollectionGuard::acquire();
-    // Allocate a vec![Ref(1), Ref(2), Ref(3)].
-    let values: Vec<Ref<u32>> = (1..=3).map(|value| Ref::new(value, &guard)).collect();
-    let values = Root::new(values, &guard);
-    drop(guard);
-
-    // Manually execute the garbage collector. Our data will not be freed,
-    // since `values` is a "root" reference.
-    refuse::collect();
-
-    // Root references allow direct access to their data, even when a
-    // `CollectionGuard` isn't held.
-    let (one, two, three) = (values[0], values[1], values[2]);
-
-    // Accessing the data contained in a `Ref` requires a guard, however.
-    let mut guard = CollectionGuard::acquire();
-    assert_eq!(one.load(&guard), Some(&1));
-    assert_eq!(two.load(&guard), Some(&2));
-    assert_eq!(three.load(&guard), Some(&3));
-
-    // Dropping our root will allow the collector to free our `Ref`s.
-    drop(values);
-    guard.collect();
-    assert_eq!(one.load(&guard), None);
-}
+use refuse::{CollectionGuard, Ref, Root};
+
+let guard = CollectionGuard::acquire();
+// Allocate a vec![Ref(1), Ref(2), Ref(3)].
+let values: Vec<Ref<u32>> = (1..=3).map(|value| Ref::new(value, &guard)).collect();
+let values = Root::new(values, &guard);
+drop(guard);
+
+// Manually execute the garbage collector. Our data will not be freed,
+// since `values` is a "root" reference.
+refuse::collect();
+
+// Root references allow direct access to their data, even when a
+// `CollectionGuard` isn't held.
+let (one, two, three) = (values[0], values[1], values[2]);
+
+// Accessing the data contained in a `Ref` requires a guard, however.
+let mut guard = CollectionGuard::acquire();
+assert_eq!(one.load(&guard), Some(&1));
+assert_eq!(two.load(&guard), Some(&2));
+assert_eq!(three.load(&guard), Some(&3));
+
+// Dropping our root will allow the collector to free our `Ref`s.
+drop(values);
+guard.collect();
+assert_eq!(one.load(&guard), None);
 ```
 
 As the version number indicates, this crate is in early development. No semver
diff --git a/benchmarks/benches/timings.rs b/benchmarks/benches/timings.rs
index e4126e5..7596c9c 100644
--- a/benchmarks/benches/timings.rs
+++ b/benchmarks/benches/timings.rs
@@ -4,7 +4,7 @@ use std::convert::Infallible;
 use std::hint::black_box;
 use std::sync::Arc;
 
-use refuse::{collected, CollectionGuard, Ref, Root};
+use refuse::{CollectionGuard, Ref, Root};
 use timings::{Benchmark, BenchmarkImplementation, Label, LabeledTimings, Timings};
 
 const TOTAL_ITERS: usize = 100_000;
@@ -105,21 +105,20 @@ impl BenchmarkImplementation<Label, (), Infallible> for GcRef {
 
     fn measure(&mut self, measurements: &LabeledTimings<Label>) -> Result<(), Infallible> {
         let mut allocated = Vec::<Ref<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
-        collected(|| {
-            let mut guard = CollectionGuard::acquire();
-            for _ in 0..OUTER_ITERS {
-                for i in 0..ITERS_PER_RELEASE {
-                    let timing = measurements.begin(self.metric.clone());
-                    let result = black_box(Ref::new([0; 32], &guard));
-                    if i == ITERS_PER_RELEASE - 1 {
-                        allocated.clear();
-                        guard.yield_to_collector();
-                    }
-                    timing.finish();
-                    allocated.push(result);
+
+        let mut guard = CollectionGuard::acquire();
+        for _ in 0..OUTER_ITERS {
+            for i in 0..ITERS_PER_RELEASE {
+                let timing = measurements.begin(self.metric.clone());
+                let result = black_box(Ref::new([0; 32], &guard));
+                if i == ITERS_PER_RELEASE - 1 {
+                    allocated.clear();
+                    guard.yield_to_collector();
                 }
+                timing.finish();
+                allocated.push(result);
             }
-        });
+        }
 
         Ok(())
     }
@@ -157,21 +156,20 @@ impl BenchmarkImplementation<Label, (), Infallible> for GcRoot {
 
     fn measure(&mut self, measurements: &LabeledTimings<Label>) -> Result<(), Infallible> {
         let mut allocated = Vec::<Root<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
-        collected(|| {
-            let mut guard = CollectionGuard::acquire();
-            for _ in 0..OUTER_ITERS {
-                for i in 0..ITERS_PER_RELEASE {
-                    let timing = measurements.begin(self.metric.clone());
-                    let result = black_box(Root::new([0; 32], &guard));
-                    if i == ITERS_PER_RELEASE - 1 {
-                        allocated.clear();
-                        guard.yield_to_collector();
-                    }
-                    timing.finish();
-                    allocated.push(result);
+
+        let mut guard = CollectionGuard::acquire();
+        for _ in 0..OUTER_ITERS {
+            for i in 0..ITERS_PER_RELEASE {
+                let timing = measurements.begin(self.metric.clone());
+                let result = black_box(Root::new([0; 32], &guard));
+                if i == ITERS_PER_RELEASE - 1 {
+                    allocated.clear();
+                    guard.yield_to_collector();
                 }
+                timing.finish();
+                allocated.push(result);
             }
-        });
+        }
 
         Ok(())
     }
diff --git a/benchmarks/benches/vs-arc.rs b/benchmarks/benches/vs-arc.rs
index 6175501..6b38879 100644
--- a/benchmarks/benches/vs-arc.rs
+++ b/benchmarks/benches/vs-arc.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use refuse::{collected, CollectionGuard, Ref, Root};
+use refuse::{CollectionGuard, Ref, Root};
 
 fn arc_string() -> Arc<[u8; 32]> {
     Arc::new([0; 32])
@@ -19,18 +19,18 @@ fn ref_string(guard: &mut CollectionGuard<'_>) -> Ref<[u8; 32]> {
 fn criterion_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("alloc-drop");
     group.bench_function("arc", |b| b.iter(|| black_box(arc_string())));
-    collected(|| {
-        group.bench_function("ref", |b| {
-            b.iter(move || {
-                let mut guard = CollectionGuard::acquire();
-                black_box(ref_string(&mut guard))
-            });
+
+    group.bench_function("ref", |b| {
+        b.iter(move || {
+            let mut guard = CollectionGuard::acquire();
+            black_box(ref_string(&mut guard))
         });
-        group.bench_function("root", |b| {
-            b.iter(move || {
-                let mut guard = CollectionGuard::acquire();
-                black_box(root_string(&mut guard))
-            });
+    });
+
+    group.bench_function("root", |b| {
+        b.iter(move || {
+            let mut guard = CollectionGuard::acquire();
+            black_box(root_string(&mut guard))
         });
     });
 }
diff --git a/examples/allocate_a_lot.rs b/examples/allocate_a_lot.rs
index 385e3b9..c334dcb 100644
--- a/examples/allocate_a_lot.rs
+++ b/examples/allocate_a_lot.rs
@@ -1,21 +1,19 @@
 //! An example demonstrating multithreaded allocations.
 //!
 //! This exists an easy executable to tweak and run with profiling tools.
-use refuse::{collected, CollectionGuard, Ref};
+use refuse::{CollectionGuard, Ref};
 
 fn main() {
     std::thread::scope(|s| {
         for _ in 0..16 {
             s.spawn(|| {
-                collected(|| {
-                    let mut guard = CollectionGuard::acquire();
+                let mut guard = CollectionGuard::acquire();
+                for _ in 0..100 {
                     for _ in 0..100 {
-                        for _ in 0..100 {
-                            Ref::new([0; 32], &guard);
-                        }
-                        guard.yield_to_collector();
+                        Ref::new([0; 32], &guard);
                     }
-                });
+                    guard.yield_to_collector();
+                }
             });
         }
     });
diff --git a/examples/basic.rs b/examples/basic.rs
index 30e2dba..ebc84e2 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,7 +1,6 @@
 //! A basic usage example demonstrating the garbage collector.
-use refuse::{collected, CollectionGuard, Ref, Root};
+use refuse::{CollectionGuard, Ref, Root};
 
-#[collected]
 fn main() {
     let guard = CollectionGuard::acquire();
     // Allocate a vec![Ref(1), Ref(2), Ref(3)].
diff --git a/examples/map_as.rs b/examples/map_as.rs
index 9d7e50d..cbf25a4 100644
--- a/examples/map_as.rs
+++ b/examples/map_as.rs
@@ -13,7 +13,7 @@
 //! [rustnomicon]:
 //!     https://doc.rust-lang.org/nomicon/exotic-sizes.html#dynamically-sized-types-dsts
 
-use refuse::{collected, AnyRef, CollectionGuard, MapAs, Ref, Trace};
+use refuse::{AnyRef, CollectionGuard, MapAs, Ref, Trace};
 
 trait SomeTrait {
     fn do_something(&self);
@@ -29,7 +29,6 @@ impl SomeTrait for SomeType {
     }
 }
 
-#[collected]
 fn main() {
     let guard = CollectionGuard::acquire();
     let gced: Ref<SomeType> = Ref::new(SomeType, &guard);
diff --git a/examples/trace.rs b/examples/trace.rs
index 232396b..1dfec35 100644
--- a/examples/trace.rs
+++ b/examples/trace.rs
@@ -1,14 +1,13 @@
 //! This example shows how the `Collectable` derive implements tracing
 //! automatically.
 
-use refuse::{collected, CollectionGuard, MapAs, Ref, Root, Trace};
+use refuse::{CollectionGuard, MapAs, Ref, Root, Trace};
 
 #[derive(Trace, MapAs)]
 struct Error {
     message: Ref<String>,
 }
 
-#[collected]
 fn main() {
     let mut guard = CollectionGuard::acquire();
 
diff --git a/refuse-macros/src/lib.rs b/refuse-macros/src/lib.rs
index 2bf1e49..bd152ac 100644
--- a/refuse-macros/src/lib.rs
+++ b/refuse-macros/src/lib.rs
@@ -8,25 +8,6 @@ use manyhow::manyhow;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 
-#[manyhow(item_as_dummy)]
-#[proc_macro_attribute]
-pub fn collected(
-    _input: TokenStream,
-    syn::ItemFn {
-        attrs,
-        vis,
-        sig,
-        block,
-    }: syn::ItemFn,
-) -> TokenStream {
-    quote! {
-        #(#attrs)*
-        #vis #sig {
-            refuse::collected(|| #block);
-        }
-    }
-}
-
 #[manyhow]
 #[proc_macro_derive(MapAs, attributes(map_as))]
 pub fn derive_map_as(input: syn::Item) -> manyhow::Result {
diff --git a/refuse-pool/src/lib.rs b/refuse-pool/src/lib.rs
index f1f852f..344f51c 100644
--- a/refuse-pool/src/lib.rs
+++ b/refuse-pool/src/lib.rs
@@ -306,20 +306,18 @@ impl PartialEq<RefString> for RootString {
 
 #[test]
 fn intern() {
-    refuse::collected(|| {
-        let mut guard = CollectionGuard::acquire();
-        let a = RootString::from("a");
-        let b = RootString::from("a");
-        assert!(Root::ptr_eq(&a.0, &b.0));
-
-        let as_ref = a.downgrade();
-        drop(a);
-        drop(b);
-        assert_eq!(as_ref.load(&guard), Some("a"));
-
-        guard.collect();
-
-        let _a = RootString::from("a");
-        assert!(as_ref.load(&guard).is_none());
-    });
+    let mut guard = CollectionGuard::acquire();
+    let a = RootString::from("a");
+    let b = RootString::from("a");
+    assert!(Root::ptr_eq(&a.0, &b.0));
+
+    let as_ref = a.downgrade();
+    drop(a);
+    drop(b);
+    assert_eq!(as_ref.load(&guard), Some("a"));
+
+    guard.collect();
+
+    let _a = RootString::from("a");
+    assert!(as_ref.load(&guard).is_none());
 }
diff --git a/src/lib.rs b/src/lib.rs
index f3919c6..3f075cf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,7 @@ use std::alloc::{alloc_zeroed, Layout};
 use std::any::{Any, TypeId};
 use std::cell::{Cell, OnceCell, RefCell, UnsafeCell};
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
+use std::fmt::Display;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
@@ -28,7 +29,7 @@ use intentional::{Assert, Cast};
 use kempt::map::Field;
 use kempt::{Map, Set};
 use parking_lot::{Condvar, Mutex, RwLock};
-pub use refuse_macros::{collected, MapAs, Trace};
+pub use refuse_macros::{MapAs, Trace};
 
 /// Architecture overview of the underlying design of Refuse.
 ///
@@ -615,20 +616,24 @@ struct ThreadPool {
 }
 
 impl ThreadPool {
+    fn map_current<R>(map: impl FnOnce(&Self) -> R) -> R {
+        THREAD_POOL.with_borrow(|tp| map(tp.get_or_init(ThreadPool::default)))
+    }
+
     fn get() -> Self {
-        THREAD_POOL.with_borrow(|tp| tp.get().expect("not invoked from collected()").clone())
+        Self::map_current(Self::clone)
+    }
+
+    fn current_depth() -> usize {
+        Self::map_current(|tp| tp.guard_depth.get())
     }
 
     fn push_thread_guard() -> usize {
-        THREAD_POOL.with_borrow(|tp| tp.get().expect("not invoked from collected()").push_guard())
+        Self::map_current(Self::push_guard)
     }
 
     fn release_thread_guard() {
-        THREAD_POOL.with_borrow(|tp| {
-            tp.get()
-                .expect("not invoked from collected()")
-                .release_guard();
-        });
+        Self::map_current(Self::release_guard)
     }
 
     fn push_guard(&self) -> usize {
@@ -718,22 +723,6 @@ impl Drop for LocalPool {
     }
 }
 
-/// Executes `wrapped` with garbage collection available.
-///
-/// This function installs a garbage collector for this thread, if needed.
-/// Repeated and nested calls are allowed.
-///
-/// Invoking [`CollectionGuard::acquire()`] within `wrapped` will return a
-/// result, while invoking it outside of a collected context will panic.
-///
-/// This function utilizes Rust's thread-local storage.
-pub fn collected<R>(wrapped: impl FnOnce() -> R) -> R {
-    THREAD_POOL.with_borrow(|lock| {
-        lock.get_or_init(ThreadPool::default);
-        wrapped()
-    })
-}
-
 struct ReaderState(AtomicUsize);
 
 impl ReaderState {
@@ -956,8 +945,31 @@ impl CollectionGuard<'_> {
     /// until the collection finishes.
     ///
     /// Finally, the guard is reacquired before returning.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if any other [`CollectionGuard`]s are held by
+    /// the current thread when invoked.
     pub fn collect(&mut self) {
-        self.while_unlocked(collect);
+        self.try_collect().unwrap();
+    }
+
+    /// Manually invokes the garbage collector.
+    ///
+    /// This method temporarily releases this guard's lock and waits for a
+    /// garbage collection to run. If a garbage collection is already in
+    /// progress, this function will return when the in-progress collection
+    /// completes. Otherwise, the collector is started and this function waits
+    /// until the collection finishes.
+    ///
+    /// Finally, the guard is reacquired before returning.
+    ///
+    /// # Errors
+    ///
+    /// If another [`CollectionGuard`] is held by the current thread,
+    /// [`WouldDeadlock`] will be returned and `unlocked` will not be invoked.
+    pub fn try_collect(&mut self) -> Result<(), WouldDeadlock> {
+        self.try_while_unlocked(collect_unchecked)
     }
 
     /// Yield to the garbage collector, if needed.
@@ -966,19 +978,45 @@ impl CollectionGuard<'_> {
     /// acquire this thread's lock. Because of this, it is a fairly efficient
     /// function to invoke. To minimize collection pauses, long-held guards
     /// should call this function regularly.
+    ///
+    /// If any other guards are currently held by this thread, this function
+    /// does nothing.
     pub fn yield_to_collector(&mut self) {
-        if self.collector.release_reader_if_collecting() {
+        // We only need to attempt yielding if we are the outermost guard.
+        if ThreadPool::current_depth() == 1 && self.collector.release_reader_if_collecting() {
             self.collector.acquire_reader();
         }
     }
 
     /// Executes `unlocked` while this guard is temporarily released.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if any other [`CollectionGuard`]s are held by
+    /// the current thread when invoked.
     pub fn while_unlocked<R>(&mut self, unlocked: impl FnOnce() -> R) -> R {
-        self.collector.release_reader();
-        let result = unlocked();
-        self.collector.acquire_reader();
+        self.try_while_unlocked(unlocked).unwrap()
+    }
 
-        result
+    /// Executes `unlocked` while this guard is temporarily released.
+    ///
+    /// # Errors
+    ///
+    /// If another [`CollectionGuard`] is held by the current thread,
+    /// [`WouldDeadlock`] will be returned and `unlocked` will not be invoked.
+    pub fn try_while_unlocked<R>(
+        &mut self,
+        unlocked: impl FnOnce() -> R,
+    ) -> Result<R, WouldDeadlock> {
+        if ThreadPool::current_depth() == 1 {
+            self.collector.release_reader();
+            let result = unlocked();
+            self.collector.acquire_reader();
+
+            Ok(result)
+        } else {
+            Err(WouldDeadlock)
+        }
     }
 
     fn adopt<T: Collectable>(&self, value: Rooted<T>) -> (TypeIndex, u32, BinId) {
@@ -1642,12 +1680,10 @@ where
 /// ```rust
 /// use refuse::{CollectionGuard, Ref};
 ///
-/// refuse::collected(|| {
-///     let guard = CollectionGuard::acquire();
-///     let data = Ref::new(42, &guard);
+/// let guard = CollectionGuard::acquire();
+/// let data = Ref::new(42, &guard);
 ///
-///     assert_eq!(data.load(&guard), Some(&42));
-/// });
+/// assert_eq!(data.load(&guard), Some(&42));
 /// ```
 ///
 /// References returned from [`Ref::load()`] are tied to the lifetime of the
@@ -2475,10 +2511,59 @@ enum SlotSweepStatus {
 
 /// Invokes the garbage collector.
 ///
-/// This function will deadlock if any [`CollectionGuard`]s are held by the
-/// current thread when invoked. If a guard is held, consider calling
-/// [`CollectionGuard::collect()`] instead.
+/// # Panics
+///
+/// This function will panic if any [`CollectionGuard`]s are held and not
+/// yielding by the current thread when invoked. If a guard is held, consider
+/// calling [`CollectionGuard::collect()`] instead.
 pub fn collect() {
+    try_collect().unwrap()
+}
+
+/// Invokes the garbage collector.
+///
+/// # Errors
+///
+/// If any [`CollectionGuard`]s are held by this thread when this function is
+/// invoked, [`WouldDeadlock`] is returned.
+pub fn try_collect() -> Result<(), WouldDeadlock> {
+    if ThreadPool::current_depth() > 0 {
+        return Err(WouldDeadlock);
+    }
+    collect_unchecked();
+    Ok(())
+}
+
+/// An error indicating an operation would deadlock.
+///
+/// [`CollectionGuard::acquire`] can be called multiple times from the same
+/// thread, but some operations require that all guards for the current thread
+/// have been released before performing. This error signals when an operation
+/// can't succeed because the current thread has an outstanding guard that must
+/// be dropped for the operation to be able to be performed.
+///
+/// ```rust
+/// use refuse::{CollectionGuard, WouldDeadlock};
+///
+/// let mut guard1 = CollectionGuard::acquire();
+/// let guard2 = CollectionGuard::acquire();
+///
+/// assert_eq!(guard1.try_collect(), Err(WouldDeadlock));
+///
+/// drop(guard2);
+///
+/// assert_eq!(guard1.try_collect(), Ok(()));
+/// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct WouldDeadlock;
+
+impl Display for WouldDeadlock {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("current thread has a non-yielding CollectionGuard")
+    }
+}
+
+fn collect_unchecked() {
     let now = Instant::now();
     CollectorCommand::Collect(now).send();
     GlobalCollector::get().info.wait_for_collection(now);
diff --git a/tests/basic.rs b/tests/basic.rs
index f225280..5ad093d 100644
--- a/tests/basic.rs
+++ b/tests/basic.rs
@@ -1,8 +1,7 @@
 //! A basic usage example demonstrating the garbage collector.
-use refuse::{collected, CollectionGuard, Ref, Root};
+use refuse::{CollectionGuard, Ref, Root};
 
 #[test]
-#[collected]
 fn basic() {
     // Execute a closure with access to a garbage collector.
 
diff --git a/tests/multithreaded.rs b/tests/multithreaded.rs
index 4e5a0a2..fe7c5f5 100644
--- a/tests/multithreaded.rs
+++ b/tests/multithreaded.rs
@@ -6,7 +6,7 @@ use std::time::Duration;
 
 use flume::{Receiver, Sender};
 use parking_lot::Mutex;
-use refuse::{collected, CollectionGuard, NoMapping, Ref, Root, SimpleType, Trace};
+use refuse::{CollectionGuard, NoMapping, Ref, Root, SimpleType, Trace};
 
 const WORK_ITERS: usize = 64;
 const WORK_ITEMS: usize = 64;
@@ -28,21 +28,17 @@ fn round_robin() {
         let next_sender = next.0.clone();
         let receiver = receiver.clone();
         let outstanding = outstanding.clone();
-        thread::spawn(move || {
-            collected(move || thread_worker(&receiver, &next_sender, &outstanding));
-        });
+        thread::spawn(move || thread_worker(&receiver, &next_sender, &outstanding));
     }
 
-    collected(|| {
-        let guard = CollectionGuard::acquire();
-        for i in 0..WORK_ITEMS {
-            channels[i % channels.len()]
-                .0
-                .send(Command::Enqueue(Root::new(WorkUnit::default(), &guard)))
-                .expect("worker disconnected early");
-        }
-        drop(guard);
-    });
+    let guard = CollectionGuard::acquire();
+    for i in 0..WORK_ITEMS {
+        channels[i % channels.len()]
+            .0
+            .send(Command::Enqueue(Root::new(WorkUnit::default(), &guard)))
+            .expect("worker disconnected early");
+    }
+    drop(guard);
 
     for i in 0..(WORK_ITEMS * WORK_ITERS) {
         channels[i % channels.len()]
diff --git a/tests/ref.rs b/tests/ref.rs
index 3ff3b3b..6ca62c0 100644
--- a/tests/ref.rs
+++ b/tests/ref.rs
@@ -1,7 +1,6 @@
-use refuse::{collected, CollectionGuard, Ref};
+use refuse::{CollectionGuard, Ref};
 
 #[test]
-#[collected]
 fn lifecycle() {
     let mut guard = CollectionGuard::acquire();
     let collected = Ref::new(42_u32, &guard);
diff --git a/tests/root-clone.rs b/tests/root-clone.rs
index 348a94c..bdeb4af 100644
--- a/tests/root-clone.rs
+++ b/tests/root-clone.rs
@@ -1,7 +1,6 @@
-use refuse::{collected, CollectionGuard, Root};
+use refuse::{CollectionGuard, Root};
 
 #[test]
-#[collected]
 fn clone() {
     let mut guard = CollectionGuard::acquire();
     let root = Root::new(42_u32, &guard);
diff --git a/tests/root.rs b/tests/root.rs
index d791def..dab4579 100644
--- a/tests/root.rs
+++ b/tests/root.rs
@@ -1,7 +1,6 @@
-use refuse::{collected, CollectionGuard, Root};
+use refuse::{CollectionGuard, Root};
 
 #[test]
-#[collected]
 fn lifecycle() {
     let mut guard = CollectionGuard::acquire();
     let root = Root::new(42_u32, &guard);