Dependency Analysis
This page contains the raw data and dependency mappings generated during the initial static analysis of the alloc crate. This data was used to isolate the compiler’s missing pieces and construct the “mock core” needed for testing.
Note
Click on the sections below to expand and view the raw data.
First, I identified which core structures each alloc file uses to establish a baseline of requirements.
Core Dependencies by File
#![allow(unused)]
fn main() {
// lib.rs
pub use core::format_args; // built-in
pub use core::ops; // RangeFull
// alloc.rs
use core::intrinsics::{min_align_of_val, size_of_val, assume};
use core::ptr::{ NonNull, Unique, copy_nonoverlapping };
pub use core::alloc::*;
panic!
debug_assert!
#[lang = "oom"];
#[rustc_std_internal_symbol]
#[rustc_allocator]
#[rustc_allocator_nounwind]
#[lang = "exchange_malloc"]
// borrow.rs
use core::cmp::Ordering;
use core::hash::{Hash, Hasher};
use core::ops::{Add, AddAssign, Deref};
pub use core::borrow::{Borrow, BorrowMut};
unrachable!
// boxed.rs
use core::any::Any;
use core::borrow::{Borrow, BorrowMut};
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Display, Debug,Formatter, Result,Pointer};
use core::future::Future;
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator, Iterator};
use core::marker::{Unpin, Unsize};
use core::mem::{ManuallyDrop,MaybeUninit};
use core::ops::{
CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Generator, GeneratorState, Receiver,
};
use core::pin::Pin;
use core::ptr::{read,copy_nonoverlapping, Unique};
use core::task::{Context, Poll};
#[lang = "owned_box"]
#[fundamental]
// fmt.rs
pub use core::fmt::rt; // ? non-used
pub use core::fmt::Alignment;
pub use core::fmt::Error;
pub use core::fmt::{write, ArgumentV1, Arguments};
pub use core::fmt::{Binary, Octal};
pub use core::fmt::{Debug, Display};
pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
pub use core::fmt::{Formatter, Result, Write};
pub use core::fmt::{LowerExp, UpperExp};
pub use core::fmt::{LowerHex, Pointer, UpperHex};
// macros.rs
macro_rules!
#[macro_export]
// raw_vec.rs
use core::alloc::LayoutErr;
use core::cmp::{max};
use core::intrinsics::{assume};
use core::mem::{size_of,align_of, ManuallyDrop, MaybeUninit};
use core::ops::Drop;
use core::ptr::{read, NonNull, Unique};
use core::slice::from_raw_parts_mut;
debug_assert_ne!
debug_assert!
assert!
debug_assert_eq!
panic!
#[may_dangle]
// rc.rs
use core::any::Any;
use core::borrow::Borrow;
use core::cell::Cell;
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Display, Debug,Formatter, Result,Pointer};
use core::hash::{Hash, Hasher};
use core::intrinsics::abort;
use core::iter::{FromIterator,IntoIterator,TrustedLen,Iterator};
use core::marker::{Send,Sync, PhantomData, Unpin, Unsize};
use core::mem::{MaybeUninit,forget,ManuallyDrop,swap, align_of_val_raw, forget, size_of_val};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{read,drop_in_place,write,copy_nonoverlapping,slice_from_raw_parts_mut, NonNull};
use core::slice::from_raw_parts_mut;
debug_assert_eq!
write!
#[repr(C)]
#[may_dangle]
#[rustc_unsafe_specialization_marker]
// slice.rs
use core::borrow::{Borrow, BorrowMut};
use core::cmp::Ordering;
use core::cmp::Ordering::Less;
use core::mem::{size_of, ManuallyDrop};
use core::ptr::{copy_nonoverlapping,read};
pub use core::slice::ArrayChunks;
pub use core::slice::ArrayChunksMut;
pub use core::slice::ArrayWindows;
pub use core::slice::SliceIndex;
pub use core::slice::{from_mut, from_ref};
pub use core::slice::{from_raw_parts, from_raw_parts_mut};
pub use core::slice::{Chunks, Windows};
pub use core::slice::{ChunksExact, ChunksExactMut};
pub use core::slice::{ChunksMut, Split, SplitMut};
pub use core::slice::{Iter, IterMut};
pub use core::slice::{RChunks, RChunksExact, RChunksExactMut, RChunksMut};
pub use core::slice::{RSplit, RSplitMut};
pub use core::slice::{RSplitN, RSplitNMut, SplitN, SplitNMut};
sort_by_key! __not_core!
#[lang = "slice_u8_alloc"]
#[lang = "slice_alloc"]
#[derive(Clone, Copy)]
#[rustc_conversion_suggestion]
// str.rs
use core::borrow::{Borrow, BorrowMut};
use core::iter::FusedIterator;
use core::mem::{take};
use core::ptr; // ? non-used
use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
use core::unicode::conversions::{to_lower,to_upper};
pub use core::str::pattern;
pub use core::str::EncodeUtf16;
pub use core::str::SplitAsciiWhitespace;
pub use core::str::SplitWhitespace;
pub use core::str::{from_utf8, from_utf8_mut, Bytes, CharIndices, Chars};
pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError};
pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode};
pub use core::str::{FromStr, Utf8Error};
pub use core::str::{Lines, LinesAny};
pub use core::str::{MatchIndices, RMatchIndices};
pub use core::str::{Matches, RMatches};
pub use core::str::{RSplit, Split};
pub use core::str::{RSplitN, SplitN};
pub use core::str::{RSplitTerminator, SplitTerminator};
use core::unicode::derived_property::{Case_Ignorable, Cased};
debug_assert!
spezialize_for_lengths! __not_core!
assert!
copy_slice_and_advance! __not_core!
#[lang = "str_alloc"]
// string.rs
use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
use core::fmt::{Formatter,Debug,Result,Display,Write};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index,Range,RangeTo,RangeFrom,RangeFull,RangeInclusive,RangeToInclusive,IndexMut,Deref,DerefMut, Add, AddAssign, Index, IndexMut, Range, RangeBounds};
use core::ptr::copy;
use core::str::{lossy, pattern::Pattern};
core::convert::Infallible;
panic!
debug_assert!
assert!
format_args!
#[rustc_conversion_suggestion]
#[derive(Debug, Clone, PartialEq, Eq,)]
#[derive(PartialOrd, Ord)]
// sync.rs
use core::any::Any;
use core::borrow::Borrow;
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Pointer,Formatter,Result,Debug,Result};
use core::hash::{Hash, Hasher};
use core::hint::spin_loop;
use core::intrinsics::abort;
use core::iter::{Iterator,FromIterator,IntoIterator, TrustedLen};
use core::marker::{PhantomData, Unpin, Unsize};
use core::mem::{swap,drop,MaybeUninit,forget,ManuallyDrop, align_of_val, size_of_val};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{write,drop_in_place,read,copy_nonoverlapping,slice_from_raw_parts_mut, NonNull};
use core::slice::from_raw_parts_mut;
use core::sync::atomic::{fence,AtamicUsize};
use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst};
write!
debug_assert_eq!
acquire! __non_core!
debug_assert!
#[may_dangle]
#[repr(C)]
// task.rs
use core::mem::ManuallyDrop;
use core::task::{RawWaker, RawWakerVTable, Waker};
// vec.rs
use core::cmp::{max, Ordering};
use core::convert::TryFrom;
use core::fmt::{Debug,Formatter,Result,Display};
use core::hash::{Hash, Hasher};
use core::intrinsics::{arith_offset, assume};
use core::iter::{ FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess };
use core::marker::PhantomData;
use core::mem::{size_of,zeroed,forget,replace,align_of, ManuallyDrop, MaybeUninit};
use core::ops::{DerefMut,Deref, Index, IndexMut, Range, RangeBounds};
use core::ptr::{replace,copy,write,read,write_bytes ,copy_nonoverlapping ,slice_from_raw_parts_mut,drop_in_place, NonNull};
use core::slice::{from_raw_parts_mut,from_raw_parts,to_vec,into_vec,Iter,IterMut,, SliceIndex};
debug_assert!
panic!
impl_is_zero! __not_core!
debug_assert_eq!
macro_rules!
#[derive(Debug)]
#[rustc_specialization_trait]
#[rustc_unsafe_specialization_marker]
#[cold]
// collections/mod.rs
use core::fmt::Display;
core::result::Result;
core::fmt::Error
// collections/linked_list.rs
use core::cmp::Ordering;
use core::fmt::{Debug,Formatter, Result};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{forget,replace,swap,take,};
use core::ptr::NonNull;
core::hint::unreachable_unchecked()
assert!
#[may_dangle]
// collections/vec_deque.rs
use core::array::IntoIter;
use core::cmp::{min,max,, Ordering};
use core::fmt::{Debug,Formatter, Result};
use core::hash::{Hash, Hasher};
use core::iter::{repeat_with, FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{size_of, replace, ManuallyDrop};
use core::ops::{Index, IndexMut, Range, RangeBounds, Try};
use core::ptr::{drop_in_place,read,write,copy,copy_nonoverlapping,swap,slice_from_raw_parts_mut, NonNull};
use core::slice::{from_raw_parts_mut,from_raw_parts};
core::mem::size_of
macro_rules!
debug_assert_eq!
assert!
debug_assert!
#[may_dangle]
#[derive(Clone)]
// collections/vec_deque/drain.rs
use core::iter::FusedIterator;
use core::ptr::{NonNull,read,};
use core::fmt::{Debug,Formatter, Result};
use core::mem::forget;
// collections/btree/append.rs
use core::iter::FusedIterator;
unrachable!
// collections/btree/borrow.rs
use core::marker::PhantomData;
use core::ptr::NonNull;
// collections/btree/map.rs
use core::borrow::Borrow;
use core::cmp::Ordering;
use core::fmt::{Debug,Formatter,Result};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{replace,swap,take,forget, ManuallyDrop};
use core::ops::{Index, RangeBounds};
use core::ptr::read;
unreachable!
#[may_dangle]
#[derive(Debug)]
// collections/btree/map/entry.rs
use core::fmt::{Result,Formatter, Debug};
use core::marker::PhantomData;
use core::mem::replace;
// collections/btree/mem.rs
use core::intrinsics::abort;
use core::mem::forget;
use core::ptr::{read,write};
// collections/btree/merge_iter.rs
use core::cmp::Ordering;
use core::fmt::{Formatter,Result, Debug};
use core::iter::FusedIterator;
#[derive(Clone, Debug)]
// collections/btree/mod.rs
core::intrinsics::unreachable();
cfg!
panic!
// collections/btree/navigate.rs
use core::borrow::Borrow;
use core::cmp::Ordering;
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::RangeBounds;
use core::ptr::read;
panic!
unreachable!
// collections/btree/node.rs
use core::cmp::Ordering;
use core::marker::PhantomData;
use core::mem::{replace, MaybeUninit};
use core::ptr::{read,copy,copy_nonoverlapping, NonNull, Unique};
use core::marker::PhantomData;
assert!
unreachable!
debug_assert!
debug_assert_eq!
#[repr(C)]
// collections/btree/remove.rs
use core::mem::replace;
use core::ptr::read;
unreachable!
// collections/btree/search.rs
use core::borrow::Borrow;
use core::cmp::Ordering;
// collections/btree/set.rs
use core::borrow::Borrow;
use core::cmp::Ordering::{Equal, Greater, Less};
use core::cmp::{max, min};
use core::fmt::{Formatter,Result, Debug};
use core::iter::{FromIterator, FusedIterator, Peekable};
use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub};
#[derive(Debug)]
// collections/btree/split.rs
use core::borrow::Borrow;
debug_assert!
unreachable!
// collections/binary_heap.rs
use core::fmt::{Debug,Formatter, Result};
use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen};
use core::mem::{forget, swap, ManuallyDrop};
use core::ops::{Deref, DerefMut};
use core::ptr::{swap,read,copy_nonoverlapping};
debug_assert!
#[derive(Clone, Debug)]
}The initial raw list contained significant repetition and was difficult to track. Furthermore, it didn’t distinguish between features already supported by the compiler and those that were missing.
To resolve this, I analyzed the internal dependencies within alloc itself. By grouping interdependent files together and deduplicating the required structures, I created a much cleaner recipe. I then cross-referenced this recipe against the gccrs codebase to check off the structures that were already supported.
Result
// lib.rs
pub use core::format_args; ok
pub use core::ops; ok
// target files
1 | alloc.rs
5 | macros.rs
22 | collections/btree/borrow.rs
25 | collections/btree/mem.rs
26 | collections/btree/merge_iter.rs
-----------------------------------------------------------
// use statements
pub use core::alloc::*; ok
core::intrinsics::min_align_of_val; !intrinsic
core::intrinsics::size_of_val; !intrinsic
core::intrinsics::assume; ok
core::ptr::NonNull; ok
core::ptr::Unique; ok
core::ptr::copy_nonoverlapping; #1 ok
core::marker::PhantomData; #22 ok
core::intrinsics::abort; ok
core::mem::forget; ok
core::ptr::read; ok
core::ptr::write; #25 ok
core::cmp::Ordering; ok
core::fmt::Formatter ok
core::fmt::Result; ok
core::fmt::Debug; ok
core::iter::FusedIterator; #26 ok
-----------------------------------------------------------
// macros
panic! ok
debug_assert! #1 ok
macro_rules! #5 ok
-----------------------------------------------------------
// lang items
#[lang = "box_free"] !
#[lang = "oom"]; !
#[lang = "exchange_malloc"] #1 !
-----------------------------------------------------------
// derive macros
#[derive(Clone)] ok
#[derive(Debug)] #26 ok
-----------------------------------------------------------
// attributes
#[rustc_allocator] !
#[rustc_allocator_nounwind] !
#[rustc_std_internal_symbol] #1 !
7 | rc.rs
16 | prelude/v1.rs
24 | collections/btree/map/entry.rs
34 | collections/binary_heap.rs
-----------------------------------------------------------
core::cell::Cell; ok
core::iter::IntoIterator; ok
core::marker::Send; ok
core::marker::Sync; ok
core::mem::align_of_val_raw; !intrinsic
core::mem::size_of_val; #7 !intrinsic
-----------------------------------------------------------
write! ok
2 | borrow.rs
3 | boxed.rs
4 | fmt.rs
6 | raw_vec.rs
8 | slice.rs
9 | str.rs
10 | string.rs
14 | vec.rs
17 | collections/mod.rs
18 | collections/linked_list.rs
19 | collections/vec_deque.rs
20 | collections/vec_deque/drain.rs
21 | collections/append.rs
23 | collections/map.rs
27 | collections/btree/mod.rs
28 | collections/btree/navigate.rs
29 | collections/btree/node.rs
30 | collections/btree/remove.rs
31 | collections/btree/search.rs
32 | collections/btree/set.rs
33 | collections/btree/split.rs
-----------------------------------------------------------
core::borrow::Borrow; ok
core::borrow::BorrowMut; ok
core::hash::Hash; ok
core::hash::Hasher; ok
core::ops::Add; ok
core::ops::AddAssign; ok
core::ops::Deref; ok
core::any::Any; ok
core::convert::From; ok
core::convert::TryFrom; ok
core::fmt::Display; ok
core::fmt::Debug; ok
core::fmt::Pointer; ok
core::future::Future; !lang
core::iter::FromIterator; ok
core::iter::Iterator; ok
core::marker::Unpin; !lang
core::marker::Unsize; !lang
core::mem::ManuallyDrop; ok
core::mem::MaybeUninit; !lang
core::ops::DerefMut; ok
core::ops::DispatchFromDyn; !lang
core::ops::Generator; !lang
core::ops::GeneratorState; !lang
core::ops::Receiver; ok
core::ops::CoerceUnsized; !lang
core::pin::Pin; !lang
core::task::Context; ok
core::task::Poll; !lang
core::fmt::rt; // ok
core::fmt::Alignment; ok
core::fmt::Error; ok
core::fmt::write; ok
core::fmt::ArgumentV1; ok
core::fmt::Arguments; ok
core::fmt::Binary; ok
core::fmt::Octal; ok
core::fmt::DebugList; ok
core::fmt::DebugMap; ok
core::fmt::DebugSet; ok
core::fmt::DebugStruct; ok
core::fmt::DebugTuple; ok
core::fmt::Formatter; ok
core::fmt::Write; ok
core::fmt::LowerExp; ok
core::fmt::UpperExp; ok
core::fmt::LowerHex; ok
core::fmt::UpperHex; ok
core::alloc::LayoutErr; ok
core::cmp::max; ok
core::mem::size_of ok
core::mem::align_of; !intrinsic
core::ops::Drop; !lang
core::slice::from_raw_parts_mut; ok
core::slice::ArrayChunks; ok
core::slice::ArrayChunksMut; ok
core::slice::ArrayWindows; ok
core::slice::SliceIndex; ok
core::slice::from_mut; ok
core::slice::from_ref; ok
core::slice::from_raw_parts; ok
core::slice::Chunks; ok
core::slice::Windows; ok
core::slice::ChunksExact; ok
core::slice::ChunksExactMut; ok
core::slice::ChunksMut; ok
core::slice::Split; ok
core::slice::SplitMut; ok
core::slice::Iter; ok
core::slice::IterMut; ok
core::slice::RChunks; ok
core::slice::RChunksExact; ok
core::slice::RChunksExactMut; ok
core::slice::RChunksMut; ok
core::slice::RSplit; ok
core::slice::RSplitMut; ok
core::slice::RSplitN; ok
core::slice::RSplitNMut; ok
core::slice::SplitN; ok
core::slice::SplitNMut; ok
core::mem::take; ok
core::str::pattern::DoubleEndedSearcher; ok
core::str::pattern::Pattern; ok
core::str::pattern::ReverseSearcher; ok
core::str::pattern::Searcher; ok
core::unicode::conversions::to_upper; ok
core::unicode::conversions::to_lower; ok
core::str::pattern; ok
core::str::EncodeUtf16; ok
core::str::SplitAsciiWhitespace; ok
core::str::SplitWhitespace; ok
core::str::from_utf8; ok
core::str::from_utf8_mut; ok
core::str::Bytes; ok
core::str::CharIndices; ok
core::str::Chars; ok
core::str::from_utf8_unchecked; ok
core::str::from_utf8_unchecked_mut; ok
core::str::ParseBoolError; ok
core::str::EscapeDebug; ok
core::str::EscapeDefault; ok
core::str::EscapeUnicode; ok
core::str::FromStr; ok
core::str::Utf8Error; ok
core::str::Lines; ok
core::str::LinesAny; ok
core::str::MatchIndices; ok
core::str::RMatchIndices; ok
core::str::Matches; ok
core::str::RMatches; ok
core::str::Split; ok
core::str::RSplit; ok
core::str::RSplitN; ok
core::str::SplitN; ok
core::str::RSplitTerminator; ok
core::str::SplitTerminator; ok
core::unicode::derived_property::Case_Ignorable; ok
core::unicode::derived_property::Cased; ok
core::char::decode_utf16; ok
core::char::REPLACEMENT_CHARACTER; ok
core::ops::Bound::Excluded; ok
core::ops::Bound::Included; ok
core::ops::Bound::Unbounded; ok
core::ops::Index; ok
core::ops::Range; ok
core::ops::RangeTo; ok
core::ops::RangeFrom; ok
core::ops::RangeFull; ok
core::ops::RangeInclusive; !lang
core::ops::RangeToInclusive; ok
core::ops::IndexMut; ok
core::ops::RangeBounds; ok
core::ptr::copy; ok
core::str::lossy::Utf8Lossy; ok
core::str::lossy::Utf8LossyChunk ok
core::convert::Infallible; ok
core::intrinsics::arith_offset; !intrinsic
core::iter::InPlaceIterable; ok
core::iter::SourceIter; ok
core::iter::TrustedLen; ok
core::iter::TrustedRandomAccess; ok
core::mem::zeroed; !intrinsic
core::mem::forget; ok
core::mem::replace; ok
core::ptr::replace; ok
core::ptr::write_bytes; !intrinsic
core::ptr::slice_from_raw_parts_mut; ok
core::ptr::drop_in_place; !lang
core::slice::to_vec; ok
core::slice::into_vec; ok
core::result::Result; ok
core::mem::swap; ok
core::hint::unreachable_unchecked(); ok
core::array::IntoIter; ok
core::cmp::min; ok
core::iter::repeat_with; ok
core::ops::Try; ok
core::ptr::swap; ok
core::intrinsics::unreachable; ok
core::iter::Peekable; ok
core::ops::BitAnd; ok
core::ops::BitOr; ok
core::ops::BitXor; ok
core::ops::Sub; ok
-----------------------------------------------------------
unreachable! ok
debug_assert_ne! ok
assert! ok
debug_assert_eq! ok
format_args! ok
cfg! ok
-----------------------------------------------------------
#[lang = "owned_box"] !
#[lang = "slice_u8_alloc"] ok
#[lang = "slice_alloc"] ok
#[lang = "str_alloc"] ok
#[lang = "slice"] ok
#[lang = "slice_u8"] ok
#[lang = "str"] ok
#[lang = "char"] ok
-----------------------------------------------------------
#[derive(Copy)] ok
#[derive(PartialEq)] ok
#[derive(Eq)] ok
#[derive(PartialOrd)] ok
#[derive(Ord)] ok
#[repr(C)] ok
-----------------------------------------------------------
#[fundamental] ok
#[may_dangle] ok
#[rustc_specialization_trait] ok
#[rustc_unsafe_specialization_marker] ok
#[cold] ok
11 | sync.rs
15 | prelude/mod.rs
-----------------------------------------------------------
core::hint::spin_loop; ok
core::mem::drop; ok
core::mem::align_of_val; ok
core::sync::atomic::fence; ok
core::sync::atomic::AtomicUsize; ok
core::sync::atomic::Ordering::Acquire; ok
core::sync::atomic::Ordering::Relaxed; ok
core::sync::atomic::Ordering::Release; ok
core::sync::atomic::Ordering::SeqCst; ok
12 | task.rs
-----------------------------------------------------------
core::task::RawWaker; ok
core::task::RawWakerVTable; ok
core::task::Waker; ok
Some of the structures marked here don’t require specific compiler magic, but identifying these gaps was crucial. It provided a clear blueprint of exactly which core structures needed to be implemented in our “mock core” to allow
allocto compile.
With this step, the massive alloc crate was successfully divided into 5 manageable chunks, giving us a precise roadmap of the compiler’s shortcomings.
If you are wondering about the index numbers at the beginning of the file names in the previous section, those are internal IDs I assigned to avoid clutter during the dependency resolution process. Here is the raw internal dependency mapping I extracted from alloc:
Internal Dependencies of alloc
* lib.rs
*
1 alloc.rs | 1:
2 borrow.rs | 2: 4 10
3 boxed.rs | 3: 1 2 6 9 14
4 fmt.rs | 4: 10
5 macros.rs | 5:
6 raw_vec.rs | 6: 1 3 17
7 rc.rs | 7: 1 2 3 10 14
8 slice.rs | 8: 2 3 14
9 str.rs | 9: 2 3 8 10 14
10 string.rs | 10: 2 3 9 14 17
11 sync.rs | 11: 1 2 3 7 10 14
12 task.rs | 12: 11
14 vec.rs | 14: 2 3 6 17
15 prelude/mod.rs | 15: 16
16 prelude/v1.rs | 16: 2 3 10 14
17 collections/mod.rs | 17: 1 18 19 27
18 collections/linked_list.rs | 18: 3 17
19 collections/vec_deque.rs | 19: 6 14 17 20
20 collections/vec_deque/drain.rs | 20: 19
21 collections/btree/append.rs | 21: 23 26 29
22 collections/btree/borrow.rs | 22:
23 collections/btree/map.rs | 23: 22 27 29 31
24 collections/btree/map/entry.rs | 24: 22 23 29
25 collections/btree/mem.rs | 25:
26 collections/btree/merge_iter.rs | 26:
27 collections/btree/mod.rs | 27: 21 22 23 25 26 28 29 30 31 32 33
28 collections/btree/navigate.rs | 28: 27 29 31
29 collections/btree/node.rs | 29: 1 3
30 collections/btree/remove.rs | 30: 23 27 29
31 collections/btree/search.rs | 31: 29
32 collections/btree/set.rs | 32: 23 26 27
33 collections/btree/split.rs | 33: 23 29 31
34 collections/binary_heap.rs | 34: 8 14 17