SYMBOL INDEX (414 symbols across 17 files)

FILE: dumpster/src/impls.rs
  method accept (line 37) | fn accept(&self, _: &mut V) -> Result<(), ()> {
  function accept (line 44) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 85) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 91) | fn accept(&self, _: &mut V) -> Result<(), ()> {
  function accept (line 100) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 110) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 117) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 130) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 143) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 153) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 162) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 168) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 174) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 180) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 186) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 194) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 200) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 208) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 216) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 222) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 228) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 234) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 240) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 246) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 253) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 259) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 266) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 272) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 278) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 289) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 298) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 304) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 338) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function accept (line 349) | fn accept(&self, visitor: &mut Z) -> Result<(), ()> {
  function accept (line 361) | fn accept(&self, visitor: &mut Z) -> Result<(), ()> {
  function accept (line 370) | fn accept(&self, visitor: &mut Z) -> Result<(), ()> {
  function accept (line 381) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {

FILE: dumpster/src/lib.rs
  type TraceWithV (line 213) | pub unsafe trait TraceWithV: TraceWith<ContainsGcs> + TraceSync + TraceU...
  type Trace (line 296) | pub trait Trace: trace::TraceWithV {}
  type TraceWith (line 321) | pub unsafe trait TraceWith<V: Visitor> {
    method accept (line 339) | fn accept(&self, visitor: &mut V) -> Result<(), ()>;
  type Visitor (line 353) | pub trait Visitor {
    method visit_sync (line 358) | fn visit_sync<T>(&mut self, gc: &sync::Gc<T>)
    method visit_unsync (line 366) | fn visit_unsync<T>(&mut self, gc: &unsync::Gc<T>)
    method visit_sync (line 427) | fn visit_sync<T>(&mut self, _: &sync::Gc<T>)
    method visit_unsync (line 434) | fn visit_unsync<T>(&mut self, _: &unsync::Gc<T>)
  function contains_gcs (line 416) | fn contains_gcs<T: Trace + ?Sized>(x: &T) -> Result<bool, ()> {
  type ContainsGcs (line 424) | struct ContainsGcs(bool);
  function panic_deref_of_collected_object (line 445) | fn panic_deref_of_collected_object() -> ! {

FILE: dumpster/src/ptr.rs
  type Erased (line 24) | pub(crate) struct Erased([*const u8; 2]);
    method new (line 37) | pub fn new<T: ?Sized>(reference: NonNull<T>) -> Erased {
    method specify (line 64) | pub unsafe fn specify<T: ?Sized>(self) -> NonNull<T> {
    method fmt (line 81) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Nullable (line 89) | pub(crate) struct Nullable<T: ?Sized>(*mut T);
  function new (line 93) | pub fn new(ptr: NonNull<T>) -> Nullable<T> {
  function as_null (line 98) | pub fn as_null(self) -> Nullable<T> {
  function is_null (line 103) | pub fn is_null(self) -> bool {
  function as_option (line 108) | pub fn as_option(self) -> Option<NonNull<T>> {
  function as_ptr (line 113) | pub fn as_ptr(self) -> *mut T {
  function from_ptr (line 118) | pub fn from_ptr(ptr: *mut T) -> Self {
  function expect (line 124) | pub fn expect(self, msg: &str) -> NonNull<T> {
  function unwrap (line 129) | pub fn unwrap(self) -> NonNull<T> {
  function unwrap_unchecked (line 138) | pub unsafe fn unwrap_unchecked(self) -> NonNull<T> {
  method clone (line 144) | fn clone(&self) -> Self {
  function fmt (line 159) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function erased_alloc (line 172) | fn erased_alloc() {
  function erased_alloc_slice (line 184) | fn erased_alloc_slice() {
  function erased_alloc_dyn (line 199) | fn erased_alloc_dyn() {

FILE: dumpster/src/sync/cell.rs
  type UCell (line 20) | pub struct UCell<T>(UnsafeCell<T>);
  function new (line 24) | pub fn new(x: T) -> Self {
  function get (line 33) | pub unsafe fn get(&self) -> T
  function set (line 53) | pub unsafe fn set(&self, x: T) {

FILE: dumpster/src/sync/collect.rs
  type GarbageTruck (line 44) | struct GarbageTruck {
    method new (line 331) | const fn new() -> Self {
    method new (line 346) | fn new() -> Self {
    method collect_all (line 359) | fn collect_all(&self) {
  type Dumpster (line 65) | pub(super) struct Dumpster {
    method deliver_to (line 297) | fn deliver_to(&self, garbage_truck: &GarbageTruck) {
    method deliver_to_contents (line 304) | fn deliver_to_contents(&self, contents: &mut HashMap<AllocationId, Tra...
    method is_full (line 320) | fn is_full(&self) -> bool {
  type AllocationId (line 74) | pub(super) struct AllocationId(NonNull<GcBox<()>>);
    method from (line 685) | fn from(value: &GcBox<T>) -> Self {
    method from (line 694) | fn from(value: NonNull<GcBox<T>>) -> Self {
  type TrashCan (line 78) | pub(super) struct TrashCan {
  type AllocationInfo (line 88) | struct AllocationInfo {
  type Reachability (line 100) | enum Reachability {
  function collect_all_await (line 157) | pub fn collect_all_await() {
  function notify_dropped_gc (line 168) | pub fn notify_dropped_gc() {
  function notify_created_gc (line 197) | pub fn notify_created_gc() {
  function mark_dirty (line 208) | pub(super) unsafe fn mark_dirty<T>(allocation: NonNull<GcBox<T>>)
  function mark_clean (line 236) | pub(super) fn mark_clean<T>(allocation: &GcBox<T>)
  function deliver_dumpster (line 256) | pub(super) fn deliver_dumpster() {
  function set_collect_condition (line 278) | pub fn set_collect_condition(f: CollectCondition) {
  function n_gcs_dropped (line 285) | pub fn n_gcs_dropped() -> usize {
  function n_gcs_existing (line 290) | pub fn n_gcs_existing() -> usize {
  function dfs (line 447) | unsafe fn dfs<T: Trace + Send + Sync + ?Sized>(
  type Dfs (line 490) | pub(super) struct Dfs<'a> {
  method visit_sync (line 500) | fn visit_sync<T>(&mut self, gc: &Gc<T>)
  method visit_unsync (line 583) | fn visit_unsync<T>(&mut self, _: &crate::unsync::Gc<T>)
  function mark (line 593) | fn mark(root: AllocationId, graph: &mut HashMap<AllocationId, Allocation...
  type PrepareForDestruction (line 605) | pub(super) struct PrepareForDestruction<'a> {
  method visit_sync (line 612) | fn visit_sync<T>(&mut self, gc: &crate::sync::Gc<T>)
  method visit_unsync (line 635) | fn visit_unsync<T>(&mut self, _: &crate::unsync::Gc<T>)
  function destroy_erased (line 648) | unsafe fn destroy_erased<T: Trace + Send + Sync + ?Sized>(
  function drop_weak_zero (line 668) | unsafe fn drop_weak_zero<T: Trace + Send + Sync + ?Sized>(ptr: Erased) {
  method drop (line 701) | fn drop(&mut self) {

FILE: dumpster/src/sync/loom_ext.rs
  type Mutex (line 29) | pub struct Mutex<T: ?Sized>(MutexImpl<T>);
  function accept (line 32) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function new (line 46) | pub fn new(value: T) -> Self {
  function lock (line 51) | pub fn lock(&self) -> MutexGuard<'_, T> {
  function is_locked (line 57) | pub fn is_locked(&self) -> bool {
  type RwLock (line 63) | pub struct RwLock<T>(RwLockImpl<T>);
  function new (line 67) | pub fn new(value: T) -> Self {
  function read (line 72) | pub fn read(&self) -> RwLockReadGuard<'_, T> {
  function write (line 77) | pub fn write(&self) -> RwLockWriteGuard<'_, T> {
  type Once (line 83) | struct Once {
    method new (line 90) | fn new() -> Self {
    method call_once (line 97) | fn call_once(&self, f: impl FnOnce()) {
    method is_completed (line 109) | fn is_completed(&self) -> bool {
  type OnceLock (line 115) | pub struct OnceLock<T> {
  function accept (line 126) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function new (line 133) | pub fn new() -> Self {
  function with_unchecked (line 141) | unsafe fn with_unchecked<R>(&self, f: impl FnOnce(&T) -> R) -> R {
  function with (line 147) | pub fn with<R>(&self, f: impl FnOnce(&T) -> R) -> Option<R> {
  function with_or_init (line 156) | pub fn with_or_init<R>(&self, init: impl FnOnce() -> T, f: impl FnOnce(&...
  function set (line 167) | pub fn set(&self, value: T) {
  function test_once (line 173) | fn test_once() {
  function test_once_lock (line 205) | fn test_once_lock() {

FILE: dumpster/src/sync/loom_tests.rs
  type DropCount (line 20) | struct DropCount<'a>(&'a AtomicUsize);
  method drop (line 23) | fn drop(&mut self) {
  function accept (line 29) | fn accept(&self, _: &mut V) -> Result<(), ()> {
  type MultiRef (line 34) | struct MultiRef {
    method accept (line 41) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function loom_single_alloc (line 47) | fn loom_single_alloc() {
  function loom_self_referential (line 64) | fn loom_self_referential() {
  function loom_two_cycle (line 96) | fn loom_two_cycle() {
  function loom_sync_leak_by_creation_in_drop (line 130) | fn loom_sync_leak_by_creation_in_drop() {

FILE: dumpster/src/sync/mod.rs
  constant MAX_STRONG_COUNT (line 80) | const MAX_STRONG_COUNT: usize = (isize::MAX) as usize;
  type TraceSync (line 84) | pub(crate) trait TraceSync:
  type Gc (line 132) | pub struct Gc<T: Trace + Send + Sync + ?Sized + 'static> {
  type GcBox (line 153) | pub struct GcBox<T>
  function collect (line 191) | pub fn collect() {
  type CollectInfo (line 214) | pub struct CollectInfo {
    method n_gcs_dropped_since_last_collect (line 948) | pub fn n_gcs_dropped_since_last_collect(&self) -> usize {
    method n_gcs_existing (line 967) | pub fn n_gcs_existing(&self) -> usize {
  type CollectCondition (line 233) | pub type CollectCondition = fn(&CollectInfo) -> bool;
  function default_collect_condition (line 262) | pub fn default_collect_condition(info: &CollectInfo) -> bool {
  function new (line 281) | pub fn new(value: T) -> Gc<T>
  function new_cyclic (line 334) | pub fn new_cyclic<F: FnOnce(Self) -> T>(data_fn: F) -> Self
  function try_deref (line 465) | pub fn try_deref(gc: &Gc<T>) -> Option<&T> {
  function try_clone (line 507) | pub fn try_clone(gc: &Gc<T>) -> Option<Gc<T>> {
  function as_ptr (line 528) | pub fn as_ptr(gc: &Gc<T>) -> *const T {
  function ptr_eq (line 551) | pub fn ptr_eq(this: &Gc<T>, other: &Gc<T>) -> bool {
  function ref_count (line 577) | pub fn ref_count(gc: &Self) -> NonZeroUsize {
  function is_dead (line 613) | pub fn is_dead(gc: &Self) -> bool {
  function into_ptr (line 620) | fn into_ptr(this: Self) -> (*const GcBox<T>, usize) {
  function from_ptr (line 631) | unsafe fn from_ptr(ptr: *const GcBox<T>, tag: usize) -> Self {
  function kill (line 644) | unsafe fn kill(&self) {
  function __private_into_ptr (line 652) | pub fn __private_into_ptr(this: Self) -> (*const GcBox<T>, usize) {
  function __private_from_ptr (line 660) | pub unsafe fn __private_from_ptr(ptr: *const GcBox<T>, tag: usize) -> Se...
  type Rehydrate (line 668) | pub(super) struct Rehydrate {
  method visit_sync (line 676) | fn visit_sync<T>(&mut self, gc: &Gc<T>)
  method visit_unsync (line 703) | fn visit_unsync<T>(&mut self, _: &crate::unsync::Gc<T>)
  function make_mut (line 743) | pub fn make_mut(this: &mut Self) -> &mut T {
  method clone (line 850) | fn clone(&self) -> Gc<T> {
  method drop (line 892) | fn drop(&mut self) {
  function allocate_for_layout (line 978) | unsafe fn allocate_for_layout(
  function allocate_for_layout_of_box (line 995) | unsafe fn allocate_for_layout_of_box(
  function allocate_for_slice (line 1020) | fn allocate_for_slice(len: usize) -> *mut GcBox<[T]> {
  function accept (line 1030) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  type Target (line 1037) | type Target = T;
  method deref (line 1082) | fn deref(&self) -> &Self::Target {
  function eq (line 1124) | fn eq(&self, other: &Gc<T>) -> bool {
  function as_ref (line 1132) | fn as_ref(&self) -> &T {
  function borrow (line 1138) | fn borrow(&self) -> &T {
  method default (line 1144) | fn default() -> Self {
  function fmt (line 1150) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 1165) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 1183) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 1202) | fn from(value: T) -> Self {
  function from (line 1221) | fn from(v: [T; N]) -> Gc<[T]> {
  function from (line 1238) | fn from(slice: &[T]) -> Gc<[T]> {
  function from (line 1318) | fn from(value: &mut [T]) -> Self {
  function from (line 1334) | fn from(v: &str) -> Self {
  function from (line 1354) | fn from(v: &mut str) -> Self {
  function from (line 1371) | fn from(value: Gc<str>) -> Self {
  function from (line 1389) | fn from(value: String) -> Self {
  function from (line 1406) | fn from(src: Box<T>) -> Self {
  function from (line 1441) | fn from(vec: Vec<T>) -> Self {
  function from (line 1479) | fn from(cow: Cow<'a, B>) -> Gc<B> {
  function from_iter (line 1491) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {

FILE: dumpster/src/sync/tests.rs
  type DropCount (line 25) | struct DropCount<'a>(&'a AtomicUsize);
  method drop (line 28) | fn drop(&mut self) {
  function accept (line 34) | fn accept(&self, _: &mut V) -> Result<(), ()> {
  type MultiRef (line 39) | struct MultiRef {
    method accept (line 46) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function single_alloc (line 52) | fn single_alloc() {
  function ref_count (line 64) | fn ref_count() {
  function self_referential (line 77) | fn self_referential() {
  function two_cycle (line 104) | fn two_cycle() {
  function self_ref_two_cycle (line 132) | fn self_ref_two_cycle() {
  function parallel_loop (line 161) | fn parallel_loop() {
  function deadlock (line 218) | fn deadlock() {
  function open_drop (line 229) | fn open_drop() {
  function eventually_collect (line 249) | fn eventually_collect() {
  function coerce_array (line 281) | fn coerce_array() {
  function coerce_array_using_macro (line 292) | fn coerce_array_using_macro() {
  function malicious (line 303) | fn malicious() {
  function fuzz (line 379) | fn fuzz() {
  function root_canal (line 504) | fn root_canal() {
  function escape_dead_pointer (line 621) | fn escape_dead_pointer() {
  function from_box (line 656) | fn from_box() {
  function from_slice (line 673) | fn from_slice() {
  function from_slice_panic (line 691) | fn from_slice_panic() {
  function from_vec (line 733) | fn from_vec() {
  function make_mut (line 750) | fn make_mut() {
  function make_mut_2 (line 774) | fn make_mut_2() {
  function make_mut_of_object_in_dumpster (line 797) | fn make_mut_of_object_in_dumpster() {
  function panic_visit (line 835) | fn panic_visit() {
  function sync_leak_by_creation_in_drop (line 855) | fn sync_leak_by_creation_in_drop() {
  function custom_trait_object (line 901) | fn custom_trait_object() {
  function new_cyclic_simple (line 911) | fn new_cyclic_simple() {
  function panic_new_cyclic (line 925) | fn panic_new_cyclic() {
  function gc_from_iter (line 930) | fn gc_from_iter() {
  function self_referential_from_iter (line 935) | fn self_referential_from_iter() {

FILE: dumpster/src/unsync/collect.rs
  type Dumpster (line 44) | pub(super) struct Dumpster {
    method collect_all (line 114) | pub fn collect_all(&self) {
    method mark_dirty (line 183) | pub fn mark_dirty<T: Trace + ?Sized>(&self, box_ptr: NonNull<GcBox<T>>) {
    method mark_cleaned (line 192) | pub fn mark_cleaned<T: Trace + ?Sized>(&self, box_ptr: NonNull<GcBox<T...
    method notify_dropped_gc (line 201) | pub fn notify_dropped_gc(&self) {
    method notify_created_gc (line 219) | pub fn notify_created_gc(&self) {
  type AllocationId (line 60) | struct AllocationId(pub NonNull<Cell<NonZeroUsize>>);
    method from (line 67) | fn from(value: NonNull<GcBox<T>>) -> Self {
  type Cleanup (line 75) | struct Cleanup {
    method new (line 102) | fn new<T: Trace + ?Sized>(box_ptr: NonNull<GcBox<T>>) -> Cleanup {
  method drop (line 225) | fn drop(&mut self) {
  type Dfs (line 232) | pub(super) struct Dfs {
  type Reachability (line 241) | struct Reachability {
  method visit_sync (line 252) | fn visit_sync<T>(&mut self, _: &crate::sync::Gc<T>)
  method visit_unsync (line 260) | fn visit_unsync<T>(&mut self, gc: &Gc<T>)
  type Mark (line 288) | pub(super) struct Mark {
  method visit_sync (line 294) | fn visit_sync<T>(&mut self, _: &crate::sync::Gc<T>)
  method visit_unsync (line 302) | fn visit_unsync<T>(&mut self, gc: &Gc<T>)
  type DropAlloc (line 317) | pub(super) struct DropAlloc<'a> {
  method visit_sync (line 325) | fn visit_sync<T>(&mut self, _: &crate::sync::Gc<T>)
  method visit_unsync (line 332) | fn visit_unsync<T>(&mut self, gc: &Gc<T>)
  function drop_assist (line 366) | unsafe fn drop_assist<T: Trace + ?Sized>(ptr: Erased, visitor: &mut Drop...

FILE: dumpster/src/unsync/mod.rs
  type TraceUnsync (line 59) | pub(crate) trait TraceUnsync:
  type Gc (line 101) | pub struct Gc<T: Trace + ?Sized + 'static> {
  function collect (line 139) | pub fn collect() {
  type CollectInfo (line 145) | pub struct CollectInfo {
    method n_gcs_dropped_since_last_collect (line 1030) | pub fn n_gcs_dropped_since_last_collect(&self) -> usize {
    method n_gcs_existing (line 1049) | pub fn n_gcs_existing(&self) -> usize {
  type CollectCondition (line 164) | pub type CollectCondition = fn(&CollectInfo) -> bool;
  function default_collect_condition (line 185) | pub fn default_collect_condition(info: &CollectInfo) -> bool {
  function set_collect_condition (line 207) | pub fn set_collect_condition(f: CollectCondition) {
  type GcBox (line 215) | pub struct GcBox<T: Trace + ?Sized> {
  function new (line 232) | pub fn new(value: T) -> Gc<T>
  function new_cyclic (line 282) | pub fn new_cyclic<F: FnOnce(Gc<T>) -> T>(data_fn: F) -> Self
  function try_deref (line 406) | pub fn try_deref(gc: &Gc<T>) -> Option<&T> {
  function try_clone (line 450) | pub fn try_clone(gc: &Gc<T>) -> Option<Gc<T>> {
  function as_ptr (line 471) | pub fn as_ptr(gc: &Gc<T>) -> *const T {
  function ptr_eq (line 492) | pub fn ptr_eq(this: &Gc<T>, other: &Gc<T>) -> bool {
  function ref_count (line 518) | pub fn ref_count(gc: &Self) -> NonZeroUsize {
  function is_dead (line 551) | pub fn is_dead(gc: &Self) -> bool {
  function into_ptr (line 558) | fn into_ptr(this: Self) -> *const GcBox<T> {
  function from_ptr (line 566) | unsafe fn from_ptr(ptr: *const GcBox<T>) -> Self {
  function __private_into_ptr (line 576) | pub fn __private_into_ptr(this: Self) -> *const GcBox<T> {
  function __private_from_ptr (line 584) | pub unsafe fn __private_from_ptr(ptr: *const GcBox<T>) -> Self {
  function kill (line 589) | fn kill(&self) {
  type Rehydrate (line 597) | pub(super) struct Rehydrate {
  method visit_sync (line 605) | fn visit_sync<T>(&mut self, _: &crate::sync::Gc<T>)
  method visit_unsync (line 611) | fn visit_unsync<T>(&mut self, gc: &Gc<T>)
  function make_mut (line 667) | pub fn make_mut(this: &mut Self) -> &mut T {
  function allocate_for_layout (line 699) | unsafe fn allocate_for_layout(
  function allocate_for_layout_of_box (line 716) | unsafe fn allocate_for_layout_of_box(
  function allocate_for_slice (line 740) | fn allocate_for_slice(len: usize) -> *mut GcBox<[T]> {
  type Target (line 790) | type Target = T;
  method deref (line 837) | fn deref(&self) -> &Self::Target {
  method clone (line 884) | fn clone(&self) -> Self {
  method drop (line 911) | fn drop(&mut self) {
  function eq (line 1006) | fn eq(&self, other: &Gc<T>) -> bool {
  function accept (line 1055) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  function as_ref (line 1062) | fn as_ref(&self) -> &T {
  function borrow (line 1068) | fn borrow(&self) -> &T {
  method default (line 1074) | fn default() -> Self {
  function fmt (line 1080) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 1101) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 1120) | fn from(value: T) -> Self {
  function from (line 1139) | fn from(v: [T; N]) -> Gc<[T]> {
  function from (line 1156) | fn from(slice: &[T]) -> Gc<[T]> {
  function from (line 1235) | fn from(value: &mut [T]) -> Self {
  function from (line 1251) | fn from(v: &str) -> Self {
  function from (line 1270) | fn from(v: &mut str) -> Self {
  function from (line 1287) | fn from(value: Gc<str>) -> Self {
  function from (line 1304) | fn from(value: String) -> Self {
  function from (line 1321) | fn from(src: Box<T>) -> Self {
  function from (line 1356) | fn from(vec: Vec<T>) -> Self {
  function from (line 1394) | fn from(cow: Cow<'a, B>) -> Gc<B> {
  function from_iter (line 1406) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {

FILE: dumpster/src/unsync/tests.rs
  type DropCount (line 26) | struct DropCount(&'static AtomicUsize);
    method accept (line 35) | fn accept(&self, _: &mut V) -> Result<(), ()> {
  method drop (line 29) | fn drop(&mut self) {
  function simple (line 42) | fn simple() {
  type MultiRef (line 73) | struct MultiRef {
    method accept (line 79) | fn accept(&self, visitor: &mut V) -> Result<(), ()> {
  method drop (line 85) | fn drop(&mut self) {
  function self_referential (line 91) | fn self_referential() {
  function cyclic (line 118) | fn cyclic() {
  function complete_graph (line 148) | fn complete_graph(detectors: &'static [AtomicUsize]) -> Vec<Gc<MultiRef>> {
  function complete4 (line 166) | fn complete4() {
  function parallel_loop (line 193) | fn parallel_loop() {
  function double_borrow (line 246) | fn double_borrow() {
  function coerce_array (line 267) | fn coerce_array() {
  function coerce_array_using_macro (line 278) | fn coerce_array_using_macro() {
  function escape_dead_pointer (line 290) | fn escape_dead_pointer() {
  function from_box (line 327) | fn from_box() {
  function from_slice (line 340) | fn from_slice() {
  function from_slice_panic (line 354) | fn from_slice_panic() {
  function from_vec (line 396) | fn from_vec() {
  function make_mut (line 409) | fn make_mut() {
  function make_mut_2 (line 433) | fn make_mut_2() {
  function make_mut_of_object_in_dumpster (line 456) | fn make_mut_of_object_in_dumpster() {
  function panic_visit (line 494) | fn panic_visit() {
  function new_cyclic_nothing (line 513) | fn new_cyclic_nothing() {
  function new_cyclic_one (line 523) | fn new_cyclic_one() {
  function new_cyclic_panic (line 544) | fn new_cyclic_panic() {
  function dead_inside_alive (line 549) | fn dead_inside_alive() {
  function leak_by_creation_in_drop (line 583) | fn leak_by_creation_in_drop() {
  function unsync_fuzz (line 625) | fn unsync_fuzz() {
  function custom_trait_object (line 748) | fn custom_trait_object() {
  function gc_from_iter (line 758) | fn gc_from_iter() {
  function self_referential_from_iter (line 763) | fn self_referential_from_iter() {

FILE: dumpster_bench/scripts/make_plots.py
  function violin (line 45) | def violin(times: dict, name: str):

FILE: dumpster_bench/src/lib.rs
  type Multiref (line 21) | pub trait Multiref: Clone {
    method new (line 23) | fn new(points_to: Vec<Self>) -> Self;
    method apply (line 25) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>));
    method collect (line 27) | fn collect();
    method new (line 137) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 143) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 147) | fn collect() {
    method new (line 153) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 159) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 163) | fn collect() {
    method new (line 169) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 175) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 179) | fn collect() {
    method new (line 185) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 191) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 195) | fn collect() {
    method new (line 202) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 208) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 212) | fn collect() {
    method new (line 218) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 224) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 228) | fn collect() {
    method new (line 234) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 240) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 244) | fn collect() {
    method new (line 250) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 254) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 258) | fn collect() {
    method new (line 264) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 270) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 274) | fn collect() {
    method new (line 280) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 286) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 290) | fn collect() {}
    method new (line 294) | fn new(points_to: Vec<Self>) -> Self {
    method apply (line 300) | fn apply(&self, f: impl FnOnce(&mut Vec<Self>)) {
    method collect (line 304) | fn collect() {}
  type SyncMultiref (line 31) | pub trait SyncMultiref: Send + Sync + Multiref {}
  type RcMultiref (line 37) | pub struct RcMultiref {
  type ArcMultiref (line 43) | pub struct ArcMultiref {
  type DumpsterSyncMultiref (line 48) | pub struct DumpsterSyncMultiref {
  type DumpsterUnsyncMultiref (line 53) | pub struct DumpsterUnsyncMultiref {
  type GcMultiref (line 57) | pub struct GcMultiref {
    method trace (line 85) | unsafe fn trace(&self) {
    method root (line 90) | unsafe fn root(&self) {
    method unroot (line 95) | unsafe fn unroot(&self) {
    method finalize_glue (line 100) | fn finalize_glue(&self) {
  type BaconRajanMultiref (line 61) | pub struct BaconRajanMultiref {
    method trace (line 76) | fn trace(&self, tracer: &mut bacon_rajan_cc::Tracer) {
  type ShredderMultiref (line 66) | pub struct ShredderMultiref {
  type ShredderSyncMultiref (line 71) | pub struct ShredderSyncMultiref {
  type RustCcMultiRef (line 106) | pub struct RustCcMultiRef {
    method trace (line 111) | fn trace(&self, ctx: &mut rust_cc::Context<'_>) {
  type TracingRcUnsyncMultiRef (line 116) | pub struct TracingRcUnsyncMultiRef {
    method visit_children (line 121) | fn visit_children(&self, visitor: &mut tracing_rc::rc::GcVisitor) {
  type TracingRcSyncMultiRef (line 126) | pub struct TracingRcSyncMultiRef {
    method visit_children (line 131) | fn visit_children(&self, visitor: &mut tracing_rc::sync::GcVisitor) {

FILE: dumpster_bench/src/main.rs
  type BenchmarkData (line 28) | struct BenchmarkData {
  method fmt (line 37) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function unsync_never_collect (line 50) | fn unsync_never_collect(_: &dumpster::unsync::CollectInfo) -> bool {
  function sync_never_collect (line 54) | fn sync_never_collect(_: &dumpster::sync::CollectInfo) -> bool {
  function main (line 58) | fn main() {
  function single_threaded (line 189) | fn single_threaded<M: Multiref>(name: &'static str, n_iters: usize) -> B...
  function multi_threaded (line 249) | fn multi_threaded<M: SyncMultiref>(

FILE: dumpster_derive/src/lib.rs
  function derive_trace (line 23) | pub fn derive_trace(input: proc_macro::TokenStream) -> proc_macro::Token...
  function add_trait_bounds (line 88) | fn add_trait_bounds(dumpster: &Path, mut generics: Generics) -> Generics {
  function delegate_methods (line 101) | fn delegate_methods(dumpster: &Path, name: &Ident, data: &Data) -> Token...

FILE: dumpster_test/src/lib.rs
  type Empty (line 23) | struct Empty;
  type UnitTuple (line 27) | struct UnitTuple();
  type MultiRef (line 30) | struct MultiRef {
  type Refs (line 37) | enum Refs {
  type A (line 45) | enum A {
  type B (line 51) | enum B {
  type Generic (line 57) | struct Generic<T> {
  method drop (line 62) | fn drop(&mut self) {
  function unit (line 68) | fn unit() {
  function self_referential (line 89) | fn self_referential() {
  function double_loop (line 105) | fn double_loop() {
  function parallel_loop (line 123) | fn parallel_loop() {
  function unsync_as_ptr (line 164) | fn unsync_as_ptr() {