SYMBOL INDEX (7948 symbols across 701 files)

FILE: benches/copy.rs
  constant KILO (line 12) | const KILO: usize = 1024;
  constant RNG_SEED (line 17) | const RNG_SEED: u64 = 0;
  constant SOURCE_SIZE (line 19) | const SOURCE_SIZE: u64 = 256 * KILO as u64;
  constant CHUNK_SIZE (line 22) | const CHUNK_SIZE: usize = 2 * KILO;
  constant READ_SERVICE_PERIOD (line 23) | const READ_SERVICE_PERIOD: Duration = Duration::from_millis(1);
  constant WRITE_BUFFER (line 26) | const WRITE_BUFFER: usize = 40 * KILO;
  constant WRITE_SERVICE_PERIOD (line 27) | const WRITE_SERVICE_PERIOD: Duration = Duration::from_millis(20);
  constant PROBABILITY_FLUSH_WAIT (line 30) | const PROBABILITY_FLUSH_WAIT: f64 = 0.1;
  type SlowHddWriter (line 41) | struct SlowHddWriter {
    method new (line 49) | fn new(service_interval: Duration, buffer_size: usize) -> Self {
    method service_write (line 61) | fn service_write(
    method write_bytes (line 73) | fn write_bytes(
  method poll_write (line 99) | fn poll_write(
  method poll_flush (line 107) | fn poll_flush(
  method poll_shutdown (line 114) | fn poll_shutdown(
  method poll_write_vectored (line 121) | fn poll_write_vectored(
  method is_write_vectored (line 130) | fn is_write_vectored(&self) -> bool {
  type ChunkReader (line 139) | struct ChunkReader {
    method new (line 145) | fn new(chunk_size: usize, service_interval: Duration) -> Self {
  method poll_read (line 157) | fn poll_read(
  function rt (line 170) | fn rt() -> tokio::runtime::Runtime {
  function copy_mem_to_mem (line 177) | fn copy_mem_to_mem(c: &mut Criterion) {
  function copy_mem_to_slow_hdd (line 193) | fn copy_mem_to_slow_hdd(c: &mut Criterion) {
  function copy_chunk_to_mem (line 209) | fn copy_chunk_to_mem(c: &mut Criterion) {
  function copy_chunk_to_slow_hdd (line 226) | fn copy_chunk_to_slow_hdd(c: &mut Criterion) {

FILE: benches/fs.rs
  function rt (line 14) | fn rt() -> tokio::runtime::Runtime {
  constant BLOCK_COUNT (line 21) | const BLOCK_COUNT: usize = 1_000;
  constant BUFFER_SIZE (line 23) | const BUFFER_SIZE: usize = 4096;
  constant DEV_ZERO (line 24) | const DEV_ZERO: &str = "/dev/zero";
  function async_read_codec (line 26) | fn async_read_codec(c: &mut Criterion) {
  function async_read_buf (line 46) | fn async_read_buf(c: &mut Criterion) {
  function async_read_std_file (line 68) | fn async_read_std_file(c: &mut Criterion) {
  function sync_read (line 92) | fn sync_read(c: &mut Criterion) {

FILE: benches/remote_spawn.rs
  constant TOTAL_TASKS (line 21) | const TOTAL_TASKS: usize = 12_800;
  constant _ (line 22) | const _: () = assert!(TOTAL_TASKS % 64 == 0, "TOTAL_TASKS must be divisi...
  function remote_spawn_contention (line 24) | fn remote_spawn_contention(c: &mut Criterion) {
  function parallelism_levels (line 83) | fn parallelism_levels() -> Vec<usize> {
  function rt (line 94) | fn rt() -> Runtime {

FILE: benches/rt_current_thread.rs
  constant NUM_SPAWN (line 9) | const NUM_SPAWN: usize = 1_000;
  function rt_curr_spawn_many_local (line 11) | fn rt_curr_spawn_many_local(c: &mut Criterion) {
  function rt_curr_spawn_many_remote_idle (line 30) | fn rt_curr_spawn_many_remote_idle(c: &mut Criterion) {
  function rt_curr_spawn_many_remote_busy (line 50) | fn rt_curr_spawn_many_remote_busy(c: &mut Criterion) {
  function rt (line 78) | fn rt() -> Runtime {

FILE: benches/rt_multi_threaded.rs
  constant NUM_WORKERS (line 15) | const NUM_WORKERS: usize = 4;
  constant NUM_SPAWN (line 16) | const NUM_SPAWN: usize = 10_000;
  constant STALL_DUR (line 17) | const STALL_DUR: Duration = Duration::from_micros(10);
  function rt_multi_spawn_many_local (line 19) | fn rt_multi_spawn_many_local(c: &mut Criterion) {
  function rt_multi_spawn_many_remote_idle (line 47) | fn rt_multi_spawn_many_remote_idle(c: &mut Criterion) {
  function rt_multi_spawn_many_remote_busy1 (line 69) | fn rt_multi_spawn_many_remote_busy1(c: &mut Criterion) {
  function rt_multi_spawn_many_remote_busy2 (line 105) | fn rt_multi_spawn_many_remote_busy2(c: &mut Criterion) {
  function rt_multi_yield_many (line 146) | fn rt_multi_yield_many(c: &mut Criterion) {
  function rt_multi_ping_pong (line 174) | fn rt_multi_ping_pong(c: &mut Criterion) {
  function rt_multi_chained_spawn (line 219) | fn rt_multi_chained_spawn(c: &mut Criterion) {
  function rt (line 250) | fn rt() -> Runtime {
  function stall (line 258) | fn stall() {

FILE: benches/signal.rs
  type Spinner (line 12) | struct Spinner {
    method new (line 31) | fn new() -> Self {
  type Output (line 17) | type Output = ();
  method poll (line 19) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function send_signal (line 36) | pub fn send_signal(signal: libc::c_int) {
  function many_signals (line 44) | fn many_signals(c: &mut Criterion) {

FILE: benches/spawn.rs
  function work (line 7) | async fn work() -> usize {
  function single_rt (line 13) | fn single_rt() -> tokio::runtime::Runtime {
  function multi_rt (line 19) | fn multi_rt() -> tokio::runtime::Runtime {
  function basic_scheduler_spawn (line 26) | fn basic_scheduler_spawn(c: &mut Criterion) {
  function basic_scheduler_spawn10 (line 39) | fn basic_scheduler_spawn10(c: &mut Criterion) {
  function threaded_scheduler_spawn (line 57) | fn threaded_scheduler_spawn(c: &mut Criterion) {
  function threaded_scheduler_spawn10 (line 70) | fn threaded_scheduler_spawn10(c: &mut Criterion) {

FILE: benches/spawn_blocking.rs
  constant NUM_BATCHES (line 13) | const NUM_BATCHES: usize = 100;
  constant BATCH_SIZE (line 15) | const BATCH_SIZE: usize = 16;
  function spawn_blocking_concurrency (line 17) | fn spawn_blocking_concurrency(c: &mut Criterion) {
  function rt (line 64) | fn rt() -> Runtime {

FILE: benches/sync_broadcast.rs
  function rt (line 9) | fn rt() -> tokio::runtime::Runtime {
  function do_work (line 16) | fn do_work(rng: &mut impl RngCore) -> u32 {
  function contention_impl (line 29) | fn contention_impl<const N_TASKS: usize>(g: &mut BenchmarkGroup<WallTime...
  function bench_contention (line 71) | fn bench_contention(c: &mut Criterion) {

FILE: benches/sync_mpsc.rs
  type Medium (line 7) | struct Medium(#[allow(dead_code)] [usize; 64]);
  method default (line 9) | fn default() -> Self {
  type Large (line 15) | struct Large(#[allow(dead_code)] [Medium; 64]);
  method default (line 17) | fn default() -> Self {
  function rt (line 22) | fn rt() -> tokio::runtime::Runtime {
  function create_medium (line 29) | fn create_medium<const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>) {
  function send_data (line 37) | fn send_data<T: Default, const SIZE: usize>(g: &mut BenchmarkGroup<WallT...
  function contention_bounded (line 51) | fn contention_bounded(g: &mut BenchmarkGroup<WallTime>) {
  function contention_bounded_recv_many (line 76) | fn contention_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
  function contention_bounded_full (line 103) | fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
  function contention_bounded_full_recv_many (line 128) | fn contention_bounded_full_recv_many(g: &mut BenchmarkGroup<WallTime>) {
  function contention_unbounded (line 155) | fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
  function contention_unbounded_recv_many (line 180) | fn contention_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
  function uncontented_bounded (line 207) | fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
  function uncontented_bounded_recv_many (line 227) | fn uncontented_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
  function uncontented_unbounded (line 249) | fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
  function uncontented_unbounded_recv_many (line 269) | fn uncontented_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
  function bench_create_medium (line 291) | fn bench_create_medium(c: &mut Criterion) {
  function bench_send (line 299) | fn bench_send(c: &mut Criterion) {
  function bench_contention (line 306) | fn bench_contention(c: &mut Criterion) {
  function bench_uncontented (line 317) | fn bench_uncontented(c: &mut Criterion) {

FILE: benches/sync_mpsc_oneshot.rs
  function request_reply_current_thread (line 8) | fn request_reply_current_thread(c: &mut Criterion) {
  function request_reply_multi_threaded (line 16) | fn request_reply_multi_threaded(c: &mut Criterion) {
  function request_reply (line 25) | fn request_reply(b: &mut Criterion, rt: Runtime) {

FILE: benches/sync_notify.rs
  function rt (line 9) | fn rt() -> tokio::runtime::Runtime {
  function notify_waiters (line 16) | fn notify_waiters<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTim...
  function notify_one (line 47) | fn notify_one<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
  function bench_notify_one (line 78) | fn bench_notify_one(c: &mut Criterion) {
  function bench_notify_waiters (line 88) | fn bench_notify_waiters(c: &mut Criterion) {

FILE: benches/sync_rwlock.rs
  function read_uncontended (line 7) | fn read_uncontended(g: &mut BenchmarkGroup<WallTime>) {
  function read_concurrent_uncontended_multi (line 27) | fn read_concurrent_uncontended_multi(g: &mut BenchmarkGroup<WallTime>) {
  function read_concurrent_uncontended (line 57) | fn read_concurrent_uncontended(g: &mut BenchmarkGroup<WallTime>) {
  function read_concurrent_contended_multi (line 85) | fn read_concurrent_contended_multi(g: &mut BenchmarkGroup<WallTime>) {
  function read_concurrent_contended (line 116) | fn read_concurrent_contended(g: &mut BenchmarkGroup<WallTime>) {
  function bench_contention (line 145) | fn bench_contention(c: &mut Criterion) {
  function bench_uncontented (line 152) | fn bench_uncontented(c: &mut Criterion) {

FILE: benches/sync_semaphore.rs
  function single_rt (line 8) | fn single_rt() -> Runtime {
  function multi_rt (line 14) | fn multi_rt() -> Runtime {
  function uncontended (line 21) | fn uncontended(g: &mut BenchmarkGroup<WallTime>) {
  function task (line 38) | async fn task(s: Arc<Semaphore>) {
  function uncontended_concurrent_multi (line 43) | fn uncontended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
  function uncontended_concurrent_single (line 65) | fn uncontended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
  function contended_concurrent_multi (line 86) | fn contended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
  function contended_concurrent_single (line 108) | fn contended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
  function bench_contention (line 129) | fn bench_contention(c: &mut Criterion) {
  function bench_uncontented (line 136) | fn bench_uncontented(c: &mut Criterion) {

FILE: benches/sync_watch.rs
  function rt (line 9) | fn rt() -> tokio::runtime::Runtime {
  function do_work (line 16) | fn do_work(rng: &mut impl RngCore) -> u32 {
  function contention_resubscribe (line 29) | fn contention_resubscribe<const N_TASKS: usize>(g: &mut BenchmarkGroup<W...
  function bench_contention_resubscribe (line 74) | fn bench_contention_resubscribe(c: &mut Criterion) {

FILE: benches/time_now.rs
  function time_now_current_thread (line 7) | fn time_now_current_thread(c: &mut Criterion) {

FILE: benches/time_timeout.rs
  function quick_job (line 10) | async fn quick_job() -> usize {
  function build_run_time (line 14) | fn build_run_time(workers: usize) -> Runtime {
  function single_thread_scheduler_timeout (line 29) | fn single_thread_scheduler_timeout(c: &mut Criterion) {
  function multi_thread_scheduler_timeout (line 33) | fn multi_thread_scheduler_timeout(c: &mut Criterion) {
  function do_timeout_test (line 37) | fn do_timeout_test(c: &mut Criterion, workers: usize, name: &str) {
  function spawn_timeout_job (line 50) | async fn spawn_timeout_job(iters: usize, procs: usize) {
  function single_thread_scheduler_sleep (line 65) | fn single_thread_scheduler_sleep(c: &mut Criterion) {
  function multi_thread_scheduler_sleep (line 69) | fn multi_thread_scheduler_sleep(c: &mut Criterion) {
  function do_sleep_test (line 73) | fn do_sleep_test(c: &mut Criterion, workers: usize, name: &str) {
  function spawn_sleep_job (line 87) | async fn spawn_sleep_job(iters: usize, procs: usize) {

FILE: examples/chat.rs
  constant DEFAULT_ADDR (line 42) | const DEFAULT_ADDR: &str = "127.0.0.1:6142";
  function main (line 45) | async fn main() -> Result<(), Box<dyn Error>> {
  type Tx (line 102) | type Tx = mpsc::UnboundedSender<String>;
  type Rx (line 105) | type Rx = mpsc::UnboundedReceiver<String>;
  type Shared (line 113) | struct Shared {
    method new (line 135) | fn new() -> Self {
    method broadcast (line 145) | async fn broadcast(&mut self, sender: SocketAddr, message: &str) {
  type Peer (line 118) | struct Peer {
    method new (line 166) | async fn new(
  function process (line 184) | async fn process(

FILE: examples/connect-tcp.rs
  function main (line 29) | async fn main() -> Result<(), Box<dyn Error>> {
  function connect (line 46) | pub async fn connect(

FILE: examples/connect-udp.rs
  function main (line 29) | async fn main() -> Result<(), Box<dyn Error>> {
  function connect (line 46) | pub async fn connect(
  function send (line 70) | async fn send(
  function recv (line 82) | async fn recv(

FILE: examples/custom-executor-tokio-context.rs
  function main (line 11) | fn main() {

FILE: examples/custom-executor.rs
  function main (line 10) | fn main() {
  function spawn (line 29) | pub fn spawn(f: impl Future<Output = ()> + Send + 'static) {
  type ThreadPool (line 33) | struct ThreadPool {
    method spawn (line 51) | fn spawn(&self, f: impl Future<Output = ()> + Send + 'static) {

FILE: examples/dump.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function main (line 87) | fn main() {

FILE: examples/echo-tcp.rs
  constant DEFAULT_ADDR (line 30) | const DEFAULT_ADDR: &str = "127.0.0.1:8080";
  constant BUFFER_SIZE (line 31) | const BUFFER_SIZE: usize = 4096;
  function main (line 34) | async fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/echo-udp.rs
  type Server (line 20) | struct Server {
    method run (line 27) | async fn run(self) -> Result<(), io::Error> {
  function main (line 52) | async fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/hello_world.rs
  function main (line 20) | pub async fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/named-pipe-multi-client.rs
  function windows_main (line 4) | async fn windows_main() -> io::Result<()> {
  function main (line 86) | async fn main() -> io::Result<()> {

FILE: examples/named-pipe-ready.rs
  function windows_main (line 4) | async fn windows_main() -> io::Result<()> {
  function main (line 149) | async fn main() -> io::Result<()> {

FILE: examples/named-pipe.rs
  function windows_main (line 4) | async fn windows_main() -> io::Result<()> {
  function main (line 48) | async fn main() -> io::Result<()> {

FILE: examples/print_each_packet.rs
  function main (line 64) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/proxy.rs
  function main (line 33) | async fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/tinydb.rs
  type Database (line 58) | struct Database {
  type Request (line 63) | enum Request {
    method parse (line 180) | fn parse(input: &str) -> Result<Request, String> {
  type Response (line 69) | enum Response {
    method serialize (line 213) | fn serialize(&self) -> String {
  function main (line 85) | async fn main() -> Result<(), Box<dyn Error>> {
  function handle_request (line 151) | fn handle_request(line: &str, db: &Arc<Database>) -> Response {

FILE: examples/tinyhttp.rs
  function main (line 27) | async fn main() -> Result<(), Box<dyn Error>> {
  function process (line 46) | async fn process(stream: TcpStream) -> Result<(), Box<dyn Error>> {
  function respond (line 62) | async fn respond(req: Request<()>) -> Result<Response<String>, Box<dyn E...
  type Http (line 90) | struct Http;
    type Error (line 95) | type Error = io::Error;
    method encode (line 97) | fn encode(&mut self, item: Response<String>, dst: &mut BytesMut) -> io...
  type Item (line 149) | type Item = Request<()>;
  type Error (line 150) | type Error = io::Error;
  method decode (line 152) | fn decode(&mut self, src: &mut BytesMut) -> io::Result<Option<Request<()...
  type Now (line 223) | pub struct Now(());
    method fmt (line 261) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function now (line 227) | pub fn now() -> Now {
  type LastRenderedNow (line 248) | struct LastRenderedNow {
    method buffer (line 278) | fn buffer(&self) -> &str {
    method update (line 282) | fn update(&mut self, now: SystemTime, now_unix: u64) {
  type LocalBuffer (line 289) | struct LocalBuffer<'a>(&'a mut LastRenderedNow);
  function write_str (line 292) | fn write_str(&mut self, s: &str) -> fmt::Result {

FILE: examples/udp-client.rs
  function get_stdin_data (line 37) | fn get_stdin_data() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
  function main (line 44) | async fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/udp-codec.rs
  function main (line 25) | async fn main() -> Result<(), Box<dyn Error>> {
  function ping (line 56) | async fn ping(socket: &mut UdpFramed<BytesCodec>, b_addr: SocketAddr) ->...
  function pong (line 70) | async fn pong(socket: &mut UdpFramed<BytesCodec>) -> Result<(), io::Erro...

FILE: stress-test/examples/simple_echo_tcp.rs
  constant TCP_ENDPOINT (line 11) | const TCP_ENDPOINT: &str = "127.0.0.1:8080";
  constant NUM_MSGS (line 12) | const NUM_MSGS: usize = 100;
  constant MSG_SIZE (line 13) | const MSG_SIZE: usize = 1024;
  function main (line 15) | fn main() {

FILE: tests-build/tests/fail/macros_core_no_default.rs
  function my_fn (line 4) | async fn my_fn() {}
  function main (line 6) | fn main() {}

FILE: tests-build/tests/fail/macros_dead_code.rs
  function f (line 6) | async fn f() {}
  function main (line 8) | fn main() {}

FILE: tests-build/tests/fail/macros_invalid_input.rs
  function main_is_not_async (line 6) | fn main_is_not_async() {}
  function main_attr_has_unknown_args (line 9) | async fn main_attr_has_unknown_args() {}
  function main_attr_has_path_args (line 12) | async fn main_attr_has_path_args() {}
  function test_is_not_async (line 15) | fn test_is_not_async() {}
  function test_attr_has_args (line 18) | async fn test_attr_has_args() {}
  function test_unexpected_attr (line 21) | async fn test_unexpected_attr() {}
  function test_flavor_not_string (line 24) | async fn test_flavor_not_string() {}
  function test_unknown_flavor (line 27) | async fn test_unknown_flavor() {}
  function test_multi_thread_with_start_paused (line 30) | async fn test_multi_thread_with_start_paused() {}
  function test_worker_threads_not_int (line 33) | async fn test_worker_threads_not_int() {}
  function test_worker_threads_and_current_thread (line 36) | async fn test_worker_threads_and_current_thread() {}
  function test_crate_not_path_int (line 39) | async fn test_crate_not_path_int() {}
  function test_crate_not_path_invalid (line 42) | async fn test_crate_not_path_invalid() {}
  function test_multi_thread_with_unhandled_panic (line 45) | async fn test_multi_thread_with_unhandled_panic() {}
  function test_has_second_test_attr (line 49) | async fn test_has_second_test_attr() {}
  function test_has_second_test_attr_v1 (line 53) | async fn test_has_second_test_attr_v1() {}
  function test_has_second_test_attr_rust_2015 (line 57) | async fn test_has_second_test_attr_rust_2015() {}
  function test_has_second_test_attr_rust_2018 (line 61) | async fn test_has_second_test_attr_rust_2018() {}
  function test_has_second_test_attr_rust_2021 (line 65) | async fn test_has_second_test_attr_rust_2021() {}
  function test_has_generated_second_test_attr (line 69) | async fn test_has_generated_second_test_attr() {}
  function main (line 71) | fn main() {}

FILE: tests-build/tests/fail/macros_join.rs
  function main (line 4) | async fn main() {

FILE: tests-build/tests/fail/macros_try_join.rs
  function main (line 4) | async fn main() {

FILE: tests-build/tests/fail/macros_type_mismatch.rs
  function missing_semicolon_or_return_type (line 4) | async fn missing_semicolon_or_return_type() {
  function missing_return_type (line 9) | async fn missing_return_type() {
  function extra_semicolon (line 14) | async fn extra_semicolon() -> Result<(), ()> {
  function question_mark_operator_with_invalid_option (line 39) | async fn question_mark_operator_with_invalid_option() -> Option<()> {
  function question_mark_operator_with_invalid_result (line 56) | async fn question_mark_operator_with_invalid_result() -> Result<(), ()> {
  function issue_4635 (line 64) | async fn issue_4635() {
  function main (line 69) | fn main() {}

FILE: tests-build/tests/macros.rs
  function compile_fail_full (line 3) | fn compile_fail_full() {

FILE: tests-build/tests/macros_clippy.rs
  function test_with_semicolon_without_return_type (line 3) | async fn test_with_semicolon_without_return_type() {

FILE: tests-build/tests/pass/forward_args_and_output.rs
  function main (line 3) | fn main() {}
  function test_fn_has_args (line 8) | async fn test_fn_has_args(_x: u8) {}
  function test_has_output (line 11) | async fn test_has_output() -> Result<(), Box<dyn std::error::Error>> {

FILE: tests-build/tests/pass/impl_trait.rs
  function never (line 4) | async fn never() -> ! {
  function impl_trait (line 9) | async fn impl_trait() -> impl Iterator<Item = impl core::fmt::Debug> {
  function impl_trait2 (line 14) | async fn impl_trait2() -> Result<(), impl core::fmt::Debug> {
  function main (line 18) | fn main() {

FILE: tests-build/tests/pass/macros_main_loop.rs
  function main (line 4) | async fn main() -> Result<(), ()> {
  function never (line 12) | fn never() -> bool {

FILE: tests-build/tests/pass/macros_main_return.rs
  function main (line 4) | async fn main() -> Result<(), ()> {

FILE: tests-build/tests/pass/use_builder_outer.rs
  function main (line 7) | async fn main() {

FILE: tests-integration/src/bin/test-cat.rs
  function main (line 7) | fn main() {

FILE: tests-integration/src/bin/test-mem.rs
  function main (line 3) | fn main() {

FILE: tests-integration/src/bin/test-process-signal.rs
  function main (line 2) | fn main() {

FILE: tests-integration/tests/macros_main.rs
  function basic_main (line 4) | async fn basic_main() -> usize {
  function generic_fun (line 9) | async fn generic_fun<T: Default>() -> T {
  function spawning (line 14) | async fn spawning() -> usize {
  function local_main (line 21) | async fn local_main() -> usize {
  function main_with_spawn (line 27) | fn main_with_spawn() {
  function shell (line 32) | fn shell() {

FILE: tests-integration/tests/macros_pin.rs
  function my_async_fn (line 3) | async fn my_async_fn() {}
  function pin (line 6) | fn pin() {

FILE: tests-integration/tests/macros_select.rs
  function join_with_select (line 12) | fn join_with_select() {

FILE: tests-integration/tests/process_stdio.rs
  function cat (line 15) | fn cat() -> Command {
  function feed_cat (line 21) | async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
  function feed_a_lot (line 85) | async fn feed_a_lot() {
  function wait_with_output_captures (line 92) | async fn wait_with_output_captures() {
  function status_closes_any_pipes (line 113) | async fn status_closes_any_pipes() {
  function try_wait (line 123) | async fn try_wait() {
  function pipe_from_one_command_to_another (line 146) | async fn pipe_from_one_command_to_another() {
  function vectored_writes (line 195) | async fn vectored_writes() {

FILE: tests-integration/tests/rt_yield.rs
  function spawn_send (line 4) | async fn spawn_send() {
  function entry_point (line 20) | async fn entry_point() {
  function test_macro (line 25) | async fn test_macro() {
  function main_macro (line 30) | fn main_macro() {
  function manual_rt (line 35) | fn manual_rt() {

FILE: tokio-macros/src/entry.rs
  type AttributeArgs (line 7) | type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![...
  type RuntimeFlavor (line 10) | enum RuntimeFlavor {
    method from_str (line 17) | fn from_str(s: &str) -> Result<RuntimeFlavor, String> {
  type UnhandledPanic (line 31) | enum UnhandledPanic {
    method from_str (line 37) | fn from_str(s: &str) -> Result<UnhandledPanic, String> {
    method into_tokens (line 45) | fn into_tokens(self, crate_path: &TokenStream) -> TokenStream {
  type FinalConfig (line 55) | struct FinalConfig {
  constant DEFAULT_ERROR_CONFIG (line 64) | const DEFAULT_ERROR_CONFIG: FinalConfig = FinalConfig {
  type Configuration (line 72) | struct Configuration {
    method new (line 84) | fn new(is_test: bool, rt_multi_thread: bool) -> Self {
    method set_flavor (line 100) | fn set_flavor(&mut self, runtime: syn::Lit, span: Span) -> Result<(), ...
    method set_worker_threads (line 112) | fn set_worker_threads(
    method set_start_paused (line 132) | fn set_start_paused(&mut self, start_paused: syn::Lit, span: Span) -> ...
    method set_crate_name (line 142) | fn set_crate_name(&mut self, name: syn::Lit, span: Span) -> Result<(),...
    method set_unhandled_panic (line 151) | fn set_unhandled_panic(
    method macro_name (line 170) | fn macro_name(&self) -> &'static str {
    method build (line 178) | fn build(&self) -> Result<FinalConfig, syn::Error> {
  function parse_int (line 239) | fn parse_int(int: syn::Lit, span: Span, field: &str) -> Result<usize, sy...
  function parse_string (line 255) | fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result<String...
  function parse_path (line 266) | fn parse_path(lit: syn::Lit, span: Span, field: &str) -> Result<Path, sy...
  function parse_bool (line 286) | fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, s...
  function contains_impl_trait (line 296) | fn contains_impl_trait(ty: &syn::Type) -> bool {
  function build_config (line 325) | fn build_config(
  function parse_knobs (line 421) | fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) ->...
  function token_stream_with_error (line 577) | fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -...
  function main (line 582) | pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread...
  function is_test_attribute (line 610) | fn is_test_attribute(attr: &Attribute) -> bool {
  function test (line 635) | pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread...
  type ItemFn (line 658) | struct ItemFn {
    method attrs (line 669) | fn attrs(&self) -> impl Iterator<Item = &Attribute> {
    method body (line 675) | fn body(&self) -> Body<'_> {
    method into_tokens (line 683) | fn into_tokens(
  method parse (line 720) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  type Body (line 767) | struct Body<'a> {
  method to_tokens (line 774) | fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {

FILE: tokio-macros/src/lib.rs
  function main (line 301) | pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
  function main_rt (line 365) | pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
  function test (line 569) | pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
  function test_rt (line 584) | pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream {
  function main_fail (line 593) | pub fn main_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
  function test_fail (line 607) | pub fn test_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
  function select_priv_declare_output_enum (line 620) | pub fn select_priv_declare_output_enum(input: TokenStream) -> TokenStream {
  function select_priv_clean_pattern (line 628) | pub fn select_priv_clean_pattern(input: TokenStream) -> TokenStream {

FILE: tokio-macros/src/select.rs
  function declare_output_enum (line 6) | pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
  function clean_pattern_macro (line 45) | pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream {
  function clean_pattern (line 59) | fn clean_pattern(pat: &mut syn::Pat) {

FILE: tokio-stream/fuzz/fuzz_targets/fuzz_stream_map.rs
  function pin_box (line 18) | fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream...

FILE: tokio-stream/src/empty.rs
  type Empty (line 10) | pub struct Empty<T>(PhantomData<T>);
  function empty (line 36) | pub const fn empty<T>() -> Empty<T> {
  type Item (line 41) | type Item = T;
  method poll_next (line 43) | fn poll_next(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<T...
  method size_hint (line 47) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/iter.rs
  type Iter (line 9) | pub struct Iter<I> {
  function iter (line 33) | pub fn iter<I>(i: I) -> Iter<I::IntoIter>
  type Item (line 47) | type Item = I::Item;
  method poll_next (line 49) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 64) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/once.rs
  type Once (line 10) | pub struct Once<T> {
  function once (line 36) | pub fn once<T>(value: T) -> Once<T> {
  type Item (line 43) | type Item = T;
  method poll_next (line 45) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 49) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/pending.rs
  type Pending (line 10) | pub struct Pending<T>(PhantomData<T>);
  function pending (line 40) | pub const fn pending<T>() -> Pending<T> {
  type Item (line 45) | type Item = T;
  method poll_next (line 47) | fn poll_next(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<T...
  method size_hint (line 51) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_close.rs
  function new (line 44) | pub fn new(stream: S) -> Self {
  function into_inner (line 53) | pub fn into_inner(self) -> Option<S> {
  type Item (line 62) | type Item = Option<S::Item>;
  method poll_next (line 64) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 84) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext.rs
  type StreamExt (line 106) | pub trait StreamExt: Stream {
    method next (line 144) | fn next(&mut self) -> Next<'_, Self>
    method try_next (line 186) | fn try_next<T, E>(&mut self) -> TryNext<'_, Self>
    method map (line 219) | fn map<T, F>(self, f: F) -> Map<Self, F>
    method map_while (line 261) | fn map_while<T, F>(self, f: F) -> MapWhile<Self, F>
    method then (line 305) | fn then<F, Fut>(self, f: F) -> Then<Self, Fut, F>
    method merge (line 398) | fn merge<U>(self, other: U) -> Merge<Self, U>
    method filter (line 436) | fn filter<F>(self, f: F) -> Filter<Self, F>
    method filter_map (line 474) | fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
    method fuse (line 543) | fn fuse(self) -> Fuse<Self>
    method take (line 570) | fn take(self, n: usize) -> Take<Self>
    method take_while (line 599) | fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
    method skip (line 625) | fn skip(self, n: usize) -> Skip<Self>
    method skip_while (line 655) | fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
    method all (line 716) | fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F>
    method any (line 775) | fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F>
    method chain (line 810) | fn chain<U>(self, other: U) -> Chain<Self, U>
    method fold (line 840) | fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F>
    method collect (line 919) | fn collect<T>(self) -> Collect<Self, T, T::InternalCollection>
    method timeout (line 1005) | fn timeout(self, duration: Duration) -> Timeout<Self>
    method timeout_repeating (line 1093) | fn timeout_repeating(self, interval: Interval) -> TimeoutRepeating<Self>
    method throttle (line 1123) | fn throttle(self, duration: Duration) -> Throttle<Self>
    method chunks_timeout (line 1179) | fn chunks_timeout(self, max_size: usize, duration: Duration) -> Chunks...
    method peekable (line 1205) | fn peekable(self) -> Peekable<Self>
  function merge_size_hints (line 1216) | fn merge_size_hints(

FILE: tokio-stream/src/stream_ext/all.rs
  function new (line 23) | pub(super) fn new(stream: &'a mut St, f: F) -> Self {
  type Output (line 37) | type Output = bool;
  method poll (line 39) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-stream/src/stream_ext/any.rs
  function new (line 23) | pub(super) fn new(stream: &'a mut St, f: F) -> Self {
  type Output (line 37) | type Output = bool;
  method poll (line 39) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-stream/src/stream_ext/chain.rs
  function new (line 19) | pub(super) fn new(a: T, b: U) -> Chain<T, U>
  type Item (line 33) | type Item = T::Item;
  method poll_next (line 35) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 47) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/chunks_timeout.rs
  function new (line 27) | pub(super) fn new(stream: S, max_size: usize, duration: Duration) -> Self {
  function into_remainder (line 38) | pub fn into_remainder(mut self: Pin<&mut Self>) -> Vec<S::Item> {
  type Item (line 45) | type Item = Vec<S::Item>;
  method poll_next (line 47) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 85) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/collect.rs
  type FromStream (line 39) | pub trait FromStream<T>: sealed::FromStreamPriv<T> {}
  function new (line 46) | pub(super) fn new(stream: T) -> Collect<T, U, U::InternalCollection> {
  type Output (line 64) | type Output = U;
  method poll (line 66) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<U> {
  type InternalCollection (line 91) | type InternalCollection = ();
  function initialize (line 93) | fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>) {}
  function extend (line 95) | fn extend(_: sealed::Internal, _collection: &mut (), _item: ()) -> bool {
  function finalize (line 99) | fn finalize(_: sealed::Internal, _collection: &mut ()) {}
  type InternalCollection (line 105) | type InternalCollection = String;
  method initialize (line 107) | fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>)...
  method extend (line 111) | fn extend(_: sealed::Internal, collection: &mut String, item: T) -> bool {
  method finalize (line 116) | fn finalize(_: sealed::Internal, collection: &mut String) -> String {
  type InternalCollection (line 124) | type InternalCollection = Vec<T>;
  function initialize (line 126) | fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) ...
  function extend (line 130) | fn extend(_: sealed::Internal, collection: &mut Vec<T>, item: T) -> bool {
  function finalize (line 135) | fn finalize(_: sealed::Internal, collection: &mut Vec<T>) -> Vec<T> {
  type InternalCollection (line 143) | type InternalCollection = VecDeque<T>;
  function initialize (line 145) | fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) ...
  function extend (line 149) | fn extend(_: sealed::Internal, collection: &mut VecDeque<T>, item: T) ->...
  function finalize (line 154) | fn finalize(_: sealed::Internal, collection: &mut VecDeque<T>) -> VecDeq...
  type InternalCollection (line 162) | type InternalCollection = LinkedList<T>;
  function initialize (line 164) | fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>)...
  function extend (line 168) | fn extend(_: sealed::Internal, collection: &mut LinkedList<T>, item: T) ...
  function finalize (line 173) | fn finalize(_: sealed::Internal, collection: &mut LinkedList<T>) -> Link...
  type InternalCollection (line 181) | type InternalCollection = BTreeSet<T>;
  function initialize (line 183) | fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>)...
  function extend (line 187) | fn extend(_: sealed::Internal, collection: &mut BTreeSet<T>, item: T) ->...
  function finalize (line 192) | fn finalize(_: sealed::Internal, collection: &mut BTreeSet<T>) -> BTreeS...
  type InternalCollection (line 200) | type InternalCollection = BTreeMap<K, V>;
  function initialize (line 202) | fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>)...
  function extend (line 206) | fn extend(_: sealed::Internal, collection: &mut BTreeMap<K, V>, (key, va...
  function finalize (line 211) | fn finalize(_: sealed::Internal, collection: &mut BTreeMap<K, V>) -> BTr...
  type InternalCollection (line 219) | type InternalCollection = HashSet<T>;
  function initialize (line 221) | fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) ...
  function extend (line 225) | fn extend(_: sealed::Internal, collection: &mut HashSet<T>, item: T) -> ...
  function finalize (line 230) | fn finalize(_: sealed::Internal, collection: &mut HashSet<T>) -> HashSet...
  type InternalCollection (line 238) | type InternalCollection = HashMap<K, V>;
  function initialize (line 240) | fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) ...
  function extend (line 244) | fn extend(_: sealed::Internal, collection: &mut HashMap<K, V>, (key, val...
  function finalize (line 249) | fn finalize(_: sealed::Internal, collection: &mut HashMap<K, V>) -> Hash...
  type InternalCollection (line 257) | type InternalCollection = BinaryHeap<T>;
  function initialize (line 259) | fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) ...
  function extend (line 263) | fn extend(_: sealed::Internal, collection: &mut BinaryHeap<T>, item: T) ...
  function finalize (line 268) | fn finalize(_: sealed::Internal, collection: &mut BinaryHeap<T>) -> Bina...
  type InternalCollection (line 276) | type InternalCollection = Vec<T>;
  function initialize (line 278) | fn initialize(_: sealed::Internal, lower: usize, upper: Option<usize>) -...
  function extend (line 282) | fn extend(_: sealed::Internal, collection: &mut Vec<T>, item: T) -> bool {
  function finalize (line 286) | fn finalize(_: sealed::Internal, collection: &mut Vec<T>) -> Box<[T]> {
  type InternalCollection (line 298) | type InternalCollection = Result<U::InternalCollection, E>;
  function initialize (line 300) | fn initialize(
  function extend (line 308) | fn extend(
  function finalize (line 326) | fn finalize(_: sealed::Internal, collection: &mut Self::InternalCollecti...
  type FromStreamPriv (line 339) | pub trait FromStreamPriv<T> {
    method initialize (line 346) | fn initialize(
    method extend (line 355) | fn extend(internal: Internal, collection: &mut Self::InternalCollectio...
    method finalize (line 358) | fn finalize(internal: Internal, collection: &mut Self::InternalCollect...
  type Internal (line 362) | pub struct Internal;

FILE: tokio-stream/src/stream_ext/filter.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 30) | pub(super) fn new(stream: St, f: F) -> Self {
  type Item (line 40) | type Item = St::Item;
  method poll_next (line 42) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 55) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/filter_map.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 30) | pub(super) fn new(stream: St, f: F) -> Self {
  type Item (line 40) | type Item = T;
  method poll_next (line 42) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 55) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/fold.rs
  function new (line 25) | pub(super) fn new(stream: St, init: B, f: F) -> Self {
  type Output (line 40) | type Output = B;
  method poll (line 42) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-stream/src/stream_ext/fuse.rs
  function new (line 20) | pub(crate) fn new(stream: T) -> Fuse<T> {
  type Item (line 31) | type Item = T::Item;
  method poll_next (line 33) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 47) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/map.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 28) | pub(super) fn new(stream: St, f: F) -> Self {
  type Item (line 38) | type Item = T;
  method poll_next (line 40) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 48) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/map_while.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 30) | pub(super) fn new(stream: St, f: F) -> Self {
  type Item (line 40) | type Item = T;
  method poll_next (line 42) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 48) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/merge.rs
  function new (line 21) | pub(super) fn new(a: T, b: U) -> Merge<T, U>
  type Item (line 39) | type Item = T::Item;
  method poll_next (line 41) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 55) | fn size_hint(&self) -> (usize, Option<usize>) {
  function poll_next (line 60) | fn poll_next<T, U>(

FILE: tokio-stream/src/stream_ext/next.rs
  function new (line 29) | pub(super) fn new(stream: &'a mut St) -> Self {
  type Output (line 38) | type Output = Option<St::Item>;
  method poll (line 40) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-stream/src/stream_ext/peekable.rs
  function new (line 20) | pub(crate) fn new(stream: T) -> Self {
  function peek (line 26) | pub async fn peek(&mut self) -> Option<&T::Item>
  type Item (line 40) | type Item = T::Item;
  method poll_next (line 42) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: tokio-stream/src/stream_ext/skip.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 30) | pub(super) fn new(stream: St, remaining: usize) -> Self {
  type Item (line 39) | type Item = St::Item;
  method poll_next (line 41) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 55) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/skip_while.rs
  function fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 30) | pub(super) fn new(stream: St, predicate: F) -> Self {
  type Item (line 43) | type Item = St::Item;
  method poll_next (line 45) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 64) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/take.rs
  function fmt (line 23) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 31) | pub(super) fn new(stream: St, remaining: usize) -> Self {
  type Item (line 40) | type Item = St::Item;
  method poll_next (line 42) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 60) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/take_while.rs
  function fmt (line 23) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 32) | pub(super) fn new(stream: St, predicate: F) -> Self {
  type Item (line 46) | type Item = St::Item;
  method poll_next (line 48) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 70) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/then.rs
  function fmt (line 25) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 33) | pub(super) fn new(stream: St, f: F) -> Self {
  type Item (line 48) | type Item = Fut::Output;
  method poll_next (line 50) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 74) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/throttle.rs
  function throttle (line 12) | pub(super) fn throttle<T>(duration: Duration, stream: T) -> Throttle<T>
  function get_ref (line 46) | pub fn get_ref(&self) -> &T {
  function get_mut (line 55) | pub fn get_mut(&mut self) -> &mut T {
  function into_inner (line 63) | pub fn into_inner(self) -> T {
  type Item (line 69) | type Item = T::Item;
  method poll_next (line 71) | fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<O...
  function is_zero (line 94) | fn is_zero(dur: Duration) -> bool {

FILE: tokio-stream/src/stream_ext/timeout.rs
  type Elapsed (line 28) | pub struct Elapsed(());
    method new (line 90) | pub(crate) fn new() -> Self {
    method fmt (line 96) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 31) | pub(super) fn new(stream: S, duration: Duration) -> Self {
  type Item (line 45) | type Item = Result<S::Item, Elapsed>;
  method poll_next (line 47) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 71) | fn size_hint(&self) -> (usize, Option<usize>) {
  function from (line 104) | fn from(_err: Elapsed) -> std::io::Error {

FILE: tokio-stream/src/stream_ext/timeout_repeating.rs
  function new (line 22) | pub(super) fn new(stream: S, interval: Interval) -> Self {
  type Item (line 31) | type Item = Result<S::Item, Elapsed>;
  method poll_next (line 33) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 50) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tokio-stream/src/stream_ext/try_next.rs
  function new (line 30) | pub(super) fn new(stream: &'a mut St) -> Self {
  type Output (line 39) | type Output = Result<Option<T>, E>;
  method poll (line 41) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-stream/src/stream_map.rs
  type StreamMap (line 205) | pub struct StreamMap<K, V> {
  function iter (line 230) | pub fn iter(&self) -> impl Iterator<Item = &(K, V)> {
  function iter_mut (line 253) | pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (K, V)> {
  function new (line 269) | pub fn new() -> StreamMap<K, V> {
  function with_capacity (line 285) | pub fn with_capacity(capacity: usize) -> StreamMap<K, V> {
  function keys (line 310) | pub fn keys(&self) -> impl Iterator<Item = &K> {
  function values (line 333) | pub fn values(&self) -> impl Iterator<Item = &V> {
  function values_mut (line 356) | pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
  function capacity (line 373) | pub fn capacity(&self) -> usize {
  function len (line 389) | pub fn len(&self) -> usize {
  function is_empty (line 405) | pub fn is_empty(&self) -> bool {
  function clear (line 422) | pub fn clear(&mut self) {
  function insert (line 446) | pub fn insert(&mut self, k: K, stream: V) -> Option<V>
  function remove (line 471) | pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
  function contains_key (line 500) | pub fn contains_key<Q>(&self, k: &Q) -> bool
  function poll_next_entry (line 521) | fn poll_next_entry(&mut self, cx: &mut Context<'_>) -> Poll<Option<(usiz...
  method default (line 560) | fn default() -> Self {
  function next_many (line 587) | pub async fn next_many(&mut self, buffer: &mut Vec<(K, V::Item)>, limit:...
  function poll_next_many (line 603) | pub fn poll_next_many(
  type Item (line 676) | type Item = (K, V::Item);
  method poll_next (line 678) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 687) | fn size_hint(&self) -> (usize, Option<usize>) {
  function from_iter (line 710) | fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
  function extend (line 724) | fn extend<T>(&mut self, iter: T)
  function seed (line 745) | pub(crate) fn seed() -> u64 {
  function seed (line 753) | pub(crate) fn seed() -> u64 {
  type FastRand (line 767) | pub(crate) struct FastRand {
    method new (line 774) | pub(crate) fn new(seed: u64) -> FastRand {
    method fastrand_n (line 789) | pub(crate) fn fastrand_n(&self, n: u32) -> u32 {
    method fastrand (line 796) | fn fastrand(&self) -> u32 {
  function thread_rng_n (line 811) | pub(crate) fn thread_rng_n(n: u32) -> u32 {

FILE: tokio-stream/src/wrappers/broadcast.rs
  type BroadcastStream (line 39) | pub struct BroadcastStream<T> {
  type BroadcastStreamRecvError (line 45) | pub enum BroadcastStreamRecvError {
    method fmt (line 54) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function make_future (line 63) | async fn make_future<T: Clone>(mut rx: Receiver<T>) -> (Result<T, RecvEr...
  function new (line 70) | pub fn new(rx: Receiver<T>) -> Self {
  type Item (line 78) | type Item = Result<T, BroadcastStreamRecvError>;
  method poll_next (line 79) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 99) | fn from(recv: Receiver<T>) -> Self {

FILE: tokio-stream/src/wrappers/interval.rs
  type IntervalStream (line 33) | pub struct IntervalStream {
    method new (line 39) | pub fn new(interval: Interval) -> Self {
    method into_inner (line 44) | pub fn into_inner(self) -> Interval {
    method as_ref (line 68) | fn as_ref(&self) -> &Interval {
    method as_mut (line 74) | fn as_mut(&mut self) -> &mut Interval {
  type Item (line 50) | type Item = Instant;
  method poll_next (line 52) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 56) | fn size_hint(&self) -> (usize, Option<usize>) {
  method is_terminated (line 62) | fn is_terminated(&self) -> bool {

FILE: tokio-stream/src/wrappers/lines.rs
  function new (line 41) | pub fn new(lines: Lines<R>) -> Self {
  function into_inner (line 46) | pub fn into_inner(self) -> Lines<R> {
  function as_pin_mut (line 51) | pub fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Lines<R>> {
  type Item (line 57) | type Item = io::Result<String>;
  method poll_next (line 59) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function as_ref (line 68) | fn as_ref(&self) -> &Lines<R> {
  function as_mut (line 74) | fn as_mut(&mut self) -> &mut Lines<R> {

FILE: tokio-stream/src/wrappers/mpsc_bounded.rs
  type ReceiverStream (line 34) | pub struct ReceiverStream<T> {
  function new (line 40) | pub fn new(recv: Receiver<T>) -> Self {
  function into_inner (line 45) | pub fn into_inner(self) -> Receiver<T> {
  function close (line 59) | pub fn close(&mut self) {
  type Item (line 65) | type Item = T;
  method poll_next (line 67) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 81) | fn size_hint(&self) -> (usize, Option<usize>) {
  function as_ref (line 92) | fn as_ref(&self) -> &Receiver<T> {
  function as_mut (line 98) | fn as_mut(&mut self) -> &mut Receiver<T> {
  function from (line 104) | fn from(recv: Receiver<T>) -> Self {

FILE: tokio-stream/src/wrappers/mpsc_unbounded.rs
  type UnboundedReceiverStream (line 34) | pub struct UnboundedReceiverStream<T> {
  function new (line 40) | pub fn new(recv: UnboundedReceiver<T>) -> Self {
  function into_inner (line 45) | pub fn into_inner(self) -> UnboundedReceiver<T> {
  function close (line 53) | pub fn close(&mut self) {
  type Item (line 59) | type Item = T;
  method poll_next (line 61) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 70) | fn size_hint(&self) -> (usize, Option<usize>) {
  function as_ref (line 81) | fn as_ref(&self) -> &UnboundedReceiver<T> {
  function as_mut (line 87) | fn as_mut(&mut self) -> &mut UnboundedReceiver<T> {
  function from (line 93) | fn from(recv: UnboundedReceiver<T>) -> Self {

FILE: tokio-stream/src/wrappers/read_dir.rs
  type ReadDirStream (line 31) | pub struct ReadDirStream {
    method new (line 37) | pub fn new(read_dir: ReadDir) -> Self {
    method into_inner (line 42) | pub fn into_inner(self) -> ReadDir {
    method as_ref (line 56) | fn as_ref(&self) -> &ReadDir {
    method as_mut (line 62) | fn as_mut(&mut self) -> &mut ReadDir {
  type Item (line 48) | type Item = io::Result<DirEntry>;
  method poll_next (line 50) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: tokio-stream/src/wrappers/signal_unix.rs
  type SignalStream (line 28) | pub struct SignalStream {
    method new (line 34) | pub fn new(signal: Signal) -> Self {
    method into_inner (line 39) | pub fn into_inner(self) -> Signal {
    method as_ref (line 53) | fn as_ref(&self) -> &Signal {
    method as_mut (line 59) | fn as_mut(&mut self) -> &mut Signal {
  type Item (line 45) | type Item = ();
  method poll_next (line 47) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: tokio-stream/src/wrappers/signal_windows.rs
  type CtrlCStream (line 29) | pub struct CtrlCStream {
    method new (line 35) | pub fn new(interval: CtrlC) -> Self {
    method into_inner (line 40) | pub fn into_inner(self) -> CtrlC {
    method as_ref (line 54) | fn as_ref(&self) -> &CtrlC {
    method as_mut (line 60) | fn as_mut(&mut self) -> &mut CtrlC {
  type Item (line 46) | type Item = ();
  method poll_next (line 48) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type CtrlBreakStream (line 88) | pub struct CtrlBreakStream {
    method new (line 94) | pub fn new(interval: CtrlBreak) -> Self {
    method into_inner (line 99) | pub fn into_inner(self) -> CtrlBreak {
    method as_ref (line 113) | fn as_ref(&self) -> &CtrlBreak {
    method as_mut (line 119) | fn as_mut(&mut self) -> &mut CtrlBreak {
  type Item (line 105) | type Item = ();
  method poll_next (line 107) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: tokio-stream/src/wrappers/split.rs
  function new (line 41) | pub fn new(split: Split<R>) -> Self {
  function into_inner (line 46) | pub fn into_inner(self) -> Split<R> {
  function as_pin_mut (line 51) | pub fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Split<R>> {
  type Item (line 57) | type Item = io::Result<Vec<u8>>;
  method poll_next (line 59) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function as_ref (line 68) | fn as_ref(&self) -> &Split<R> {
  function as_mut (line 74) | fn as_mut(&mut self) -> &mut Split<R> {

FILE: tokio-stream/src/wrappers/tcp_listener.rs
  type TcpListenerStream (line 43) | pub struct TcpListenerStream {
    method new (line 49) | pub fn new(listener: TcpListener) -> Self {
    method into_inner (line 54) | pub fn into_inner(self) -> TcpListener {
    method as_ref (line 75) | fn as_ref(&self) -> &TcpListener {
    method as_mut (line 81) | fn as_mut(&mut self) -> &mut TcpListener {
  type Item (line 60) | type Item = io::Result<TcpStream>;
  method poll_next (line 62) | fn poll_next(

FILE: tokio-stream/src/wrappers/unix_listener.rs
  type UnixListenerStream (line 32) | pub struct UnixListenerStream {
    method new (line 38) | pub fn new(listener: UnixListener) -> Self {
    method into_inner (line 43) | pub fn into_inner(self) -> UnixListener {
    method as_ref (line 64) | fn as_ref(&self) -> &UnixListener {
    method as_mut (line 70) | fn as_mut(&mut self) -> &mut UnixListener {
  type Item (line 49) | type Item = io::Result<UnixStream>;
  method poll_next (line 51) | fn poll_next(

FILE: tokio-stream/src/wrappers/watch.rs
  type WatchStream (line 74) | pub struct WatchStream<T> {
  function make_future (line 78) | async fn make_future<T: Clone + Send + Sync>(
  function new (line 87) | pub fn new(rx: Receiver<T>) -> Self {
  function from_changes (line 94) | pub fn from_changes(rx: Receiver<T>) -> Self {
  type Item (line 102) | type Item = T;
  method poll_next (line 104) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function fmt (line 123) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 129) | fn from(recv: Receiver<T>) -> Self {

FILE: tokio-stream/tests/async_send_sync.rs
  type BoxStream (line 6) | type BoxStream<T> = std::pin::Pin<Box<dyn tokio_stream::Stream<Item = T>>>;
  function require_send (line 9) | fn require_send<T: Send>(_t: &T) {}
  function require_sync (line 11) | fn require_sync<T: Sync>(_t: &T) {}
  function require_unpin (line 13) | fn require_unpin<T: Unpin>(_t: &T) {}
  type Invalid (line 16) | struct Invalid;
  type AmbiguousIfSend (line 19) | trait AmbiguousIfSend<A> {
    method some_item (line 20) | fn some_item(&self) {}
  type AmbiguousIfSync (line 26) | trait AmbiguousIfSync<A> {
    method some_item (line 27) | fn some_item(&self) {}
  type AmbiguousIfUnpin (line 33) | trait AmbiguousIfUnpin<A> {
    method some_item (line 34) | fn some_item(&self) {}

FILE: tokio-stream/tests/chunks_timeout.rs
  function usage (line 13) | async fn usage() {
  function full_chunk_with_timeout (line 37) | async fn full_chunk_with_timeout() {
  function real_time (line 67) | async fn real_time() {

FILE: tokio-stream/tests/mpsc_bounded_stream.rs
  function size_hint_stream_open (line 6) | async fn size_hint_stream_open() {
  function size_hint_stream_closed (line 22) | async fn size_hint_stream_closed() {
  function size_hint_sender_dropped (line 39) | async fn size_hint_sender_dropped() {
  function size_hint_stream_instantly_closed (line 56) | fn size_hint_stream_instantly_closed() {
  function size_hint_stream_closed_permits_send (line 66) | async fn size_hint_stream_closed_permits_send() {
  function size_hint_stream_closed_permits_drop (line 91) | async fn size_hint_stream_closed_permits_drop() {

FILE: tokio-stream/tests/mpsc_unbounded_stream.rs
  function size_hint_stream_open (line 6) | async fn size_hint_stream_open() {
  function size_hint_stream_closed (line 22) | async fn size_hint_stream_closed() {
  function size_hint_sender_dropped (line 39) | async fn size_hint_sender_dropped() {
  function size_hint_stream_instantly_closed (line 56) | fn size_hint_stream_instantly_closed() {

FILE: tokio-stream/tests/stream_chain.rs
  function basic_usage (line 12) | async fn basic_usage() {
  function visibility_test (line 43) | fn visibility_test<I, S1, S2>(s1: S1, s2: S2) -> Chain<S1, S2>
  function pending_first (line 53) | async fn pending_first() {
  function size_overflow (line 89) | fn size_overflow() {

FILE: tokio-stream/tests/stream_chunks_timeout.rs
  function stream_chunks_remainder (line 12) | async fn stream_chunks_remainder() -> Result<(), Box<dyn Error>> {

FILE: tokio-stream/tests/stream_close.rs
  function basic_usage (line 4) | async fn basic_usage() {

FILE: tokio-stream/tests/stream_collect.rs
  function empty_unit (line 14) | async fn empty_unit() {
  function empty_vec (line 22) | async fn empty_vec() {
  function empty_box_slice (line 28) | async fn empty_box_slice() {
  function empty_string (line 34) | async fn empty_string() {
  function empty_result (line 40) | async fn empty_result() {
  function collect_vec_items (line 46) | async fn collect_vec_items() {
  function collect_vecdeque_items (line 67) | async fn collect_vecdeque_items() {
  function collect_linkedlist_items (line 89) | async fn collect_linkedlist_items() {
  function collect_btreeset_items (line 111) | async fn collect_btreeset_items() {
  function collect_btreemap_items (line 132) | async fn collect_btreemap_items() {
  function collect_hashset_items (line 153) | async fn collect_hashset_items() {
  function collect_hashmap_items (line 174) | async fn collect_hashmap_items() {
  function collect_binaryheap_items (line 195) | async fn collect_binaryheap_items() {
  function collect_string_items (line 216) | async fn collect_string_items() {
  function collect_str_items (line 238) | async fn collect_str_items() {
  function collect_results_ok (line 260) | async fn collect_results_ok() {
  function collect_results_err (line 282) | async fn collect_results_err() {

FILE: tokio-stream/tests/stream_empty.rs
  function basic_usage (line 4) | async fn basic_usage() {

FILE: tokio-stream/tests/stream_fuse.rs
  type Alternate (line 7) | struct Alternate {
  type Item (line 12) | type Item = i32;
  method poll_next (line 14) | fn poll_next(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Op...
  function basic_usage (line 28) | async fn basic_usage() {
  function interval_stream_is_never_terminated (line 54) | async fn interval_stream_is_never_terminated() {

FILE: tokio-stream/tests/stream_iter.rs
  function coop (line 7) | async fn coop() {

FILE: tokio-stream/tests/stream_merge.rs
  function merge_sync_streams (line 12) | async fn merge_sync_streams() {
  function merge_async_streams (line 25) | async fn merge_async_streams() {
  function size_overflow (line 62) | fn size_overflow() {

FILE: tokio-stream/tests/stream_once.rs
  function basic_usage (line 4) | async fn basic_usage() {

FILE: tokio-stream/tests/stream_panic.rs
  function test_panic (line 12) | fn test_panic<Func: FnOnce() + panic::UnwindSafe>(func: Func) -> Option<...
  function stream_chunks_timeout_panic_caller (line 44) | fn stream_chunks_timeout_panic_caller() -> Result<(), Box<dyn Error>> {

FILE: tokio-stream/tests/stream_pending.rs
  function basic_usage (line 5) | async fn basic_usage() {

FILE: tokio-stream/tests/stream_stream_map.rs
  function empty (line 34) | async fn empty() {
  function single_entry (line 47) | async fn single_entry() {
  function multiple_entries (line 86) | async fn multiple_entries() {
  function insert_remove (line 145) | async fn insert_remove() {
  function replace (line 175) | async fn replace() {
  function size_hint_with_upper (line 202) | fn size_hint_with_upper() {
  function size_hint_without_upper (line 217) | fn size_hint_without_upper() {
  function new_capacity_zero (line 229) | fn new_capacity_zero() {
  function with_capacity (line 237) | fn with_capacity() {
  function iter_keys (line 245) | fn iter_keys() {
  function iter_values (line 259) | fn iter_values() {
  function iter_values_mut (line 274) | fn iter_values_mut() {
  function clear (line 292) | fn clear() {
  function contains_key_borrow (line 308) | fn contains_key_borrow() {
  function one_ready_many_none (line 316) | fn one_ready_many_none() {
  function pin_box (line 331) | fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream...
  type UsizeStream (line 335) | type UsizeStream = Pin<Box<dyn Stream<Item = usize> + Send>>;
  function poll_next_many_zero (line 338) | async fn poll_next_many_zero() {
  function poll_next_many_empty (line 349) | async fn poll_next_many_empty() {
  function poll_next_many_pending (line 358) | async fn poll_next_many_pending() {
  function poll_next_many_not_enough (line 377) | async fn poll_next_many_not_enough() {
  function poll_next_many_enough (line 393) | async fn poll_next_many_enough() {
  function poll_next_many_correctly_loops_around (line 409) | async fn poll_next_many_correctly_loops_around() {
  function next_many_zero (line 452) | async fn next_many_zero() {
  function next_many_empty (line 463) | async fn next_many_empty() {
  function next_many_pending (line 472) | async fn next_many_pending() {
  function next_many_not_enough (line 491) | async fn next_many_not_enough() {
  function next_many_enough (line 507) | async fn next_many_enough() {
  function next_many_correctly_loops_around (line 523) | async fn next_many_correctly_loops_around() {

FILE: tokio-stream/tests/stream_timeout.rs
  function maybe_sleep (line 9) | async fn maybe_sleep(idx: i32) -> i32 {
  function ms (line 16) | fn ms(n: u64) -> Duration {
  function basic_usage (line 21) | async fn basic_usage() {
  function return_elapsed_errors_only_once (line 68) | async fn return_elapsed_errors_only_once() {
  function no_timeouts (line 98) | async fn no_timeouts() {

FILE: tokio-stream/tests/support/mpsc.rs
  function unbounded_channel_stream (line 5) | pub fn unbounded_channel_stream<T: Unpin>() -> (UnboundedSender<T>, impl...

FILE: tokio-stream/tests/time_throttle.rs
  function usage (line 11) | async fn usage() {

FILE: tokio-stream/tests/watch.rs
  function watch_stream_message_not_twice (line 10) | async fn watch_stream_message_not_twice() {
  function watch_stream_from_rx (line 34) | async fn watch_stream_from_rx() {
  function watch_stream_from_changes (line 47) | async fn watch_stream_from_changes() {

FILE: tokio-test/src/io.rs
  type Mock (line 40) | pub struct Mock {
    method maybe_wakeup_reader (line 347) | fn maybe_wakeup_reader(&mut self) {
    method pmsg (line 574) | fn pmsg(&self) -> PanicMsgSnippet<'_> {
  type Handle (line 46) | pub struct Handle {
    method read (line 159) | pub fn read(&mut self, buf: &[u8]) -> &mut Self {
    method read_error (line 168) | pub fn read_error(&mut self, error: io::Error) -> &mut Self {
    method write (line 178) | pub fn write(&mut self, buf: &[u8]) -> &mut Self {
    method write_error (line 187) | pub fn write_error(&mut self, error: io::Error) -> &mut Self {
  type Builder (line 52) | pub struct Builder {
    method new (line 80) | pub fn new() -> Self {
    method read (line 88) | pub fn read(&mut self, buf: &[u8]) -> &mut Self {
    method read_error (line 97) | pub fn read_error(&mut self, error: io::Error) -> &mut Self {
    method write (line 107) | pub fn write(&mut self, buf: &[u8]) -> &mut Self {
    method write_error (line 116) | pub fn write_error(&mut self, error: io::Error) -> &mut Self {
    method wait (line 126) | pub fn wait(&mut self, duration: Duration) -> &mut Self {
    method name (line 133) | pub fn name(&mut self, name: impl Into<String>) -> &mut Self {
    method build (line 139) | pub fn build(&mut self) -> Mock {
    method build_with_handle (line 145) | pub fn build_with_handle(&mut self) -> (Mock, Handle) {
  type Action (line 59) | enum Action {
  type Inner (line 69) | struct Inner {
    method new (line 195) | fn new(actions: VecDeque<Action>, name: String) -> (Inner, Handle) {
    method poll_action (line 214) | fn poll_action(&mut self, cx: &mut task::Context<'_>) -> Poll<Option<A...
    method read (line 218) | fn read(&mut self, dst: &mut ReadBuf<'_>) -> io::Result<()> {
    method write (line 246) | fn write(&mut self, mut src: &[u8]) -> io::Result<usize> {
    method remaining_wait (line 292) | fn remaining_wait(&mut self) -> Option<Duration> {
    method action (line 299) | fn action(&mut self) -> Option<&mut Action> {
    method fmt (line 547) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method poll_read (line 360) | fn poll_read(
  method poll_write (line 408) | fn poll_write(
  method poll_flush (line 492) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut task::Context<'_>) -> Poll...
  method poll_shutdown (line 496) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut task::Context<'_>) -> P...
  method drop (line 503) | fn drop(&mut self) {
  type PanicMsgSnippet (line 556) | struct PanicMsgSnippet<'a>(&'a Inner);
  function fmt (line 559) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio-test/src/lib.rs
  function block_on (line 27) | pub fn block_on<F: std::future::Future>(future: F) -> F::Output {

FILE: tokio-test/src/stream_mock.rs
  type Action (line 47) | enum Action<T: Unpin> {
  type StreamMockBuilder (line 54) | pub struct StreamMockBuilder<T: Unpin> {
  function new (line 60) | pub fn new() -> Self {
  function next (line 65) | pub fn next(mut self, value: T) -> Self {
  function wait (line 79) | pub fn wait(mut self, duration: Duration) -> Self {
  function build (line 85) | pub fn build(self) -> StreamMock<T> {
  method default (line 94) | fn default() -> Self {
  type StreamMock (line 105) | pub struct StreamMock<T: Unpin> {
  function next_action (line 111) | fn next_action(&mut self) -> Option<Action<T>> {
  type Item (line 117) | type Item = T;
  method poll_next (line 119) | fn poll_next(
  method drop (line 147) | fn drop(&mut self) {

FILE: tokio-test/src/task.rs
  function spawn (line 42) | pub fn spawn<T>(task: T) -> Spawn<T> {
  type Spawn (line 53) | pub struct Spawn<T> {
  type MockTask (line 59) | struct MockTask {
    method new (line 159) | fn new() -> Self {
    method enter (line 169) | fn enter<F, R>(&mut self, f: F) -> R
    method is_woken (line 182) | fn is_woken(&self) -> bool {
    method waker_ref_count (line 189) | fn waker_ref_count(&self) -> usize {
    method waker (line 193) | fn waker(&self) -> Waker {
  type ThreadWaker (line 64) | struct ThreadWaker {
    method new (line 208) | fn new() -> Self {
    method clear (line 218) | fn clear(&self) {
    method is_woken (line 222) | fn is_woken(&self) -> bool {
    method wake (line 230) | fn wake(&self) {
  constant IDLE (line 69) | const IDLE: usize = 0;
  constant WAKE (line 70) | const WAKE: usize = 1;
  constant SLEEP (line 71) | const SLEEP: usize = 2;
  function into_inner (line 75) | pub fn into_inner(self) -> T
  function is_woken (line 84) | pub fn is_woken(&self) -> bool {
  function waker_ref_count (line 91) | pub fn waker_ref_count(&self) -> usize {
  function enter (line 96) | pub fn enter<F, R>(&mut self, f: F) -> R
  type Target (line 106) | type Target = T;
  function deref (line 108) | fn deref(&self) -> &T {
  function deref_mut (line 114) | fn deref_mut(&mut self) -> &mut T {
  function poll (line 122) | pub fn poll(&mut self) -> Poll<T::Output> {
  function poll_next (line 131) | pub fn poll_next(&mut self) -> Poll<Option<T::Item>> {
  type Output (line 138) | type Output = T::Output;
  method poll (line 140) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Item (line 146) | type Item = T::Item;
  method poll_next (line 148) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 152) | fn size_hint(&self) -> (usize, Option<usize>) {
  method default (line 202) | fn default() -> Self {
  function to_raw (line 253) | unsafe fn to_raw(waker: Arc<ThreadWaker>) -> RawWaker {
  function from_raw (line 257) | unsafe fn from_raw(raw: *const ()) -> Arc<ThreadWaker> {
  function clone (line 261) | unsafe fn clone(raw: *const ()) -> RawWaker {
  function wake (line 270) | unsafe fn wake(raw: *const ()) {
  function wake_by_ref (line 275) | unsafe fn wake_by_ref(raw: *const ()) {
  function drop_waker (line 283) | unsafe fn drop_waker(raw: *const ()) {

FILE: tokio-test/tests/block_on.rs
  function async_block (line 7) | fn async_block() {
  function five (line 11) | async fn five() -> u8 {
  function async_fn (line 16) | fn async_fn() {
  function test_sleep (line 21) | fn test_sleep() {

FILE: tokio-test/tests/io.rs
  function read (line 9) | async fn read() {
  function read_error (line 22) | async fn read_error() {
  function write (line 47) | async fn write() {
  function write_with_handle (line 55) | async fn write_with_handle() {
  function read_with_handle (line 65) | async fn read_with_handle() {
  function write_error (line 78) | async fn write_error() {
  function mock_panics_read_data_left (line 100) | async fn mock_panics_read_data_left() {
  function mock_panics_write_data_left (line 107) | async fn mock_panics_write_data_left() {
  function wait (line 113) | async fn wait() {
  function multiple_wait (line 143) | async fn multiple_wait() {

FILE: tokio-test/tests/macros.rs
  function ready (line 8) | fn ready() -> Poll<()> {
  function ready_ok (line 12) | fn ready_ok() -> Poll<Result<(), ()>> {
  function ready_err (line 16) | fn ready_err() -> Poll<Result<(), ()>> {
  function pending (line 20) | fn pending() -> Poll<()> {
  type Test (line 25) | enum Test {
  function assert_ready (line 30) | fn assert_ready() {
  function assert_ready_on_pending (line 40) | fn assert_ready_on_pending() {
  function assert_pending (line 46) | fn assert_pending() {
  function assert_pending_on_ready (line 56) | fn assert_pending_on_ready() {
  function assert_ready_ok (line 62) | fn assert_ready_ok() {
  function assert_ok_on_err (line 72) | fn assert_ok_on_err() {
  function assert_ready_err (line 78) | fn assert_ready_err() {
  function assert_err_on_ok (line 88) | fn assert_err_on_ok() {
  function assert_ready_eq (line 94) | fn assert_ready_eq() {
  function assert_eq_on_not_eq (line 104) | fn assert_eq_on_not_eq() {

FILE: tokio-test/tests/stream_mock.rs
  function test_stream_mock_empty (line 6) | async fn test_stream_mock_empty() {
  function test_stream_mock_items (line 14) | async fn test_stream_mock_items() {
  function test_stream_mock_wait (line 23) | async fn test_stream_mock_wait() {
  function test_stream_mock_drop_without_consuming_all (line 40) | async fn test_stream_mock_drop_without_consuming_all() {
  function test_stream_mock_drop_during_panic_doesnt_mask_panic (line 47) | async fn test_stream_mock_drop_during_panic_doesnt_mask_panic() {

FILE: tokio-test/tests/task.rs
  type SizedStream (line 7) | struct SizedStream;
  type Item (line 10) | type Item = ();
  method poll_next (line 12) | fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option...
  method size_hint (line 16) | fn size_hint(&self) -> (usize, Option<usize>) {
  function test_spawn_stream_size_hint (line 22) | fn test_spawn_stream_size_hint() {

FILE: tokio-util/src/codec/any_delimiter_codec.rs
  constant DEFAULT_SEEK_DELIMITERS (line 7) | const DEFAULT_SEEK_DELIMITERS: &[u8] = b",;\n\r";
  constant DEFAULT_SEQUENCE_WRITER (line 8) | const DEFAULT_SEQUENCE_WRITER: &[u8] = b",";
  type AnyDelimiterCodec (line 41) | pub struct AnyDelimiterCodec {
    method new (line 75) | pub fn new(seek_delimiters: Vec<u8>, sequence_writer: Vec<u8>) -> AnyD...
    method new_with_max_length (line 103) | pub fn new_with_max_length(
    method max_length (line 129) | pub fn max_length(&self) -> usize {
    type Error (line 214) | type Error = AnyDelimiterCodecError;
    method encode (line 216) | fn encode(&mut self, chunk: T, buf: &mut BytesMut) -> Result<(), AnyDe...
  type Item (line 135) | type Item = Bytes;
  type Error (line 136) | type Error = AnyDelimiterCodecError;
  method decode (line 138) | fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Bytes>, AnyDel...
  method decode_eof (line 193) | fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Bytes>, An...
  method default (line 227) | fn default() -> Self {
  type AnyDelimiterCodecError (line 237) | pub enum AnyDelimiterCodecError {
    method fmt (line 245) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 256) | fn from(e: io::Error) -> AnyDelimiterCodecError {

FILE: tokio-util/src/codec/bytes_codec.rs
  type BytesCodec (line 45) | pub struct BytesCodec(());
    method new (line 49) | pub fn new() -> BytesCodec {
    type Error (line 69) | type Error = io::Error;
    method encode (line 71) | fn encode(&mut self, data: Bytes, buf: &mut BytesMut) -> Result<(), io...
    type Error (line 79) | type Error = io::Error;
    method encode (line 81) | fn encode(&mut self, data: BytesMut, buf: &mut BytesMut) -> Result<(),...
  type Item (line 55) | type Item = BytesMut;
  type Error (line 56) | type Error = io::Error;
  method decode (line 58) | fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<BytesMut>, io:...

FILE: tokio-util/src/codec/decoder.rs
  type Decoder (line 35) | pub trait Decoder {
    method decode (line 124) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>,...
    method decode_eof (line 144) | fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::It...
    method framed (line 178) | fn framed<T: AsyncRead + AsyncWrite + Sized>(self, io: T) -> Framed<T,...

FILE: tokio-util/src/codec/encoder.rs
  type Encoder (line 8) | pub trait Encoder<Item> {
    method encode (line 24) | fn encode(&mut self, item: Item, dst: &mut BytesMut) -> Result<(), Sel...

FILE: tokio-util/src/codec/framed.rs
  function new (line 73) | pub fn new(inner: T, codec: U) -> Framed<T, U> {
  function with_capacity (line 107) | pub fn with_capacity(inner: T, codec: U, capacity: usize) -> Framed<T, U> {
  function from_parts (line 155) | pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
  function get_ref (line 174) | pub fn get_ref(&self) -> &T {
  function get_mut (line 184) | pub fn get_mut(&mut self) -> &mut T {
  function get_pin_mut (line 194) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
  function codec (line 203) | pub fn codec(&self) -> &U {
  function codec_mut (line 212) | pub fn codec_mut(&mut self) -> &mut U {
  function map_codec (line 221) | pub fn map_codec<C, F>(self, map: F) -> Framed<T, C>
  function codec_pin_mut (line 241) | pub fn codec_pin_mut(self: Pin<&mut Self>) -> &mut U {
  function read_buffer (line 246) | pub fn read_buffer(&self) -> &BytesMut {
  function read_buffer_mut (line 251) | pub fn read_buffer_mut(&mut self) -> &mut BytesMut {
  function write_buffer (line 256) | pub fn write_buffer(&self) -> &BytesMut {
  function write_buffer_mut (line 261) | pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
  function backpressure_boundary (line 266) | pub fn backpressure_boundary(&self) -> usize {
  function set_backpressure_boundary (line 271) | pub fn set_backpressure_boundary(&mut self, boundary: usize) {
  function into_inner (line 280) | pub fn into_inner(self) -> T {
  function into_parts (line 290) | pub fn into_parts(self) -> FramedParts<T, U> {
  type Item (line 307) | type Item = Result<U::Item, U::Error>;
  method poll_next (line 309) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Error (line 321) | type Error = U::Error;
  function poll_ready (line 323) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 327) | fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
  function poll_flush (line 331) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 335) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function fmt (line 345) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FramedParts (line 360) | pub struct FramedParts<T, U> {
  function new (line 380) | pub fn new<I>(io: T, codec: U) -> FramedParts<T, U>

FILE: tokio-util/src/codec/framed_impl.rs
  constant INITIAL_CAPACITY (line 25) | const INITIAL_CAPACITY: usize = 8 * 1024;
  type ReadFrame (line 28) | pub(crate) struct ReadFrame {
    method from (line 67) | fn from(mut buffer: BytesMut) -> Self {
  type WriteFrame (line 35) | pub(crate) struct WriteFrame {
    method from (line 84) | fn from(mut buffer: BytesMut) -> Self {
  type RWFrames (line 41) | pub(crate) struct RWFrames {
    method borrow (line 98) | fn borrow(&self) -> &ReadFrame {
    method borrow_mut (line 103) | fn borrow_mut(&mut self) -> &mut ReadFrame {
    method borrow (line 108) | fn borrow(&self) -> &WriteFrame {
    method borrow_mut (line 113) | fn borrow_mut(&mut self) -> &mut WriteFrame {
  method default (line 47) | fn default() -> Self {
  method default (line 58) | fn default() -> Self {
  type Item (line 123) | type Item = Result<U::Item, U::Error>;
  method poll_next (line 125) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Error (line 260) | type Error = U::Error;
  function poll_ready (line 262) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function start_send (line 270) | fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
  function poll_flush (line 278) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 306) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...

FILE: tokio-util/src/codec/framed_read.rs
  function new (line 41) | pub fn new(inner: T, decoder: D) -> FramedRead<T, D> {
  function with_capacity (line 53) | pub fn with_capacity(inner: T, decoder: D, capacity: usize) -> FramedRea...
  function get_ref (line 74) | pub fn get_ref(&self) -> &T {
  function get_mut (line 84) | pub fn get_mut(&mut self) -> &mut T {
  function get_pin_mut (line 94) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
  function into_inner (line 103) | pub fn into_inner(self) -> T {
  function decoder (line 108) | pub fn decoder(&self) -> &D {
  function decoder_mut (line 113) | pub fn decoder_mut(&mut self) -> &mut D {
  function map_decoder (line 119) | pub fn map_decoder<C, F>(self, map: F) -> FramedRead<T, C>
  function decoder_pin_mut (line 139) | pub fn decoder_pin_mut(self: Pin<&mut Self>) -> &mut D {
  function read_buffer (line 144) | pub fn read_buffer(&self) -> &BytesMut {
  function read_buffer_mut (line 149) | pub fn read_buffer_mut(&mut self) -> &mut BytesMut {
  function into_parts (line 155) | pub fn into_parts(self) -> FramedParts<T, D> {
  type Item (line 172) | type Item = Result<D::Item, D::Error>;
  method poll_next (line 174) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Error (line 184) | type Error = T::Error;
  function poll_ready (line 186) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 190) | fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
  function poll_flush (line 194) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 198) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function fmt (line 208) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio-util/src/codec/framed_write.rs
  function new (line 40) | pub fn new(inner: T, encoder: E) -> FramedWrite<T, E> {
  function with_capacity (line 52) | pub fn with_capacity(inner: T, encoder: E, capacity: usize) -> FramedWri...
  function get_ref (line 71) | pub fn get_ref(&self) -> &T {
  function get_mut (line 81) | pub fn get_mut(&mut self) -> &mut T {
  function get_pin_mut (line 91) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
  function into_inner (line 100) | pub fn into_inner(self) -> T {
  function encoder (line 105) | pub fn encoder(&self) -> &E {
  function encoder_mut (line 110) | pub fn encoder_mut(&mut self) -> &mut E {
  function map_encoder (line 116) | pub fn map_encoder<C, F>(self, map: F) -> FramedWrite<T, C>
  function encoder_pin_mut (line 136) | pub fn encoder_pin_mut(self: Pin<&mut Self>) -> &mut E {
  function write_buffer (line 141) | pub fn write_buffer(&self) -> &BytesMut {
  function write_buffer_mut (line 146) | pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
  function backpressure_boundary (line 151) | pub fn backpressure_boundary(&self) -> usize {
  function set_backpressure_boundary (line 156) | pub fn set_backpressure_boundary(&mut self, boundary: usize) {
  function into_parts (line 162) | pub fn into_parts(self) -> FramedParts<T, E> {
  type Error (line 180) | type Error = E::Error;
  function poll_ready (line 182) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 186) | fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
  function poll_flush (line 190) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 194) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  type Item (line 204) | type Item = T::Item;
  method poll_next (line 206) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function fmt (line 216) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio-util/src/codec/length_delimited.rs
  type Builder (line 416) | pub struct Builder {
    method new (line 691) | pub fn new() -> Builder {
    method big_endian (line 732) | pub fn big_endian(&mut self) -> &mut Self {
    method little_endian (line 756) | pub fn little_endian(&mut self) -> &mut Self {
    method native_endian (line 780) | pub fn native_endian(&mut self) -> &mut Self {
    method max_frame_length (line 814) | pub fn max_frame_length(&mut self, val: usize) -> &mut Self {
    method length_field_type (line 851) | pub fn length_field_type<T: builder::LengthFieldType>(&mut self) -> &m...
    method length_field_length (line 874) | pub fn length_field_length(&mut self, val: usize) -> &mut Self {
    method length_field_offset (line 897) | pub fn length_field_offset(&mut self, val: usize) -> &mut Self {
    method length_adjustment (line 918) | pub fn length_adjustment(&mut self, val: isize) -> &mut Self {
    method num_skip (line 942) | pub fn num_skip(&mut self, val: usize) -> &mut Self {
    method new_codec (line 962) | pub fn new_codec(&self) -> LengthDelimitedCodec {
    method new_read (line 991) | pub fn new_read<T>(&self, upstream: T) -> FramedRead<T, LengthDelimite...
    method new_write (line 1012) | pub fn new_write<T>(&self, inner: T) -> FramedWrite<T, LengthDelimited...
    method new_framed (line 1034) | pub fn new_framed<T>(&self, inner: T) -> Framed<T, LengthDelimitedCodec>
    method num_head_bytes (line 1041) | fn num_head_bytes(&self) -> usize {
    method get_num_skip (line 1046) | fn get_num_skip(&self) -> usize {
    method adjust_max_frame_len (line 1051) | fn adjust_max_frame_len(&mut self) {
  type LengthDelimitedCodecError (line 438) | pub struct LengthDelimitedCodecError {
    method fmt (line 1075) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 1081) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LengthDelimitedCodec (line 451) | pub struct LengthDelimitedCodec {
    method new (line 469) | pub fn new() -> Self {
    method builder (line 478) | pub fn builder() -> Builder {
    method max_frame_length (line 486) | pub fn max_frame_length(&self) -> usize {
    method set_max_frame_length (line 496) | pub fn set_max_frame_length(&mut self, val: usize) {
    method decode_head (line 500) | fn decode_head(&mut self, src: &mut BytesMut) -> io::Result<Option<usi...
    method decode_data (line 560) | fn decode_data(&self, n: usize, src: &mut BytesMut) -> Option<BytesMut> {
    type Error (line 603) | type Error = io::Error;
    method encode (line 605) | fn encode(&mut self, data: Bytes, dst: &mut BytesMut) -> Result<(), io...
  type DecodeState (line 460) | enum DecodeState {
  type Item (line 572) | type Item = BytesMut;
  type Error (line 573) | type Error = io::Error;
  method decode (line 575) | fn decode(&mut self, src: &mut BytesMut) -> io::Result<Option<BytesMut>> {
  method default (line 647) | fn default() -> Self {
  type LengthFieldType (line 656) | pub trait LengthFieldType {}
  method default (line 1067) | fn default() -> Self {

FILE: tokio-util/src/codec/lines_codec.rs
  type LinesCodec (line 14) | pub struct LinesCodec {
    method new (line 42) | pub fn new() -> LinesCodec {
    method new_with_max_length (line 68) | pub fn new_with_max_length(max_length: usize) -> Self {
    method max_length (line 90) | pub fn max_length(&self) -> usize {
    type Error (line 191) | type Error = LinesCodecError;
    method encode (line 193) | fn encode(&mut self, line: T, buf: &mut BytesMut) -> Result<(), LinesC...
  function utf8 (line 95) | fn utf8(buf: &[u8]) -> Result<&str, io::Error> {
  function without_carriage_return (line 100) | fn without_carriage_return(s: &[u8]) -> &[u8] {
  type Item (line 109) | type Item = String;
  type Error (line 110) | type Error = LinesCodecError;
  method decode (line 112) | fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<String>, Lines...
  method decode_eof (line 168) | fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<String>, L...
  method default (line 203) | fn default() -> Self {
  type LinesCodecError (line 210) | pub enum LinesCodecError {
    method fmt (line 218) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 227) | fn from(e: io::Error) -> LinesCodecError {

FILE: tokio-util/src/compat.rs
  type FuturesAsyncReadCompatExt (line 132) | pub trait FuturesAsyncReadCompatExt: futures_io::AsyncRead {
    method compat (line 135) | fn compat(self) -> Compat<Self>
  type FuturesAsyncWriteCompatExt (line 147) | pub trait FuturesAsyncWriteCompatExt: futures_io::AsyncWrite {
    method compat_write (line 150) | fn compat_write(self) -> Compat<Self>
  type TokioAsyncReadCompatExt (line 162) | pub trait TokioAsyncReadCompatExt: tokio::io::AsyncRead {
    method compat (line 165) | fn compat(self) -> Compat<Self>
  type TokioAsyncWriteCompatExt (line 177) | pub trait TokioAsyncWriteCompatExt: tokio::io::AsyncWrite {
    method compat_write (line 180) | fn compat_write(self) -> Compat<Self>
  function new (line 193) | fn new(inner: T) -> Self {
  function get_ref (line 202) | pub fn get_ref(&self) -> &T {
  function get_mut (line 208) | pub fn get_mut(&mut self) -> &mut T {
  function into_inner (line 213) | pub fn into_inner(self) -> T {
  function poll_read (line 222) | fn poll_read(
  function poll_read (line 244) | fn poll_read(
  function poll_fill_buf (line 263) | fn poll_fill_buf<'a>(
  function consume (line 270) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function poll_fill_buf (line 279) | fn poll_fill_buf<'a>(
  function consume (line 286) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function poll_write (line 295) | fn poll_write(
  function poll_flush (line 303) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_shutdown (line 307) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  function poll_write (line 316) | fn poll_write(
  function poll_flush (line 324) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_close (line 328) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_seek (line 334) | fn poll_seek(
  function start_seek (line 352) | fn start_seek(mut self: Pin<&mut Self>, pos: io::SeekFrom) -> io::Result...
  function poll_complete (line 357) | fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  function as_raw_fd (line 376) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
  function as_raw_handle (line 383) | fn as_raw_handle(&self) -> std::os::windows::io::RawHandle {

FILE: tokio-util/src/context.rs
  function new (line 119) | pub fn new(future: F, handle: Handle) -> TokioContext<F> {
  function handle (line 127) | pub fn handle(&self) -> &Handle {
  function into_inner (line 132) | pub fn into_inner(self) -> F {
  type Output (line 138) | type Output = F::Output;
  method poll (line 140) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type RuntimeExt (line 151) | pub trait RuntimeExt {
    method wrap (line 189) | fn wrap<F: Future>(&self, fut: F) -> TokioContext<F>;
    method wrap (line 193) | fn wrap<F: Future>(&self, fut: F) -> TokioContext<F> {

FILE: tokio-util/src/either.rs
  type Either (line 64) | pub enum Either<L, R> {
  type Output (line 88) | type Output = O;
  method poll (line 90) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method poll_read (line 100) | fn poll_read(
  method poll_fill_buf (line 114) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method consume (line 118) | fn consume(self: Pin<&mut Self>, amt: usize) {
  method start_seek (line 128) | fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<()> {
  method poll_complete (line 132) | fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write (line 142) | fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) ->...
  method poll_flush (line 146) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<tokio:...
  method poll_shutdown (line 150) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<tok...
  method poll_write_vectored (line 154) | fn poll_write_vectored(
  method is_write_vectored (line 162) | fn is_write_vectored(&self) -> bool {
  type Item (line 175) | type Item = L::Item;
  function poll_next (line 177) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Error (line 187) | type Error = Error;
  function poll_ready (line 189) | fn poll_ready(
  function start_send (line 196) | fn start_send(self: Pin<&mut Self>, item: Item) -> std::result::Result<(...
  function poll_flush (line 200) | fn poll_flush(
  function poll_close (line 207) | fn poll_close(
  function either_is_stream (line 222) | async fn either_is_stream() {
  function either_is_async_read (line 229) | async fn either_is_async_read() {

FILE: tokio-util/src/future.rs
  type FutureExt (line 11) | pub trait FutureExt: Future {
    method with_cancellation_token (line 89) | fn with_cancellation_token(
    method with_cancellation_token_owned (line 126) | fn with_cancellation_token_owned(

FILE: tokio-util/src/future/with_cancellation_token.rs
  function new (line 26) | pub(crate) fn new(cancellation_token: &'a CancellationToken, future: F) ...
  type Output (line 35) | type Output = Option<F::Output>;
  method poll (line 37) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function new (line 61) | pub(crate) fn new(cancellation_token: CancellationToken, future: F) -> S...
  type Output (line 70) | type Output = Option<F::Output>;
  method poll (line 72) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio-util/src/io/copy_to_bytes.rs
  function new (line 26) | pub fn new(inner: S) -> Self {
  function get_ref (line 31) | pub fn get_ref(&self) -> &S {
  function get_mut (line 36) | pub fn get_mut(&mut self) -> &mut S {
  function into_inner (line 41) | pub fn into_inner(self) -> S {
  type Error (line 50) | type Error = S::Error;
  function poll_ready (line 52) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 56) | fn start_send(self: Pin<&mut Self>, item: &'a [u8]) -> Result<(), Self::...
  function poll_flush (line 62) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 66) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  type Item (line 72) | type Item = S::Item;
  method poll_next (line 73) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: tokio-util/src/io/inspect.rs
  function new (line 26) | pub fn new(reader: R, f: F) -> InspectReader<R, F>
  function into_inner (line 35) | pub fn into_inner(self) -> R {
  method poll_read (line 41) | fn poll_read(
  method poll_write (line 55) | fn poll_write(
  method poll_flush (line 63) | fn poll_flush(
  method poll_shutdown (line 70) | fn poll_shutdown(
  method poll_write_vectored (line 77) | fn poll_write_vectored(
  method is_write_vectored (line 85) | fn is_write_vectored(&self) -> bool {
  function new (line 108) | pub fn new(writer: W, f: F) -> InspectWriter<W, F>
  function into_inner (line 117) | pub fn into_inner(self) -> W {
  method poll_write (line 123) | fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) ->...
  method poll_flush (line 134) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 139) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write_vectored (line 144) | fn poll_write_vectored(
  method is_write_vectored (line 166) | fn is_write_vectored(&self) -> bool {
  method poll_read (line 172) | fn poll_read(

FILE: tokio-util/src/io/read_arc.rs
  function read_exact_arc (line 25) | pub async fn read_exact_arc<R: AsyncRead>(read: R, len: usize) -> io::Re...

FILE: tokio-util/src/io/read_buf.rs
  function read_buf (line 43) | pub async fn read_buf<R, B>(read: &mut R, buf: &mut B) -> io::Result<usize>

FILE: tokio-util/src/io/reader_stream.rs
  constant DEFAULT_CAPACITY (line 8) | const DEFAULT_CAPACITY: usize = 4096;
  function new (line 68) | pub fn new(reader: R) -> Self {
  function with_capacity (line 82) | pub fn with_capacity(reader: R, capacity: usize) -> Self {
  type Item (line 92) | type Item = std::io::Result<Bytes>;
  method poll_next (line 93) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: tokio-util/src/io/simplex.rs
  type IoResult (line 16) | type IoResult<T> = Result<T, IoError>;
  constant CLOSED_ERROR_MSG (line 18) | const CLOSED_ERROR_MSG: &str = "simplex has been closed";
  type Inner (line 21) | struct Inner {
    method with_capacity (line 39) | fn with_capacity(capacity: usize) -> Self {
    method register_receiver_waker (line 49) | fn register_receiver_waker(&mut self, waker: &Waker) -> Option<Waker> {
    method register_sender_waker (line 56) | fn register_sender_waker(&mut self, waker: &Waker) -> Option<Waker> {
    method take_receiver_waker (line 63) | fn take_receiver_waker(&mut self) -> Option<Waker> {
    method take_sender_waker (line 67) | fn take_sender_waker(&mut self) -> Option<Waker> {
    method is_closed (line 71) | fn is_closed(&self) -> bool {
    method close_receiver (line 75) | fn close_receiver(&mut self) -> Option<Waker> {
    method close_sender (line 80) | fn close_sender(&mut self) -> Option<Waker> {
  type Receiver (line 101) | pub struct Receiver {
  method drop (line 107) | fn drop(&mut self) {
  method poll_read (line 120) | fn poll_read(
  type Sender (line 177) | pub struct Sender {
  method drop (line 183) | fn drop(&mut self) {
  method poll_write (line 200) | fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) ->...
  method poll_flush (line 250) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<IoRes...
  method poll_shutdown (line 265) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Io...
  method is_write_vectored (line 278) | fn is_write_vectored(&self) -> bool {
  method poll_write_vectored (line 282) | fn poll_write_vectored(
  function new (line 351) | pub fn new(capacity: usize) -> (Sender, Receiver) {

FILE: tokio-util/src/io/sink_writer.rs
  function new (line 72) | pub fn new(sink: S) -> Self {
  function get_ref (line 77) | pub fn get_ref(&self) -> &S {
  function get_mut (line 82) | pub fn get_mut(&mut self) -> &mut S {
  function into_inner (line 87) | pub fn into_inner(self) -> S {
  method poll_write (line 96) | fn poll_write(
  method poll_flush (line 110) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 114) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  type Item (line 120) | type Item = S::Item;
  method poll_next (line 121) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method poll_read (line 127) | fn poll_read(

FILE: tokio-util/src/io/stream_reader.rs
  type StreamReader (line 156) | pub struct StreamReader<S, B> {
  function new (line 178) | pub fn new(stream: S) -> Self {
  function has_chunk (line 186) | fn has_chunk(&self) -> bool {
  function into_inner_with_chunk (line 197) | pub fn into_inner_with_chunk(self) -> (S, Option<B>) {
  function get_ref (line 210) | pub fn get_ref(&self) -> &S {
  function get_mut (line 217) | pub fn get_mut(&mut self) -> &mut S {
  function get_pin_mut (line 224) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut S> {
  function into_inner (line 235) | pub fn into_inner(self) -> S {
  method poll_read (line 246) | fn poll_read(
  method poll_fill_buf (line 274) | fn poll_fill_buf(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method consume (line 293) | fn consume(self: Pin<&mut Self>, amt: usize) {
  type StreamReaderProject (line 311) | struct StreamReaderProject<'a, S, B> {
  function project (line 318) | fn project(self: Pin<&mut Self>) -> StreamReaderProject<'_, S, B> {
  type Error (line 330) | type Error = E;
  function poll_ready (line 331) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 335) | fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
  function poll_flush (line 339) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 343) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...

FILE: tokio-util/src/io/sync_bridge.rs
  type SyncIoBridge (line 264) | pub struct SyncIoBridge<T> {
  method fill_buf (line 270) | fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
  method consume (line 275) | fn consume(&mut self, amt: usize) {
  method read_until (line 280) | fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> std::io::Result...
  method read_line (line 285) | fn read_line(&mut self, buf: &mut String) -> std::io::Result<usize> {
  method read (line 292) | fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
  method read_to_end (line 297) | fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
  method read_to_string (line 302) | fn read_to_string(&mut self, buf: &mut String) -> std::io::Result<usize> {
  method read_exact (line 307) | fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
  method write (line 316) | fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
  method flush (line 321) | fn flush(&mut self) -> std::io::Result<()> {
  method write_all (line 326) | fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
  method write_vectored (line 331) | fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::...
  method seek (line 338) | fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
  function is_write_vectored (line 350) | pub fn is_write_vectored(&self) -> bool {
  function shutdown (line 364) | pub fn shutdown(&mut self) -> std::io::Result<()> {
  function new (line 393) | pub fn new(src: T) -> Self {
  function new_with_handle (line 402) | pub fn new_with_handle(src: T, rt: tokio::runtime::Handle) -> Self {
  function into_inner (line 407) | pub fn into_inner(self) -> T {
  function as_mut (line 413) | fn as_mut(&mut self) -> &mut T {
  function as_ref (line 419) | fn as_ref(&self) -> &T {

FILE: tokio-util/src/io/write_all_vectored.rs
  function write_all_vectored (line 86) | pub fn write_all_vectored<'a, 'b, W>(
  type Output (line 104) | type Output = io::Result<()>;
  method poll (line 106) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<(...
  function advance_slices (line 131) | fn advance_slices<'a>(bufs: &mut &mut [IoSlice<'a>], n: usize) {

FILE: tokio-util/src/net/mod.rs
  type Listener (line 15) | pub trait Listener {
    method poll_accept (line 22) | fn poll_accept(&mut self, cx: &mut Context<'_>) -> Poll<Result<(Self::...
    method accept (line 25) | fn accept(&mut self) -> ListenerAcceptFut<'_, Self>
    method local_addr (line 33) | fn local_addr(&self) -> Result<Self::Addr>;
    type Io (line 37) | type Io = tokio::net::TcpStream;
    type Addr (line 38) | type Addr = std::net::SocketAddr;
    method poll_accept (line 40) | fn poll_accept(&mut self, cx: &mut Context<'_>) -> Poll<Result<(Self::...
    method local_addr (line 44) | fn local_addr(&self) -> Result<Self::Addr> {
  type ListenerAcceptFut (line 52) | pub struct ListenerAcceptFut<'a, L> {
  type Output (line 60) | type Output = Result<(L::Io, L::Addr)>;
  method poll (line 62) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function accept (line 73) | pub async fn accept(&mut self) -> Result<Either<(L::Io, L::Addr), (R::Io...
  function local_addr (line 87) | pub fn local_addr(&self) -> Result<Either<L::Addr, R::Addr>> {

FILE: tokio-util/src/net/unix/mod.rs
  type Io (line 8) | type Io = tokio::net::UnixStream;
  type Addr (line 9) | type Addr = tokio::net::unix::SocketAddr;
  method poll_accept (line 11) | fn poll_accept(&mut self, cx: &mut Context<'_>) -> Poll<Result<(Self::Io...
  method local_addr (line 15) | fn local_addr(&self) -> Result<Self::Addr> {

FILE: tokio-util/src/sync/cancellation_token.rs
  type CancellationToken (line 57) | pub struct CancellationToken {
    method fmt (line 107) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method new (line 139) | pub fn new() -> CancellationToken {
    method child_token (line 184) | pub fn child_token(&self) -> CancellationToken {
    method cancel (line 200) | pub fn cancel(&self) {
    method is_cancelled (line 205) | pub fn is_cancelled(&self) -> bool {
    method cancelled (line 223) | pub fn cancelled(&self) -> WaitForCancellationFuture<'_> {
    method cancelled_owned (line 247) | pub fn cancelled_owned(self) -> WaitForCancellationFutureOwned {
    method drop_guard (line 255) | pub fn drop_guard(self) -> DropGuard {
    method drop_guard_ref (line 263) | pub fn drop_guard_ref(&self) -> DropGuardRef<'_> {
    method run_until_cancelled (line 280) | pub async fn run_until_cancelled<F>(&self, fut: F) -> Option<F::Output>
    method run_until_cancelled_owned (line 310) | pub async fn run_until_cancelled_owned<F>(self, fut: F) -> Option<F::O...
  method clone (line 117) | fn clone(&self) -> Self {
  method drop (line 126) | fn drop(&mut self) {
  method default (line 132) | fn default() -> CancellationToken {
  function fmt (line 321) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Output (line 327) | type Output = ();
  method poll (line 329) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  method fmt (line 352) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method new (line 358) | fn new(cancellation_token: CancellationToken) -> Self {
  method new_future (line 375) | unsafe fn new_future(
  type Output (line 387) | type Output = ();
  method poll (line 389) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  function new (line 429) | pub(crate) fn new(cancellation_token: &'a CancellationToken, future: F) ...
  type Output (line 438) | type Output = Option<F::Output>;
  method poll (line 440) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 466) | type Output = Option<F::Output>;
  method poll (line 468) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function new (line 481) | pub(crate) fn new(cancellation_token: CancellationToken, future: F) -> S...

FILE: tokio-util/src/sync/cancellation_token/guard.rs
  type DropGuard (line 8) | pub struct DropGuard {
    method disarm (line 16) | pub fn disarm(mut self) -> CancellationToken {
  method drop (line 24) | fn drop(&mut self) {

FILE: tokio-util/src/sync/cancellation_token/guard_ref.rs
  type DropGuardRef (line 11) | pub struct DropGuardRef<'a> {
  function disarm (line 19) | pub fn disarm(mut self) -> &'a CancellationToken {
  method drop (line 27) | fn drop(&mut self) {

FILE: tokio-util/src/sync/cancellation_token/tree_node.rs
  type TreeNode (line 46) | pub(crate) struct TreeNode {
    method new (line 51) | pub(crate) fn new() -> Self {
    method notified (line 64) | pub(crate) fn notified(&self) -> tokio::sync::futures::Notified<'_> {
  type Inner (line 73) | struct Inner {
  function is_cancelled (line 82) | pub(crate) fn is_cancelled(node: &Arc<TreeNode>) -> bool {
  function child_node (line 87) | pub(crate) fn child_node(parent: &Arc<TreeNode>) -> Arc<TreeNode> {
  function disconnect_children (line 125) | fn disconnect_children(node: &mut Inner) {
  function with_locked_node_and_parent (line 150) | fn with_locked_node_and_parent<F, Ret>(node: &Arc<TreeNode>, func: F) ->...
  function move_children_to_parent (line 202) | fn move_children_to_parent(node: &mut Inner, parent: &mut Inner) {
  function remove_child (line 220) | fn remove_child(parent: &mut Inner, mut node: MutexGuard<'_, Inner>) {
  function increase_handle_refcount (line 249) | pub(crate) fn increase_handle_refcount(node: &Arc<TreeNode>) {
  function decrease_handle_refcount (line 263) | pub(crate) fn decrease_handle_refcount(node: &Arc<TreeNode>) {
  function cancel (line 297) | pub(crate) fn cancel(node: &Arc<TreeNode>) {

FILE: tokio-util/src/sync/mpsc.rs
  type PollSendError (line 12) | pub struct PollSendError<T>(Option<T>);
  function into_inner (line 19) | pub fn into_inner(self) -> Option<T> {
  function fmt (line 25) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type State (line 33) | enum State<T> {
  type PollSender (line 44) | pub struct PollSender<T> {
  function make_acquire_future (line 55) | async fn make_acquire_future<T>(
  type InnerFuture (line 67) | type InnerFuture<'a, T> = ReusableBoxFuture<'a, Result<OwnedPermit<T>, P...
  type PollSenderFuture (line 71) | struct PollSenderFuture<T>(InnerFuture<'static, T>);
  function empty (line 75) | fn empty() -> Self {
  function new (line 84) | fn new() -> Self {
  function poll (line 91) | fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Result<OwnedPermit<T>, ...
  function set (line 96) | fn set(&mut self, sender: Option<Sender<T>>) {
  function new (line 112) | pub fn new(sender: Sender<T>) -> Self {
  function take_state (line 120) | fn take_state(&mut self) -> State<T> {
  function poll_reserve (line 137) | pub fn poll_reserve(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), ...
  function send_item (line 183) | pub fn send_item(&mut self, value: T) -> Result<(), PollSendError<T>> {
  function is_closed (line 206) | pub fn is_closed(&self) -> bool {
  function get_ref (line 214) | pub fn get_ref(&self) -> Option<&Sender<T>> {
  function close (line 230) | pub fn close(&mut self) {
  function abort_send (line 252) | pub fn abort_send(&mut self) -> bool {
  method clone (line 292) | fn clone(&self) -> PollSender<T> {
  type Error (line 307) | type Error = PollSendError<T>;
  function poll_ready (line 309) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_flush (line 313) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  function start_send (line 317) | fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
  function poll_close (line 321) | fn poll_close(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...

FILE: tokio-util/src/sync/poll_semaphore.rs
  type PollSemaphore (line 13) | pub struct PollSemaphore {
    method new (line 23) | pub fn new(semaphore: Arc<Semaphore>) -> Self {
    method close (line 31) | pub fn close(&self) {
    method clone_inner (line 36) | pub fn clone_inner(&self) -> Arc<Semaphore> {
    method into_inner (line 41) | pub fn into_inner(self) -> Arc<Semaphore> {
    method poll_acquire (line 58) | pub fn poll_acquire(&mut self, cx: &mut Context<'_>) -> Poll<Option<Ow...
    method poll_acquire_many (line 75) | pub fn poll_acquire_many(
    method available_permits (line 127) | pub fn available_permits(&self) -> usize {
    method add_permits (line 140) | pub fn add_permits(&self, n: usize) {
    method fmt (line 160) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method as_ref (line 168) | fn as_ref(&self) -> &Semaphore {
  type Item (line 146) | type Item = OwnedSemaphorePermit;
  method poll_next (line 148) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method clone (line 154) | fn clone(&self) -> PollSemaphore {

FILE: tokio-util/src/sync/reusable_box.rs
  type ReusableBoxFuture (line 13) | pub struct ReusableBoxFuture<'a, T> {
  function new (line 19) | pub fn new<F>(future: F) -> Self
  function set (line 32) | pub fn set<F>(&mut self, future: F)
  function try_set (line 46) | pub fn try_set<F>(&mut self, future: F) -> Result<(), F>
  function get_pin (line 71) | pub fn get_pin(&mut self) -> Pin<&mut (dyn Future<Output = T> + Send)> {
  function poll (line 76) | pub fn poll(&mut self, cx: &mut Context<'_>) -> Poll<T> {
  type Output (line 82) | type Output = T;
  method poll (line 85) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
  function fmt (line 96) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function reuse_pin_box (line 101) | fn reuse_pin_box<T: ?Sized, U, O, F>(boxed: Pin<Box<T>>, new_value: U, c...
  type CallOnDrop (line 136) | struct CallOnDrop<O, F: FnOnce() -> O> {
  function new (line 141) | fn new(f: F) -> Self {
  function call (line 145) | fn call(self) -> O {
  method drop (line 153) | fn drop(&mut self) {

FILE: tokio-util/src/sync/tests/loom_cancellation_token.rs
  function cancel_token (line 7) | fn cancel_token() {
  function cancel_token_owned (line 28) | fn cancel_token_owned() {
  function cancel_with_child (line 49) | fn cancel_with_child() {
  function drop_token_no_child (line 79) | fn drop_token_no_child() {
  function drop_token_with_children (line 107) | fn drop_token_with_children() {
  function drop_and_cancel_token (line 135) | fn drop_and_cancel_token() {
  function cancel_parent_and_child (line 163) | fn cancel_parent_and_child() {

FILE: tokio-util/src/task/abort_on_drop.rs
  type AbortOnDropHandle (line 21) | pub struct AbortOnDropHandle<T>(JoinHandle<T>);
  method drop (line 24) | fn drop(&mut self) {
  function new (line 31) | pub fn new(handle: JoinHandle<T>) -> Self {
  function abort (line 38) | pub fn abort(&self) {
  function is_finished (line 45) | pub fn is_finished(&self) -> bool {
  function abort_handle (line 51) | pub fn abort_handle(&self) -> AbortHandle {
  function detach (line 56) | pub fn detach(self) -> JoinHandle<T> {
  function fmt (line 66) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Output (line 74) | type Output = Result<T, JoinError>;
  method poll (line 76) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function as_ref (line 82) | fn as_ref(&self) -> &JoinHandle<T> {
  type AbortOnDrop (line 97) | pub struct AbortOnDrop(AbortHandle);
    method new (line 107) | pub fn new(handle: AbortHandle) -> Self {
    method abort (line 114) | pub fn abort(&self) {
    method is_finished (line 121) | pub fn is_finished(&self) -> bool {
    method detach (line 126) | pub fn detach(self) -> AbortHandle {
    method fmt (line 136) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method drop (line 100) | fn drop(&mut self) {
  type NotDebug (line 148) | struct NotDebug;
  function is_debug (line 150) | fn is_debug<T: std::fmt::Debug>() {}
  function assert_debug (line 153) | fn assert_debug() {

FILE: tokio-util/src/task/join_map.rs
  type JoinMap (line 98) | pub struct JoinMap<K, V, S = RandomState> {
  function new (line 131) | pub fn new() -> Self {
  function with_capacity (line 148) | pub fn with_capacity(capacity: usize) -> Self {
  function with_hasher (line 168) | pub fn with_hasher(hash_builder: S) -> Self {
  function with_capacity_and_hasher (line 201) | pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self {
  function len (line 210) | pub fn len(&self) -> usize {
  function is_empty (line 217) | pub fn is_empty(&self) -> bool {
  function capacity (line 237) | pub fn capacity(&self) -> usize {
  function spawn (line 264) | pub fn spawn<F>(&mut self, key: K, task: F)
  function spawn_on (line 284) | pub fn spawn_on<F>(&mut self, key: K, task: F, handle: &Handle)
  function spawn_blocking (line 313) | pub fn spawn_blocking<F>(&mut self, key: K, f: F)
  function spawn_blocking_on (line 338) | pub fn spawn_blocking_on<F>(&mut self, key: K, f: F, handle: &Handle)
  function spawn_local (line 364) | pub fn spawn_local<F>(&mut self, key: K, task: F)
  function spawn_local_on (line 384) | pub fn spawn_local_on<F>(&mut self, key: K, task: F, local_set: &LocalSet)
  function insert (line 393) | fn insert(&mut self, mut key: K, mut abort: AbortHandle) {
  function join_next (line 455) | pub async fn join_next(&mut self) -> Option<(K, Result<V, JoinError>)> {
  function shutdown (line 481) | pub async fn shutdown(&mut self) {
  function abort (line 539) | pub fn abort<Q>(&mut self, key: &Q) -> bool
  function abort_matching (line 606) | pub fn abort_matching(&mut self, mut predicate: impl FnMut(&K) -> bool) {
  function keys (line 623) | pub fn keys(&self) -> JoinMapKeys<'_, K, V> {
  function contains_key (line 636) | pub fn contains_key<Q>(&self, key: &Q) -> bool
  function contains_task (line 652) | pub fn contains_task(&self, task: &Id) -> bool {
  function reserve (line 676) | pub fn reserve(&mut self, additional: usize) {
  function shrink_to_fit (line 703) | pub fn shrink_to_fit(&mut self) {
  function shrink_to (line 733) | pub fn shrink_to(&mut self, min_capacity: usize) {
  function get_by_key (line 741) | fn get_by_key<'map, Q>(&'map self, key: &Q) -> Option<&'map (K, AbortHan...
  function remove_by_id (line 751) | fn remove_by_id(&mut self, id: Id) -> Option<K> {
  function abort_all (line 775) | pub fn abort_all(&mut self) {
  function detach_all (line 783) | pub fn detach_all(&mut self) {
  function fmt (line 793) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 818) | fn default() -> Self {
  type JoinMapKeys (line 825) | pub struct JoinMapKeys<'a, K, V> {
  type Item (line 833) | type Item = &'a K;
  method next (line 835) | fn next(&mut self) -> Option<&'a K> {
  method size_hint (line 839) | fn size_hint(&self) -> (usize, Option<usize>) {
  method len (line 845) | fn len(&self) -> usize {

FILE: tokio-util/src/task/join_queue.rs
  type JoinQueue (line 24) | pub struct JoinQueue<T>(VecDeque<AbortOnDropHandle<T>>);
  function new (line 28) | pub const fn new() -> Self {
  function with_capacity (line 33) | pub fn with_capacity(capacity: usize) -> Self {
  function len (line 42) | pub fn len(&self) -> usize {
  function is_empty (line 47) | pub fn is_empty(&self) -> bool {
  function spawn (line 64) | pub fn spawn<F>(&mut self, task: F) -> AbortHandle
  function spawn_on (line 82) | pub fn spawn_on<F>(&mut self, task: F, handle: &Handle) -> AbortHandle
  function spawn_local (line 106) | pub fn spawn_local<F>(&mut self, task: F) -> AbortHandle
  function spawn_blocking (line 124) | pub fn spawn_blocking<F>(&mut self, f: F) -> AbortHandle
  function spawn_blocking_on (line 138) | pub fn spawn_blocking_on<F>(&mut self, f: F, handle: &Handle) -> AbortHa...
  function push_back (line 146) | fn push_back(&mut self, jh: JoinHandle<T>) -> AbortHandle {
  function join_next (line 162) | pub async fn join_next(&mut self) -> Option<Result<T, JoinError>> {
  function join_next_with_id (line 182) | pub async fn join_next_with_id(&mut self) -> Option<Result<(Id, T), Join...
  function try_poll_handle (line 190) | fn try_poll_handle(jh: &mut AbortOnDropHandle<T>) -> Option<Result<T, Jo...
  function try_join_next (line 207) | pub fn try_join_next(&mut self) -> Option<Result<T, JoinError>> {
  function try_join_next_with_id (line 227) | pub fn try_join_next_with_id(&mut self) -> Option<Result<(Id, T), JoinEr...
  function shutdown (line 249) | pub async fn shutdown(&mut self) {
  function join_all (line 270) | pub async fn join_all(mut self) -> Vec<T> {
  function abort_all (line 287) | pub fn abort_all(&mut self) {
  function detach_all (line 295) | pub fn detach_all(&mut self) {
  function poll_join_next (line 319) | pub fn poll_join_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Re...
  function poll_join_next_with_id (line 357) | pub fn poll_join_next_with_id(
  function fmt (line 382) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 390) | fn default() -> Self {
  function from_iter (line 403) | fn from_iter<I: IntoIterator<Item = F>>(iter: I) -> Self {
  type NotDebug (line 417) | struct NotDebug;
  function is_debug (line 419) | fn is_debug<T: std::fmt::Debug>() {}
  function assert_debug (line 422) | fn assert_debug() {

FILE: tokio-util/src/task/spawn_pinned.rs
  type LocalPoolHandle (line 54) | pub struct LocalPoolHandle {
    method new (line 66) | pub fn new(pool_size: usize) -> LocalPoolHandle {
    method num_threads (line 80) | pub fn num_threads(&self) -> usize {
    method get_task_loads_for_each_worker (line 86) | pub fn get_task_loads_for_each_worker(&self) -> Vec<usize> {
    method spawn_pinned (line 126) | pub fn spawn_pinned<F, Fut>(&self, create_task: F) -> JoinHandle<Fut::...
    method spawn_pinned_by_idx (line 182) | pub fn spawn_pinned_by_idx<F, Fut>(&self, create_task: F, idx: usize) ...
  method fmt (line 195) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type WorkerChoice (line 200) | enum WorkerChoice {
  type LocalPool (line 205) | struct LocalPool {
    method spawn_pinned (line 212) | fn spawn_pinned<F, Fut>(
    method find_and_incr_least_burdened_worker (line 314) | fn find_and_incr_least_burdened_worker(&self) -> (&LocalWorkerHandle, ...
    method find_worker_by_idx (line 341) | fn find_worker_by_idx(&self, idx: usize) -> (&LocalWorkerHandle, JobCo...
  type JobCountGuard (line 351) | struct JobCountGuard(Arc<AtomicUsize>);
  method drop (line 354) | fn drop(&mut self) {
  type AbortGuard (line 362) | struct AbortGuard(AbortHandle);
  method drop (line 365) | fn drop(&mut self) {
  type PinnedFutureSpawner (line 370) | type PinnedFutureSpawner = Box<dyn FnOnce() + Send + 'static>;
  type LocalWorkerHandle (line 372) | struct LocalWorkerHandle {
    method new_worker (line 380) | fn new_worker() -> LocalWorkerHandle {
    method run (line 399) | fn run(

FILE: tokio-util/src/task/task_tracker.rs
  type TaskTracker (line 158) | pub struct TaskTracker {
    method new (line 293) | pub fn new() -> Self {
    method wait (line 318) | pub fn wait(&self) -> TaskTrackerWaitFuture<'_> {
    method close (line 337) | pub fn close(&self) -> bool {
    method reopen (line 349) | pub fn reopen(&self) -> bool {
    method is_closed (line 356) | pub fn is_closed(&self) -> bool {
    method len (line 363) | pub fn len(&self) -> usize {
    method is_empty (line 370) | pub fn is_empty(&self) -> bool {
    method spawn (line 381) | pub fn spawn<F>(&self, task: F) -> JoinHandle<F::Output>
    method spawn_on (line 396) | pub fn spawn_on<F>(&self, task: F, handle: &Handle) -> JoinHandle<F::O...
    method spawn_local (line 419) | pub fn spawn_local<F>(&self, task: F) -> JoinHandle<F::Output>
    method spawn_local_on (line 436) | pub fn spawn_local_on<F>(&self, task: F, local_set: &LocalSet) -> Join...
    method spawn_blocking (line 452) | pub fn spawn_blocking<F, T>(&self, task: F) -> JoinHandle<T>
    method spawn_blocking_on (line 474) | pub fn spawn_blocking_on<F, T>(&self, task: F, handle: &Handle) -> Joi...
    method track_future (line 532) | pub fn track_future<F: Future>(&self, future: F) -> TrackedFuture<F> {
    method token (line 549) | pub fn token(&self) -> TaskTrackerToken {
    method ptr_eq (line 572) | pub fn ptr_eq(left: &TaskTracker, right: &TaskTracker) -> bool {
    method fmt (line 643) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TaskTrackerToken (line 165) | pub struct TaskTrackerToken {
    method task_tracker (line 652) | pub fn task_tracker(&self) -> &TaskTracker {
  type TaskTrackerInner (line 169) | struct TaskTrackerInner {
    method new (line 208) | fn new() -> Self {
    method is_closed_and_empty (line 216) | fn is_closed_and_empty(&self) -> bool {
    method set_closed (line 225) | fn set_closed(&self) -> bool {
    method set_open (line 252) | fn set_open(&self) -> bool {
    method add_task (line 259) | fn add_task(&self) {
    method drop_task (line 264) | fn drop_task(&self) {
    method notify_now (line 274) | fn notify_now(&self) {
  method default (line 582) | fn default() -> TaskTracker {
  method clone (line 623) | fn clone(&self) -> TaskTracker {
  function debug_inner (line 630) | fn debug_inner(inner: &TaskTrackerInner, f: &mut fmt::Formatter<'_>) -> ...
  method clone (line 662) | fn clone(&self) -> TaskTrackerToken {
  method drop (line 670) | fn drop(&mut self) {
  type Output (line 676) | type Output = F::Output;
  method poll (line 679) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<F::Output> {
  function fmt (line 685) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 694) | type Output = ();
  method poll (line 697) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  function fmt (line 716) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio-util/src/time/delay_queue.rs
  type DelayQueue (line 135) | pub struct DelayQueue<T> {
  type SlabStorage (line 162) | struct SlabStorage<T> {
  function with_capacity (line 181) | pub(crate) fn with_capacity(capacity: usize) -> SlabStorage<T> {
  function insert (line 191) | pub(crate) fn insert(&mut self, val: Data<T>) -> Key {
  function remove (line 231) | pub(crate) fn remove(&mut self, key: &Key) -> Data<T> {
  function shrink_to_fit (line 244) | pub(crate) fn shrink_to_fit(&mut self) {
  function compact (line 249) | pub(crate) fn compact(&mut self) {
  function remap_key (line 278) | fn remap_key(&self, key: &Key) -> Option<KeyInternal> {
  function create_new_key (line 287) | fn create_new_key(&mut self) -> KeyInternal {
  function len (line 295) | pub(crate) fn len(&self) -> usize {
  function capacity (line 299) | pub(crate) fn capacity(&self) -> usize {
  function clear (line 303) | pub(crate) fn clear(&mut self) {
  function reserve (line 309) | pub(crate) fn reserve(&mut self, additional: usize) {
  function is_empty (line 317) | pub(crate) fn is_empty(&self) -> bool {
  function contains (line 321) | pub(crate) fn contains(&self, key: &Key) -> bool {
  function fmt (line 335) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 348) | type Output = Data<T>;
  function index (line 350) | fn index(&self, key: Key) -> &Self::Output {
  function index_mut (line 361) | fn index_mut(&mut self, key: Key) -> &mut Data<T> {
  type Expired (line 377) | pub struct Expired<T> {
  type Key (line 396) | pub struct Key {
    method new (line 1306) | pub(crate) fn new(index: usize) -> Key {
    method from (line 1324) | fn from(item: KeyInternal) -> Self {
  type KeyInternal (line 404) | struct KeyInternal {
    method new (line 1312) | pub(crate) fn new(index: usize) -> KeyInternal {
    method from (line 1318) | fn from(item: Key) -> Self {
  type Stack (line 409) | struct Stack<T> {
  type Data (line 416) | struct Data<T> {
  constant MAX_ENTRIES (line 435) | const MAX_ENTRIES: usize = (1 << 30) - 1;
  function new (line 448) | pub fn new() -> DelayQueue<T> {
  function with_capacity (line 477) | pub fn with_capacity(capacity: usize) -> DelayQueue<T> {
  function insert_at (line 538) | pub fn insert_at(&mut self, value: T, when: Instant) -> Key {
  function poll_expired (line 582) | pub fn poll_expired(&mut self, cx: &mut task::Context<'_>) -> Poll<Optio...
  function insert (line 657) | pub fn insert(&mut self, value: T, timeout: Duration) -> Key {
  function insert_idx (line 662) | fn insert_idx(&mut self, when: u64, key: Key) {
  function deadline (line 706) | pub fn deadline(&self, key: &Key) -> Instant {
  function remove_key (line 717) | fn remove_key(&mut self, key: &Key) {
  function remove (line 757) | pub fn remove(&mut self, key: &Key) -> Expired<T> {
  function try_remove (line 814) | pub fn try_remove(&mut self, key: &Key) -> Option<Expired<T>> {
  function reset_at (line 857) | pub fn reset_at(&mut self, key: &Key, when: Instant) {
  function shrink_to_fit (line 884) | pub fn shrink_to_fit(&mut self) {
  function compact (line 915) | pub fn compact(&mut self) {
  function peek (line 948) | pub fn peek(&self) -> Option<Key> {
  function next_deadline (line 957) | fn next_deadline(&self) -> Option<Instant> {
  function reset (line 999) | pub fn reset(&mut self, key: &Key, timeout: Duration) {
  function clear (line 1030) | pub fn clear(&mut self) {
  function capacity (line 1047) | pub fn capacity(&self) -> usize {
  function len (line 1067) | pub fn len(&self) -> usize {
  function reserve (line 1105) | pub fn reserve(&mut self, additional: usize) {
  function is_empty (line 1133) | pub fn is_empty(&self) -> bool {
  function poll_idx (line 1141) | fn poll_idx(&mut self, cx: &mut task::Context<'_>) -> Poll<Option<Key>> {
  function normalize_deadline (line 1176) | fn normalize_deadline(&self, when: Instant) -> u64 {
  method default (line 1191) | fn default() -> DelayQueue<T> {
  type Item (line 1199) | type Item = Expired<T>;
  function poll_next (line 1201) | fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<O...
  type Owned (line 1207) | type Owned = Key;
  type Borrowed (line 1208) | type Borrowed = Key;
  type Store (line 1209) | type Store = SlabStorage<T>;
  function is_empty (line 1211) | fn is_empty(&self) -> bool {
  function push (line 1215) | fn push(&mut self, item: Self::Owned, store: &mut Self::Store) {
  function pop (line 1231) | fn pop(&mut self, store: &mut Self::Store) -> Option<Self::Owned> {
  function peek (line 1248) | fn peek(&self) -> Option<Self::Owned> {
  function remove (line 1253) | fn remove(&mut self, item: &Self::Borrowed, store: &mut Self::Store) {
  function when (line 1291) | fn when(item: &Self::Borrowed, store: &Self::Store) -> u64 {
  method default (line 1297) | fn default() -> Stack<T> {
  function get_ref (line 1331) | pub fn get_ref(&self) -> &T {
  function get_mut (line 1336) | pub fn get_mut(&mut self) -> &mut T {
  function into_inner (line 1341) | pub fn into_inner(self) -> T {
  function deadline (line 1346) | pub fn deadline(&self) -> Instant {
  function key (line 1351) | pub fn key(&self) -> Key {

FILE: tokio-util/src/time/mod.rs
  type Round (line 26) | enum Round {
  function ms (line 37) | fn ms(duration: Duration, round: Round) -> u64 {

FILE: tokio-util/src/time/wheel/level.rs
  type Level (line 6) | pub(crate) struct Level<T> {
  type Expiration (line 24) | pub(crate) struct Expiration {
  constant LEVEL_MULT (line 38) | const LEVEL_MULT: usize = 64;
  function new (line 41) | pub(crate) fn new(level: usize) -> Level<T> {
  function next_expiration (line 51) | pub(crate) fn next_expiration(&self, now: u64) -> Option<Expiration> {
  function next_occupied_slot (line 103) | fn next_occupied_slot(&self, now: u64) -> Option<usize> {
  function add_entry (line 117) | pub(crate) fn add_entry(&mut self, when: u64, item: T::Owned, store: &mu...
  function remove_entry (line 124) | pub(crate) fn remove_entry(&mut self, when: u64, item: &T::Borrowed, sto...
  function pop_entry_slot (line 138) | pub(crate) fn pop_entry_slot(&mut self, slot: usize, store: &mut T::Stor...
  function peek_entry_slot (line 151) | pub(crate) fn peek_entry_slot(&self, slot: usize) -> Option<T::Owned> {
  function fmt (line 157) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function occupied_bit (line 164) | fn occupied_bit(slot: usize) -> u64 {
  function slot_range (line 168) | fn slot_range(level: usize) -> u64 {
  function level_range (line 172) | fn level_range(level: usize) -> u64 {
  function slot_for (line 177) | fn slot_for(duration: u64, level: usize) -> usize {
  function test_slot_for (line 186) | fn test_slot_for() {

FILE: tokio-util/src/time/wheel/mod.rs
  type Wheel (line 25) | pub(crate) struct Wheel<T> {
  constant NUM_LEVELS (line 45) | const NUM_LEVELS: usize = 6;
  constant MAX_DURATION (line 48) | const MAX_DURATION: u64 = (1 << (6 * NUM_LEVELS)) - 1;
  type InsertError (line 51) | pub(crate) enum InsertError {
  function new (line 61) | pub(crate) fn new() -> Wheel<T> {
  function elapsed (line 69) | pub(crate) fn elapsed(&self) -> u64 {
  function insert (line 94) | pub(crate) fn insert(
  function remove (line 123) | pub(crate) fn remove(&mut self, item: &T::Borrowed, store: &mut T::Store) {
  function poll_at (line 139) | pub(crate) fn poll_at(&self) -> Option<u64> {
  function peek (line 144) | pub(crate) fn peek(&self) -> Option<T::Owned> {
  function poll (line 150) | pub(crate) fn poll(&mut self, now: u64, store: &mut T::Store) -> Option<...
  function next_expiration (line 181) | fn next_expiration(&self) -> Option<Expiration> {
  function no_expirations_before (line 197) | fn no_expirations_before(&self, start_level: usize, before: u64) -> bool {
  function poll_expiration (line 215) | pub(crate) fn poll_expiration(
  function set_elapsed (line 237) | fn set_elapsed(&mut self, when: u64) {
  function pop_entry (line 250) | fn pop_entry(&mut self, expiration: &Expiration, store: &mut T::Store) -...
  function peek_entry (line 254) | fn peek_entry(&self, expiration: &Expiration) -> Option<T::Owned> {
  function level_for (line 258) | fn level_for(&self, when: u64) -> usize {
  function level_for (line 263) | fn level_for(elapsed: u64, when: u64) -> usize {
  function test_level_for (line 283) | fn test_level_for() {

FILE: tokio-util/src/time/wheel/stack.rs
  type Stack (line 6) | pub(crate) trait Stack: Default {
    method is_empty (line 17) | fn is_empty(&self) -> bool;
    method push (line 20) | fn push(&mut self, item: Self::Owned, store: &mut Self::Store);
    method pop (line 23) | fn pop(&mut self, store: &mut Self::Store) -> Option<Self::Owned>;
    method peek (line 26) | fn peek(&self) -> Option<Self::Owned>;
    method remove (line 28) | fn remove(&mut self, item: &Self::Borrowed, store: &mut Self::Store);
    method when (line 30) | fn when(item: &Self::Borrowed, store: &Self::Store) -> u64;

FILE: tokio-util/src/udp/frame.rs
  type UdpFramed (line 38) | pub struct UdpFramed<C, T = UdpSocket> {
  constant INITIAL_RD_CAPACITY (line 49) | const INITIAL_RD_CAPACITY: usize = 64 * 1024;
  constant INITIAL_WR_CAPACITY (line 50) | const INITIAL_WR_CAPACITY: usize = 8 * 1024;
  type Item (line 59) | type Item = Result<(C::Item, SocketAddr), C::Error>;
  method poll_next (line 61) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Error (line 113) | type Error = C::Error;
  function poll_ready (line 115) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 126) | fn start_send(self: Pin<&mut Self>, item: (I, SocketAddr)) -> Result<(),...
  function poll_flush (line 138) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function poll_close (line 169) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function new (line 182) | pub fn new(socket: T, codec: C) -> UdpFramed<C, T> {
  function get_ref (line 202) | pub fn get_ref(&self) -> &T {
  function get_mut (line 213) | pub fn get_mut(&mut self) -> &mut T {
  function codec (line 222) | pub fn codec(&self) -> &C {
  function codec_mut (line 231) | pub fn codec_mut(&mut self) -> &mut C {
  function read_buffer (line 236) | pub fn read_buffer(&self) -> &BytesMut {
  function read_buffer_mut (line 241) | pub fn read_buffer_mut(&mut self) -> &mut BytesMut {
  function into_inner (line 246) | pub fn into_inner(self) -> T {

FILE: tokio-util/src/util/maybe_dangling.rs
  type MaybeDangling (line 28) | pub(crate) struct MaybeDangling<T>(MaybeUninit<T>);
  method drop (line 31) | fn drop(&mut self) {
  function new (line 38) | pub(crate) fn new(inner: T) -> Self {
  type Output (line 44) | type Output = F::Output;
  method poll (line 46) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function maybedangling_runs_drop (line 54) | fn maybedangling_runs_drop() {

FILE: tokio-util/src/util/poll_buf.rs
  function poll_read_buf (line 47) | pub fn poll_read_buf<T: AsyncRead + ?Sized, B: BufMut>(
  function poll_write_buf (line 121) | pub fn poll_write_buf<T: AsyncWrite + ?Sized, B: Buf>(

FILE: tokio-util/tests/abort_on_drop.rs
  function aborts_task_on_drop (line 5) | async fn aborts_task_on_drop() {
  function aborts_task_directly (line 17) | async fn aborts_task_directly() {
  function does_not_abort_after_detach (line 30) | async fn does_not_abort_after_detach() {
  function handle_aborts_task_on_drop (line 42) | async fn handle_aborts_task_on_drop() {
  function handle_aborts_task_directly (line 54) | async fn handle_aborts_task_directly() {
  function handle_does_not_abort_after_detach (line 67) | async fn handle_does_not_abort_after_detach() {

FILE: tokio-util/tests/codecs.rs
  function bytes_decoder (line 8) | fn bytes_decoder() {
  function bytes_encoder (line 20) | fn bytes_encoder() {
  function lines_decoder (line 47) | fn lines_decoder() {
  function lines_decoder_invalid_utf8 (line 66) | fn lines_decoder_invalid_utf8() {
  function lines_decoder_max_length (line 79) | fn lines_decoder_max_length() {
  function lines_decoder_max_length_underrun (line 123) | fn lines_decoder_max_length_underrun() {
  function lines_decoder_max_length_bursts (line 144) | fn lines_decoder_max_length_bursts() {
  function lines_decoder_max_length_big_burst (line 160) | fn lines_decoder_max_length_big_burst() {
  function lines_decoder_max_length_newline_between_decodes (line 174) | fn lines_decoder_max_length_newline_between_decodes() {
  function lines_decoder_discard_repeat (line 190) | fn lines_decoder_discard_repeat() {
  function lines_decoder_max_length_underrun_twice (line 205) | fn lines_decoder_max_length_underrun_twice() {
  function lines_encoder (line 223) | fn lines_encoder() {
  function any_delimiters_decoder_any_character (line 235) | fn any_delimiters_decoder_any_character() {
  function any_delimiters_decoder_max_length (line 254) | fn any_delimiters_decoder_max_length() {
  function any_delimiter_decoder_max_length_underrun (line 331) | fn any_delimiter_decoder_max_length_underrun() {
  function any_delimiter_decoder_max_length_underrun_twice (line 353) | fn any_delimiter_decoder_max_length_underrun_twice() {
  function any_delimiter_decoder_max_length_bursts (line 371) | fn any_delimiter_decoder_max_length_bursts() {
  function any_delimiter_decoder_max_length_big_burst (line 388) | fn any_delimiter_decoder_max_length_big_burst() {
  function any_delimiter_decoder_max_length_delimiter_between_decodes (line 403) | fn any_delimiter_decoder_max_length_delimiter_between_decodes() {
  function any_delimiter_decoder_discard_repeat (line 419) | fn any_delimiter_decoder_discard_repeat() {
  function any_delimiter_encoder (line 434) | fn any_delimiter_encoder() {

FILE: tokio-util/tests/compat.rs
  function compat_file_seek (line 12) | async fn compat_file_seek() -> futures_util::io::Result<()> {

FILE: tokio-util/tests/context.rs
  function tokio_context_with_another_runtime (line 10) | fn tokio_context_with_another_runtime() {

FILE: tokio-util/tests/framed.rs
  constant INITIAL_CAPACITY (line 12) | const INITIAL_CAPACITY: usize = 8 * 1024;
  type U32Codec (line 16) | struct U32Codec {
    type Error (line 36) | type Error = io::Error;
    method encode (line 38) | fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
  type Item (line 21) | type Item = u32;
  type Error (line 22) | type Error = io::Error;
  method decode (line 24) | fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
  type U64Codec (line 48) | struct U64Codec {
    type Error (line 68) | type Error = io::Error;
    method encode (line 70) | fn encode(&mut self, item: u64, dst: &mut BytesMut) -> io::Result<()> {
  type Item (line 53) | type Item = u64;
  type Error (line 54) | type Error = io::Error;
  method decode (line 56) | fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u64>> {
  type DontReadIntoThis (line 79) | struct DontReadIntoThis;
    method poll_read (line 91) | fn poll_read(
  method read (line 82) | fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
  function can_read_from_existing_buf (line 101) | async fn can_read_from_existing_buf() {
  function can_read_from_existing_buf_after_codec_changed (line 113) | async fn can_read_from_existing_buf_after_codec_changed() {
  function external_buf_grows_to_init (line 133) | fn external_buf_grows_to_init() {
  function from_parts_empty_read_buf_does_not_spuriously_decode (line 151) | async fn from_parts_empty_read_buf_does_not_spuriously_decode() {
  function external_buf_does_not_shrink (line 197) | fn external_buf_does_not_shrink() {

FILE: tokio-util/tests/framed_read.rs
  type U32Decoder (line 37) | struct U32Decoder;
  type Item (line 40) | type Item = u32;
  type Error (line 41) | type Error = io::Error;
  method decode (line 43) | fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
  type U64Decoder (line 53) | struct U64Decoder;
  type Item (line 56) | type Item = u64;
  type Error (line 57) | type Error = io::Error;
  method decode (line 59) | fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u64>> {
  function read_multi_frame_in_packet (line 70) | fn read_multi_frame_in_packet() {
  function read_multi_frame_across_packets (line 86) | fn read_multi_frame_across_packets() {
  function read_multi_frame_in_packet_after_codec_changed (line 104) | fn read_multi_frame_in_packet_after_codec_changed() {
  function read_not_ready (line 122) | fn read_not_ready() {
  function read_partial_then_not_ready (line 140) | fn read_partial_then_not_ready() {
  function read_err (line 159) | fn read_err() {
  function read_partial_then_err (line 178) | fn read_partial_then_err() {
  function read_partial_would_block_then_err (line 198) | fn read_partial_would_block_then_err() {
  function huge_size (line 220) | fn huge_size() {
  function data_remaining_is_error (line 247) | fn data_remaining_is_error() {
  function multi_frames_on_eof (line 259) | fn multi_frames_on_eof() {
  function read_eof_then_resume (line 292) | fn read_eof_then_resume() {
  type Mock (line 316) | struct Mock {
  method poll_read (line 321) | fn poll_read(

FILE: tokio-util/tests/framed_stream.rs
  function return_none_after_error (line 20) | async fn return_none_after_error() {

FILE: tokio-util/tests/framed_write.rs
  type U32Encoder (line 29) | struct U32Encoder;
    type Error (line 32) | type Error = io::Error;
    method encode (line 34) | fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
  type U64Encoder (line 42) | struct U64Encoder;
    type Error (line 45) | type Error = io::Error;
    method encode (line 47) | fn encode(&mut self, item: u64, dst: &mut BytesMut) -> io::Result<()> {
  function write_multi_frame_in_packet (line 56) | fn write_multi_frame_in_packet() {
  function write_multi_frame_after_codec_changed (line 82) | fn write_multi_frame_after_codec_changed() {
  function write_hits_backpressure (line 108) | fn write_hits_backpressure() {
  type Mock (line 170) | struct Mock {
  method write (line 175) | fn write(&mut self, src: &[u8]) -> io::Result<usize> {
  method flush (line 187) | fn flush(&mut self) -> io::Result<()> {
  method poll_write (line 193) | fn poll_write(
  method poll_flush (line 203) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 209) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...

FILE: tokio-util/tests/future.rs
  type ReadyOnTheSecondPollFuture (line 12) | struct ReadyOnTheSecondPollFuture {
  type Output (line 17) | type Output = ();
  method poll (line 19) | fn poll(mut self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>) -> Po...
  function ready_fut_with_cancellation_token_test (line 29) | fn ready_fut_with_cancellation_token_test() {
  function pending_fut_with_cancellation_token_test (line 47) | fn pending_fut_with_cancellation_token_test() {
  function ready_fut_with_already_cancelled_token_test (line 65) | fn ready_fut_with_already_cancelled_token_test() {
  function pending_fut_with_already_cancelled_token_test (line 84) | fn pending_fut_with_already_cancelled_token_test() {
  function pending_fut_with_token_cancelled_test (line 104) | fn pending_fut_with_token_cancelled_test() {
  function pending_only_on_first_poll_with_cancellation_token_test (line 129) | fn pending_only_on_first_poll_with_cancellation_token_test() {
  function ready_fut_with_cancellation_owned_token_test (line 150) | fn ready_fut_with_cancellation_owned_token_test() {
  function pending_fut_with_cancellation_token_owned_test (line 168) | fn pending_fut_with_cancellation_token_owned_test() {
  function ready_fut_with_already_cancelled_token_owned_test (line 186) | fn ready_fut_with_already_cancelled_token_owned_test() {
  function pending_fut_with_already_cancelled_token_owned_test (line 205) | fn pending_fut_with_already_cancelled_token_owned_test() {
  function pending_fut_with_owned_token_cancelled_test (line 225) | fn pending_fut_with_owned_token_cancelled_test() {
  function pending_only_on_first_poll_with_cancellation_token_owned_test (line 250) | fn pending_only_on_first_poll_with_cancellation_token_owned_test() {

FILE: tokio-util/tests/io_inspect.rs
  type SmallReader (line 12) | struct SmallReader {
  method poll_read (line 19) | fn poll_read(
  function read_tee (line 32) | async fn read_tee() {
  type SmallWriter (line 53) | struct SmallWriter {
  method poll_write (line 60) | fn poll_write(
  method poll_flush (line 73) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 77) | fn poll_shutdown(
  method poll_write_vectored (line 84) | fn poll_write_vectored(
  method is_write_vectored (line 108) | fn is_write_vectored(&self) -> bool {
  function write_tee (line 114) | async fn write_tee() {
  function write_all_vectored (line 132) | async fn write_all_vectored<W: AsyncWrite + Unpin>(
  function write_tee_vectored (line 161) | async fn write_tee_vectored() {

FILE: tokio-util/tests/io_reader_stream.rs
  type Reader (line 10) | struct Reader {
  method poll_read (line 15) | fn poll_read(
  function correct_behavior_on_errors (line 38) | async fn correct_behavior_on_errors() {

FILE: tokio-util/tests/io_simplex.rs
  function single_thread (line 12) | async fn single_thread() {
  function multi_thread (line 46) | fn multi_thread() {
  function zero_capacity (line 85) | fn zero_capacity() {
  function read_buf_is_full (line 92) | async fn read_buf_is_full() {
  function write_buf_is_empty (line 103) | async fn write_buf_is_empty() {
  function drop_receiver_0 (line 112) | async fn drop_receiver_0() {
  function drop_receiver_1 (line 121) | async fn drop_receiver_1() {
  function drop_sender_0 (line 136) | async fn drop_sender_0() {
  function drop_sender_1 (line 151) | async fn drop_sender_1() {
  function shutdown_sender_0 (line 171) | async fn shutdown_sender_0() {
  function shutdown_sender_1 (line 184) | async fn shutdown_sender_1() {
  function shutdown_sender_2 (line 192) | async fn shutdown_sender_2() {
  function cooperative_scheduling (line 214) | async fn cooperative_scheduling() {
  function poll_write_vectored_0 (line 276) | async fn poll_write_vectored_0() {
  function poll_write_vectored_1 (line 297) | async fn poll_write_vectored_1() {
  function poll_write_vectored_2 (line 320) | async fn poll_write_vectored_2() {
  function poll_write_vectored_3 (line 350) | async fn poll_write_vectored_3() {

FILE: tokio-util/tests/io_sink_writer.rs
  function test_copied_sink_writer (line 12) | async fn test_copied_sink_writer() -> Result<(), Error> {
  type SliceEncoder (line 34) | struct SliceEncoder;
    method new (line 37) | fn new() -> Self {
    type Error (line 43) | type Error = Error;
    method encode (line 45) | fn encode(&mut self, item: &'a [u8], dst: &mut bytes::BytesMut) -> Res...
  function test_direct_sink_writer (line 55) | async fn test_direct_sink_writer() -> Result<(), Error> {

FILE: tokio-util/tests/io_stream_reader.rs
  function test_stream_reader (line 9) | async fn test_stream_reader() -> std::io::Result<()> {

FILE: tokio-util/tests/io_sync_bridge.rs
  function test_reader_len (line 9) | async fn test_reader_len(
  function test_async_read_to_sync (line 25) | async fn test_async_read_to_sync() -> Result<(), Box<dyn Error>> {
  function test_async_write_to_sync (line 33) | async fn test_async_write_to_sync() -> Result<(), Box<dyn Error>> {
  function test_into_inner (line 47) | async fn test_into_inner() -> Result<(), Box<dyn Error>> {
  function test_shutdown (line 59) | async fn test_shutdown() -> Result<(), Box<dyn Error>> {

FILE: tokio-util/tests/io_write_all_vectored.rs
  function test_write_all_vectored (line 14) | async fn test_write_all_vectored() {
  function write_all_vectored_with_empty_slice (line 66) | async fn write_all_vectored_with_empty_slice() {

FILE: tokio-util/tests/length_delimited.rs
  function read_empty_io_yields_nothing (line 74) | fn read_empty_io_yields_nothing() {
  function read_single_frame_one_packet (line 82) | fn read_single_frame_one_packet() {
  function read_single_frame_one_packet_little_endian (line 96) | fn read_single_frame_one_packet_little_endian() {
  function read_single_frame_one_packet_native_endian (line 109) | fn read_single_frame_one_packet_native_endian() {
  function read_single_multi_frame_one_packet (line 127) | fn read_single_multi_frame_one_packet() {
  function read_single_frame_multi_packet (line 148) | fn read_single_frame_multi_packet() {
  function read_multi_frame_multi_packet (line 164) | fn read_multi_frame_multi_packet() {
  function read_single_frame_multi_packet_wait (line 184) | fn read_single_frame_multi_packet_wait() {
  function read_multi_frame_multi_packet_wait (line 206) | fn read_multi_frame_multi_packet_wait() {
  function read_incomplete_head (line 236) | fn read_incomplete_head() {
  function read_incomplete_head_multi (line 249) | fn read_incomplete_head_multi() {
  function read_incomplete_payload (line 266) | fn read_incomplete_payload() {
  function read_max_frame_len (line 284) | fn read_max_frame_len() {
  function read_update_max_frame_len_at_rest (line 296) | fn read_update_max_frame_len_at_rest() {
  function read_update_max_frame_len_in_flight (line 309) | fn read_update_max_frame_len_in_flight() {
  function read_one_byte_length_field (line 325) | fn read_one_byte_length_field() {
  function read_header_offset (line 338) | fn read_header_offset() {
  function read_single_multi_frame_one_packet_skip_none_adjusted (line 352) | fn read_single_multi_frame_one_packet_skip_none_adjusted() {
  function read_single_frame_length_adjusted (line 375) | fn read_single_frame_length_adjusted() {
  function read_single_multi_frame_one_packet_length_includes_head (line 394) | fn read_single_multi_frame_one_packet_length_includes_head() {
  function write_single_frame_length_adjusted (line 415) | fn write_single_frame_length_adjusted() {
  function write_nothing_yields_nothing (line 434) | fn write_nothing_yields_nothing() {
  function write_single_frame_one_packet (line 444) | fn write_single_frame_one_packet() {
  function write_single_multi_frame_one_packet (line 464) | fn write_single_multi_frame_one_packet() {
  function write_single_multi_frame_multi_packet (line 495) | fn write_single_multi_frame_multi_packet() {
  function write_single_frame_would_block (line 532) | fn write_single_frame_would_block() {
  function write_single_frame_little_endian (line 559) | fn write_single_frame_little_endian() {
  function write_single_frame_with_short_length_field (line 579) | fn write_single_frame_with_short_length_field() {
  function write_max_frame_len (line 600) | fn write_max_frame_len() {
  function write_update_max_frame_len_at_rest (line 615) | fn write_update_max_frame_len_at_rest() {
  function write_update_max_frame_len_in_flight (line 638) | fn write_update_max_frame_len_in_flight() {
  function write_zero (line 664) | fn write_zero() {
  function encode_overflow (line 679) | fn encode_overflow() {
  function frame_does_not_fit (line 693) | fn frame_does_not_fit() {
  function neg_adjusted_frame_does_not_fit (line 703) | fn neg_adjusted_frame_does_not_fit() {
  function pos_adjusted_frame_does_not_fit (line 713) | fn pos_adjusted_frame_does_not_fit() {
  function max_allowed_frame_fits (line 723) | fn max_allowed_frame_fits() {
  function smaller_frame_len_not_adjusted (line 733) | fn smaller_frame_len_not_adjusted() {
  function max_allowed_length_field (line 743) | fn max_allowed_length_field() {
  type Mock (line 754) | struct Mock {
  type Op (line 758) | enum Op {
    method from (line 819) | fn from(src: &'a [u8]) -> Op {
    method from (line 825) | fn from(src: Vec<u8>) -> Op {
  method poll_read (line 764) | fn poll_read(
  method poll_write (line 784) | fn poll_write(
  method poll_flush (line 803) | fn poll_flush(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<R...
  method poll_shutdown (line 813) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...
  function data (line 830) | fn data(bytes: &[u8]) -> Poll<io::Result<Op>> {
  function flush (line 834) | fn flush() -> Poll<io::Result<Op>> {

FILE: tokio-util/tests/mpsc.rs
  function simple (line 11) | async fn simple() {
  function simple_ref (line 34) | async fn simple_ref() {
  function repeated_poll_reserve (line 57) | async fn repeated_poll_reserve() {
  function abort_send (line 70) | async fn abort_send() {
  function close_sender_last (line 99) | async fn close_sender_last() {
  function close_sender_not_last (line 113) | async fn close_sender_not_last() {
  function close_sender_before_reserve (line 133) | async fn close_sender_before_reserve() {
  function close_sender_after_pending_reserve (line 150) | async fn close_sender_after_pending_reserve() {
  function close_sender_after_successful_reserve (line 175) | async fn close_sender_after_successful_reserve() {
  function abort_send_after_pending_reserve (line 196) | async fn abort_send_after_pending_reserve() {
  function abort_send_after_successful_reserve (line 218) | async fn abort_send_after_successful_reserve() {
  function closed_when_receiver_drops (line 235) | async fn closed_when_receiver_drops() {
  function start_send_panics_when_idle (line 245) | fn start_send_panics_when_idle() {
  function start_send_panics_when_acquiring (line 254) | fn start_send_panics_when_acquiring() {
  function sink_send_then_flush (line 268) | fn sink_send_then_flush() {
  function sink_send_then_close (line 295) | fn sink_send_then_close() {
  function sink_send_ref (line 332) | fn sink_send_ref() {

FILE: tokio-util/tests/panic.rs
  constant MAX_DURATION_MS (line 19) | const MAX_DURATION_MS: u64 = (1 << (36)) - 1;
  function test_panic (line 21) | fn test_panic<Func: FnOnce() + panic::UnwindSafe>(func: Func) -> Option<...
  function sync_bridge_new_panic_caller (line 53) | fn sync_bridge_new_panic_caller() -> Result<(), Box<dyn Error>> {
  function poll_sender_send_item_panic_caller (line 65) | fn poll_sender_send_item_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_pool_handle_new_panic_caller (line 80) | fn local_pool_handle_new_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_pool_handle_spawn_pinned_by_idx_panic_caller (line 92) | fn local_pool_handle_spawn_pinned_by_idx_panic_caller() -> Result<(), Bo...
  function delay_queue_insert_at_panic_caller (line 108) | fn delay_queue_insert_at_panic_caller() -> Result<(), Box<dyn Error>> {
  function delay_queue_insert_panic_caller (line 129) | fn delay_queue_insert_panic_caller() -> Result<(), Box<dyn Error>> {
  function delay_queue_remove_panic_caller (line 146) | fn delay_queue_remove_panic_caller() -> Result<(), Box<dyn Error>> {
  function delay_queue_reset_at_panic_caller (line 165) | fn delay_queue_reset_at_panic_caller() -> Result<(), Box<dyn Error>> {
  function delay_queue_reset_panic_caller (line 186) | fn delay_queue_reset_panic_caller() -> Result<(), Box<dyn Error>> {
  function delay_queue_reserve_panic_caller (line 204) | fn delay_queue_reserve_panic_caller() -> Result<(), Box<dyn Error>> {
  function future_ext_to_panic_caller (line 221) | fn future_ext_to_panic_caller() -> Result<(), Box<dyn Error>> {
  function basic (line 237) | fn basic() -> Runtime {

FILE: tokio-util/tests/poll_semaphore.rs
  type SemRet (line 7) | type SemRet = Option<OwnedSemaphorePermit>;
  function semaphore_poll (line 9) | fn semaphore_poll(
  function semaphore_poll_many (line 16) | fn semaphore_poll_many(
  function it_works (line 25) | async fn it_works() {
  function can_acquire_many_permits (line 47) | async fn can_acquire_many_permits() {
  function can_poll_different_amounts_of_permits (line 72) | async fn can_poll_different_amounts_of_permits() {

FILE: tokio-util/tests/reusable_box.rs
  function traits (line 13) | fn traits<'a>() {
  function test_different_futures (line 22) | fn test_different_futures() {
  function test_different_sizes (line 43) | fn test_different_sizes() {
  type ZeroSizedFuture (line 61) | struct ZeroSizedFuture {}
  type Output (line 63) | type Output = u32;
  method poll (line 64) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<u32> {
  function test_zero_sized (line 70) | fn test_zero_sized() {

FILE: tokio-util/tests/spawn_pinned.rs
  function can_spawn_not_send_future (line 11) | async fn can_spawn_not_send_future() {
  function can_drop_future_and_still_get_output (line 30) | fn can_drop_future_and_still_get_output() {
  function cannot_create_zero_sized_pool (line 49) | fn cannot_create_zero_sized_pool() {
  function can_spawn_multiple_futures (line 55) | async fn can_spawn_multiple_futures() {
  function task_panic_propagates (line 75) | async fn task_panic_propagates() {
  function callback_panic_does_not_kill_worker (line 100) | async fn callback_panic_does_not_kill_worker() {
  function task_cancellation_propagates (line 126) | async fn task_cancellation_propagates() {
  function tasks_are_balanced (line 163) | async fn tasks_are_balanced() {
  function spawn_by_idx (line 200) | async fn spawn_by_idx() {

FILE: tokio-util/tests/sync_cancellation_token.rs
  function cancel_token (line 12) | fn cancel_token() {
  function cancel_token_owned (line 44) | fn cancel_token_owned() {
  function cancel_token_owned_drop_test (line 76) | fn cancel_token_owned_drop_test() {
  function cancel_child_token_through_parent (line 94) | fn cancel_child_token_through_parent() {
  function cancel_grandchild_token_through_parent_if_child_was_dropped (line 132) | fn cancel_grandchild_token_through_parent_if_child_was_dropped() {
  function cancel_child_token_without_parent (line 172) | fn cancel_child_token_without_parent() {
  function create_child_token_after_parent_was_cancelled (line 236) | fn create_child_token_after_parent_was_cancelled() {
  function drop_multiple_child_tokens (line 273) | fn drop_multiple_child_tokens() {
  function cancel_only_all_descendants (line 298) | fn cancel_only_all_descendants() {
  function drop_parent_before_child_tokens (line 426) | fn drop_parent_before_child_tokens() {
  function derives_send_sync (line 439) | fn derives_send_sync() {
  function run_until_cancelled_test (line 451) | fn run_until_cancelled_test() {
  function run_until_cancelled_owned_test (line 513) | fn run_until_cancelled_owned_test() {

FILE: tokio-util/tests/task_join_map.rs
  function rt (line 12) | fn rt() -> tokio::runtime::Runtime {
  function spawn_index_tasks (line 19) | fn spawn_index_tasks(map: &mut JoinMap<usize, usize>, n: usize, on: Opti...
  function spawn_pending_tasks (line 32) | fn spawn_pending_tasks(
  function drain_joinmap_and_assert (line 54) | async fn drain_joinmap_and_assert(mut map: JoinMap<usize, usize>, n: usi...
  function await_receivers_and_assert (line 67) | async fn await_receivers_and_assert(receivers: Vec<oneshot::Receiver<()>...
  function test_with_sleep (line 77) | async fn test_with_sleep() {
  function test_abort_on_drop (line 129) | async fn test_abort_on_drop() {
  function alternating (line 154) | async fn alternating() {
  function test_keys (line 173) | async fn test_keys() {
  function abort_by_key (line 197) | async fn abort_by_key() {
  function abort_by_predicate (line 235) | async fn abort_by_predicate() {
  function runtime_gone (line 269) | fn runtime_gone() {
  function join_map_coop (line 285) | async fn join_map_coop() {
  function abort_all (line 327) | async fn abort_all() {
  function duplicate_keys (line 362) | async fn duplicate_keys() {
  function duplicate_keys2 (line 377) | async fn duplicate_keys2() {
  function duplicate_keys_drop (line 409) | async fn duplicate_keys_drop() {
  function panic_outside_any_runtime (line 445) | fn panic_outside_any_runtime() {
  function panic_in_multi_thread_runtime (line 454) | async fn panic_in_multi_thread_runtime() {
  function spawn_then_join_next (line 465) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 477) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 493) | async fn spawn_then_drop() {
  function spawn_then_join_next (line 512) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 527) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 548) | async fn spawn_then_drop() {
  function spawn_then_join_next (line 577) | async fn spawn_then_join_next() {
  function spawn_then_join_next (line 599) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 616) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 637) | async fn spawn_then_drop() {

FILE: tokio-util/tests/task_join_queue.rs
  function test_join_queue_no_spurious_wakeups (line 10) | async fn test_join_queue_no_spurious_wakeups() {
  function test_join_queue_abort_on_drop (line 34) | async fn test_join_queue_abort_on_drop() {
  function test_join_queue_alternating (line 59) | async fn test_join_queue_alternating() {
  function test_join_queue_abort_all (line 78) | async fn test_join_queue_abort_all() {
  function test_join_queue_join_all (line 110) | async fn test_join_queue_join_all() {
  function test_join_queue_shutdown (line 130) | async fn test_join_queue_shutdown() {
  function test_join_queue_with_manual_abort (line 150) | async fn test_join_queue_with_manual_abort() {
  function test_join_queue_join_next_with_id (line 190) | async fn test_join_queue_join_next_with_id() {
  function test_join_queue_try_join_next (line 226) | async fn test_join_queue_try_join_next() {
  function test_join_queue_try_join_next_disabled_coop (line 280) | async fn test_join_queue_try_join_next_disabled_coop() {
  function test_join_queue_try_join_next_with_id_disabled_coop (line 316) | async fn test_join_queue_try_join_next_with_id_disabled_coop() {
  function spawn_local_panic_outside_any_runtime (line 367) | fn spawn_local_panic_outside_any_runtime() {
  function spawn_local_panic_in_multi_thread_runtime (line 376) | async fn spawn_local_panic_in_multi_thread_runtime() {

FILE: tokio-util/tests/task_tracker.rs
  function open_close (line 12) | fn open_close() {
  function token_len (line 41) | fn token_len() {
  function notify_immediately (line 60) | fn notify_immediately() {
  function notify_immediately_on_reopen (line 69) | fn notify_immediately_on_reopen() {
  function notify_on_close (line 79) | fn notify_on_close() {
  function notify_on_close_reopen (line 90) | fn notify_on_close_reopen() {
  function notify_on_last_task (line 102) | fn notify_on_last_task() {
  function notify_on_last_task_respawn (line 114) | fn notify_on_last_task_respawn() {
  function no_notify_on_respawn_if_open (line 128) | fn no_notify_on_respawn_if_open() {
  function close_during_exit (line 141) | fn close_during_exit() {
  function notify_many (line 169) | fn notify_many() {
  function spawn_then_close (line 191) | async fn spawn_then_close() {
  function panic_outside_any_runtime (line 220) | fn panic_outside_any_runtime() {
  function panic_in_multi_thread_runtime (line 229) | async fn panic_in_multi_thread_runtime() {
  function spawn_then_close (line 236) | async fn spawn_then_close() {
  function spawn_after_close (line 257) | async fn spawn_after_close() {
  function spawn_then_close (line 287) | async fn spawn_then_close() {
  function spawn_then_drop (line 321) | async fn spawn_then_drop() {
  function close_then_spawn (line 354) | async fn close_then_spawn() {

FILE: tokio-util/tests/time_delay_queue.rs
  function single_immediate_delay (line 26) | async fn single_immediate_delay() {
  function multi_immediate_delays (line 42) | async fn multi_immediate_delays() {
  function single_short_delay (line 71) | async fn single_short_delay() {
  function multi_delay_at_start (line 96) | async fn multi_delay_at_start() {
  function insert_in_past_fires_immediately (line 138) | async fn insert_in_past_fires_immediately() {
  function remove_entry (line 154) | async fn remove_entry() {
  function reset_entry (line 173) | async fn reset_entry() {
  function reset_much_later (line 207) | async fn reset_much_later() {
  function reset_twice (line 229) | async fn reset_twice() {
  function repeatedly_reset_entry_inserted_as_expired (line 260) | async fn repeatedly_reset_entry_inserted_as_expired() {
  function remove_expired_item (line 288) | async fn remove_expired_item() {
  function remove_at_timer_wheel_threshold (line 308) | async fn remove_at_timer_wheel_threshold() {
  function expires_before_last_insert (line 336) | async fn expires_before_last_insert() {
  function multi_reset (line 362) | async fn multi_reset() {
  function expire_first_key_when_reset_to_expire_earlier (line 399) | async fn expire_first_key_when_reset_to_expire_earlier() {
  function expire_second_key_when_reset_to_expire_earlier (line 422) | async fn expire_second_key_when_reset_to_expire_earlier() {
  function reset_first_expiring_item_to_expire_later (line 445) | async fn reset_first_expiring_item_to_expire_later() {
  function insert_before_first_after_poll (line 467) | async fn insert_before_first_after_poll() {
  function insert_after_ready_poll (line 493) | async fn insert_after_ready_poll() {
  function reset_later_after_slot_starts (line 526) | async fn reset_later_after_slot_starts() {
  function reset_inserted_expired (line 563) | async fn reset_inserted_expired() {
  function reset_earlier_after_slot_starts (line 588) | async fn reset_earlier_after_slot_starts() {
  function insert_in_past_after_poll_fires_immediately (line 625) | async fn insert_in_past_after_poll_fires_immediately() {
  function delay_queue_poll_expired_when_empty (line 648) | async fn delay_queue_poll_expired_when_empty() {
  function compact_expire_empty (line 658) | async fn compact_expire_empty() {
  function compact_remove_empty (line 681) | async fn compact_remove_empty() {
  function compact_remove_remapped_keys (line 701) | async fn compact_remove_remapped_keys() {
  function compact_change_deadline (line 740) | async fn compact_change_deadline() {
  function item_expiry_greater_than_wheel (line 792) | async fn item_expiry_greater_than_wheel() {
  function remove_after_compact (line 810) | async fn remove_after_compact() {
  function remove_after_compact_poll (line 828) | async fn remove_after_compact_poll() {
  function peek (line 847) | async fn peek() {
  function wake_after_remove_last (line 885) | async fn wake_after_remove_last() {
  function ms (line 897) | fn ms(n: u64) -> Duration {

FILE: tokio-util/tests/udp.rs
  function send_framed_byte_codec (line 29) | async fn send_framed_byte_codec() -> std::io::Result<()> {
  type ByteCodec (line 81) | pub struct ByteCodec;
    type Error (line 94) | type Error = io::Error;
    method encode (line 96) | fn encode(&mut self, data: &[u8], buf: &mut BytesMut) -> Result<(), io...
  type Item (line 84) | type Item = Vec<u8>;
  type Error (line 85) | type Error = io::Error;
  method decode (line 87) | fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Vec<u8>>, io::...
  function send_framed_lines_codec (line 104) | async fn send_framed_lines_codec() -> std::io::Result<()> {
  function framed_half (line 125) | async fn framed_half() -> std::io::Result<()> {

FILE: tokio/src/doc/mod.rs
  type NotDefinedHere (line 21) | pub enum NotDefinedHere {}
    method register (line 25) | fn register(
    method reregister (line 33) | fn reregister(
    method deregister (line 41) | fn deregister(&mut self, _registry: &mio::Registry) -> std::io::Result...

FILE: tokio/src/doc/os.rs
  type RawHandle (line 12) | pub type RawHandle = crate::doc::NotDefinedHere;
  type OwnedHandle (line 15) | pub type OwnedHandle = crate::doc::NotDefinedHere;
  type AsRawHandle (line 18) | pub trait AsRawHandle {
    method as_raw_handle (line 20) | fn as_raw_handle(&self) -> RawHandle;
  type FromRawHandle (line 24) | pub trait FromRawHandle {
    method from_raw_handle (line 26) | unsafe fn from_raw_handle(handle: RawHandle) -> Self;
  type RawSocket (line 30) | pub type RawSocket = crate::doc::NotDefinedHere;
  type AsRawSocket (line 33) | pub trait AsRawSocket {
    method as_raw_socket (line 35) | fn as_raw_socket(&self) -> RawSocket;
  type FromRawSocket (line 39) | pub trait FromRawSocket {
    method from_raw_socket (line 41) | unsafe fn from_raw_socket(sock: RawSocket) -> Self;
  type IntoRawSocket (line 45) | pub trait IntoRawSocket {
    method into_raw_socket (line 47) | fn into_raw_socket(self) -> RawSocket;
  type BorrowedHandle (line 51) | pub type BorrowedHandle<'handle> = crate::doc::NotDefinedHere;
  type AsHandle (line 54) | pub trait AsHandle {
    method as_handle (line 56) | fn as_handle(&self) -> BorrowedHandle<'_>;
  type BorrowedSocket (line 60) | pub type BorrowedSocket<'socket> = crate::doc::NotDefinedHere;
  type AsSocket (line 63) | pub trait AsSocket {
    method as_socket (line 65) | fn as_socket(&self) -> BorrowedSocket<'_>;

FILE: tokio/src/fs/canonicalize.rs
  function canonicalize (line 46) | pub async fn canonicalize(path: impl AsRef<Path>) -> io::Result<PathBuf> {

FILE: tokio/src/fs/copy.rs
  function copy (line 20) | pub async fn copy(from: impl AsRef<Path>, to: impl AsRef<Path>) -> Resul...

FILE: tokio/src/fs/create_dir.rs
  function create_dir (line 47) | pub async fn create_dir(path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/create_dir_all.rs
  function create_dir_all (line 48) | pub async fn create_dir_all(path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/dir_builder.rs
  type DirBuilder (line 11) | pub struct DirBuilder {
    method new (line 33) | pub fn new() -> Self {
    method recursive (line 52) | pub fn recursive(&mut self, recursive: bool) -> &mut Self {
    method create (line 91) | pub async fn create(&self, path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/file.rs
  type File (line 90) | pub struct File {
    method open (line 152) | pub async fn open(path: impl AsRef<Path>) -> io::Result<File> {
    method create (line 187) | pub async fn create(path: impl AsRef<Path>) -> io::Result<File> {
    method create_new (line 227) | pub async fn create_new<P: AsRef<Path>>(path: P) -> std::io::Result<Fi...
    method options (line 263) | pub fn options() -> OpenOptions {
    method from_std (line 277) | pub fn from_std(std: StdFile) -> File {
    method sync_all (line 312) | pub async fn sync_all(&self) -> io::Result<()> {
    method sync_data (line 347) | pub async fn sync_data(&self) -> io::Result<()> {
    method set_len (line 385) | pub async fn set_len(&self, size: u64) -> io::Result<()> {
    method metadata (line 444) | pub async fn metadata(&self) -> io::Result<Metadata> {
    method try_clone (line 464) | pub async fn try_clone(&self) -> io::Result<File> {
    method into_std (line 489) | pub async fn into_std(mut self) -> StdFile {
    method try_into_std (line 513) | pub fn try_into_std(mut self) -> Result<StdFile, Self> {
    method set_permissions (line 552) | pub async fn set_permissions(&self, perm: Permissions) -> io::Result<(...
    method set_max_buf_size (line 581) | pub fn set_max_buf_size(&mut self, max_buf_size: usize) {
    method max_buf_size (line 586) | pub fn max_buf_size(&self) -> usize {
    method from (line 888) | fn from(std: StdFile) -> Self {
    method fmt (line 894) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method as_raw_fd (line 903) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
    method as_fd (line 910) | fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> {
    method from_raw_fd (line 919) | unsafe fn from_raw_fd(fd: std::os::unix::io::RawFd) -> Self {
  type Inner (line 96) | struct Inner {
    method complete_inflight (line 955) | async fn complete_inflight(&mut self) {
    method poll_complete_inflight (line 961) | fn poll_complete_inflight(&mut self, cx: &mut Context<'_>) -> Poll<()> {
    method poll_flush (line 973) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), io::...
  type State (line 108) | enum State {
  type Operation (line 114) | enum Operation {
  method poll_read (line 592) | fn poll_read(
  method start_seek (line 665) | fn start_seek(self: Pin<&mut Self>, mut pos: SeekFrom) -> io::Result<()> {
  method poll_complete (line 697) | fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_write (line 729) | fn poll_write(
  method poll_write_vectored (line 800) | fn poll_write_vectored(
  method is_write_vectored (line 871) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 875) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_shutdown (line 881) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...

FILE: tokio/src/fs/file/tests.rs
  constant HELLO (line 9) | const HELLO: &[u8] = b"hello world...";
  constant FOO (line 10) | const FOO: &[u8] = b"foo bar baz...";
  function open_read (line 13) | fn open_read() {
  function read_twice_before_dispatch (line 39) | fn read_twice_before_dispatch() {
  function read_with_smaller_buf (line 63) | fn read_with_smaller_buf() {
  function read_with_bigger_buf (line 99) | fn read_with_bigger_buf() {
  function read_err_then_read_success (line 154) | fn read_err_then_read_success() {
  function open_write (line 196) | fn open_write() {
  function flush_while_idle (line 221) | fn flush_while_idle() {
  function read_with_buffer_larger_than_max (line 232) | fn read_with_buffer_larger_than_max() {
  function write_with_buffer_larger_than_max (line 304) | fn write_with_buffer_larger_than_max() {
  function write_twice_before_dispatch (line 372) | fn write_twice_before_dispatch() {
  function incomplete_read_followed_by_write (line 412) | fn incomplete_read_followed_by_write() {
  function incomplete_partial_read_followed_by_write (line 452) | fn incomplete_partial_read_followed_by_write() {
  function incomplete_read_followed_by_flush (line 496) | fn incomplete_read_followed_by_flush() {
  function incomplete_flush_followed_by_write (line 536) | fn incomplete_flush_followed_by_write() {
  function read_err (line 572) | fn read_err() {
  function write_write_err (line 592) | fn write_write_err() {
  function write_read_write_err (line 610) | fn write_read_write_err() {
  function write_read_flush_err (line 644) | fn write_read_flush_err() {
  function write_seek_write_err (line 678) | fn write_seek_write_err() {
  function write_seek_flush_err (line 710) | fn write_seek_flush_err() {
  function sync_all_ordered_after_write (line 742) | fn sync_all_ordered_after_write() {
  function sync_all_err_ordered_after_write (line 773) | fn sync_all_err_ordered_after_write() {
  function sync_data_ordered_after_write (line 806) | fn sync_data_ordered_after_write() {
  function sync_data_err_ordered_after_write (line 837) | fn sync_data_err_ordered_after_write() {
  function open_set_len_ok (line 870) | fn open_set_len_ok() {
  function open_set_len_err (line 886) | fn open_set_len_err() {
  function partial_read_set_len_ok (line 904) | fn partial_read_set_len_ok() {
  function busy_file_seek_error (line 960) | fn busy_file_seek_error() {

FILE: tokio/src/fs/hard_link.rs
  function hard_link (line 39) | pub async fn hard_link(original: impl AsRef<Path>, link: impl AsRef<Path...

FILE: tokio/src/fs/metadata.rs
  function metadata (line 43) | pub async fn metadata(path: impl AsRef<Path>) -> io::Result<Metadata> {

FILE: tokio/src/fs/mocks.rs
  method read (line 60) | fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
  method read (line 73) | fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
  method seek (line 86) | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
  method write (line 92) | fn write(&mut self, src: &[u8]) -> io::Result<usize> {
  method flush (line 96) | fn flush(&mut self) -> io::Result<()> {
  method from (line 104) | fn from(file: MockFile) -> OwnedFd {
  type JoinHandle (line 114) | pub(super) struct JoinHandle<T> {
  function spawn_blocking (line 118) | pub(super) fn spawn_blocking<F, R>(f: F) -> JoinHandle<R>
  function spawn_mandatory_blocking (line 133) | pub(super) fn spawn_mandatory_blocking<F, R>(f: F) -> Option<JoinHandle<R>>
  type Output (line 149) | type Output = Result<T, io::Error>;
  method poll (line 151) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function len (line 165) | pub(in super::super) fn len() -> usize {
  function run_one (line 169) | pub(in super::super) fn run_one() {

FILE: tokio/src/fs/mod.rs
  function asyncify (line 312) | pub(crate) async fn asyncify<F, T>(f: F) -> io::Result<T>

FILE: tokio/src/fs/open_options.rs
  type OpenOptions (line 88) | pub struct OpenOptions {
    method new (line 122) | pub fn new() -> OpenOptions {
    method read (line 168) | pub fn read(&mut self, read: bool) -> &mut OpenOptions {
    method write (line 212) | pub fn write(&mut self, write: bool) -> &mut OpenOptions {
    method append (line 285) | pub fn append(&mut self, append: bool) -> &mut OpenOptions {
    method truncate (line 332) | pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
    method create (line 382) | pub fn create(&mut self, create: bool) -> &mut OpenOptions {
    method create_new (line 439) | pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions {
    method open (line 520) | pub async fn open(&self, path: impl AsRef<Path>) -> io::Result<File> {
    method std_open (line 547) | async fn std_open(opts: &StdOpenOptions, path: impl AsRef<Path>) -> io...
    method as_inner_mut (line 556) | pub(super) fn as_inner_mut(&mut self) -> &mut StdOpenOptions {
    method from (line 841) | fn from(options: StdOpenOptions) -> OpenOptions {
  type Kind (line 93) | enum Kind {
  method default (line 853) | fn default() -> Self {

FILE: tokio/src/fs/open_options/uring_open_options.rs
  type UringOpenOptions (line 12) | pub(crate) struct UringOpenOptions {
    method new (line 24) | pub(crate) fn new() -> Self {
    method append (line 37) | pub(crate) fn append(&mut self, append: bool) -> &mut Self {
    method create (line 42) | pub(crate) fn create(&mut self, create: bool) -> &mut Self {
    method create_new (line 47) | pub(crate) fn create_new(&mut self, create_new: bool) -> &mut Self {
    method read (line 52) | pub(crate) fn read(&mut self, read: bool) -> &mut Self {
    method write (line 57) | pub(crate) fn write(&mut self, write: bool) -> &mut Self {
    method truncate (line 62) | pub(crate) fn truncate(&mut self, truncate: bool) -> &mut Self {
    method mode (line 67) | pub(crate) fn mode(&mut self, mode: u32) -> &mut Self {
    method custom_flags (line 72) | pub(crate) fn custom_flags(&mut self, flags: i32) -> &mut Self {
    method access_mode (line 78) | pub(crate) fn access_mode(&self) -> io::Result<libc::c_int> {
    method creation_mode (line 90) | pub(crate) fn creation_mode(&self) -> io::Result<libc::c_int> {
  method from (line 116) | fn from(value: UringOpenOptions) -> Self {

FILE: tokio/src/fs/read.rs
  function read (line 56) | pub async fn read(path: impl AsRef<Path>) -> io::Result<Vec<u8>> {

FILE: tokio/src/fs/read_dir.rs
  constant CHUNK_SIZE (line 22) | const CHUNK_SIZE: usize = 32;
  function read_dir (line 32) | pub async fn read_dir(path: impl AsRef<Path>) -> io::Result<ReadDir> {
  type ReadDir (line 64) | pub struct ReadDir(State);
    method next_entry (line 78) | pub async fn next_entry(&mut self) -> io::Result<Option<DirEntry>> {
    method poll_next_entry (line 101) | pub fn poll_next_entry(&mut self, cx: &mut Context<'_>) -> Poll<io::Re...
    method next_chunk (line 127) | fn next_chunk(buf: &mut VecDeque<io::Result<DirEntry>>, std: &mut std:...
  type State (line 67) | enum State {
  type DirEntry (line 200) | pub struct DirEntry {
    method path (line 244) | pub fn path(&self) -> PathBuf {
    method file_name (line 265) | pub fn file_name(&self) -> OsString {
    method metadata (line 299) | pub async fn metadata(&self) -> io::Result<Metadata> {
    method file_type (line 334) | pub async fn file_type(&self) -> io::Result<FileType> {
    method as_inner (line 354) | pub(super) fn as_inner(&self) -> &std::fs::DirEntry {

FILE: tokio/src/fs/read_link.rs
  function read_link (line 9) | pub async fn read_link(path: impl AsRef<Path>) -> io::Result<PathBuf> {

FILE: tokio/src/fs/read_to_string.rs
  function read_to_string (line 27) | pub async fn read_to_string(path: impl AsRef<Path>) -> io::Result<String> {

FILE: tokio/src/fs/read_uring.rs
  constant PROBE_SIZE (line 11) | const PROBE_SIZE: usize = 32;
  constant PROBE_SIZE_U32 (line 12) | const PROBE_SIZE_U32: u32 = PROBE_SIZE as u32;
  constant MAX_READ_SIZE (line 17) | const MAX_READ_SIZE: usize = 64 * 1024 * 1024;
  function read_uring (line 19) | pub(crate) async fn read_uring(path: &Path) -> io::Result<Vec<u8>> {
  function read_to_end_uring (line 39) | async fn read_to_end_uring(mut fd: OwnedFd, mut buf: Vec<u8>) -> io::Res...
  function small_probe_read (line 83) | async fn small_probe_read(
  function op_read (line 112) | async fn op_read(

FILE: tokio/src/fs/remove_dir.rs
  function remove_dir (line 9) | pub async fn remove_dir(path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/remove_dir_all.rs
  function remove_dir_all (line 11) | pub async fn remove_dir_all(path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/remove_file.rs
  function remove_file (line 13) | pub async fn remove_file(path: impl AsRef<Path>) -> io::Result<()> {

FILE: tokio/src/fs/rename.rs
  function rename (line 12) | pub async fn rename(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io:...

FILE: tokio/src/fs/set_permissions.rs
  function set_permissions (line 12) | pub async fn set_permissions(path: impl AsRef<Path>, perm: Permissions) ...

FILE: tokio/src/fs/symlink.rs
  function symlink (line 11) | pub async fn symlink(original: impl AsRef<Path>, link: impl AsRef<Path>)...

FILE: tokio/src/fs/symlink_dir.rs
  function symlink_dir (line 14) | pub async fn symlink_dir(original: impl AsRef<Path>, link: impl AsRef<Pa...

FILE: tokio/src/fs/symlink_file.rs
  function symlink_file (line 14) | pub async fn symlink_file(original: impl AsRef<Path>, link: impl AsRef<P...

FILE: tokio/src/fs/symlink_metadata.rs
  function symlink_metadata (line 12) | pub async fn symlink_metadata(path: impl AsRef<Path>) -> io::Result<Meta...

FILE: tokio/src/fs/try_exists.rs
  function try_exists (line 25) | pub async fn try_exists(path: impl AsRef<Path>) -> io::Result<bool> {

FILE: tokio/src/fs/write.rs
  function write (line 26) | pub async fn write(path: impl AsRef<Path>, contents: impl AsRef<[u8]>) -...
  function write_uring (line 58) | async fn write_uring(path: &Path, mut buf: OwnedBuf) -> io::Result<()> {
  function write_spawn_blocking (line 96) | async fn write_spawn_blocking(path: &Path, contents: OwnedBuf) -> io::Re...

FILE: tokio/src/future/maybe_done.rs
  function maybe_done (line 26) | pub fn maybe_done<F: IntoFuture>(future: F) -> MaybeDone<F::IntoFuture> {
  function output_mut (line 37) | pub fn output_mut(self: Pin<&mut Self>) -> Option<&mut Fut::Output> {
  function take_output (line 47) | pub fn take_output(self: Pin<&mut Self>) -> Option<Fut::Output> {
  type Output (line 61) | type Output = ();
  method poll (line 63) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type ThingAdder (line 86) | struct ThingAdder<'a> {
  type Output (line 91) | type Output = ();
  method poll (line 93) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Outpu...
  function maybe_done_miri (line 102) | fn maybe_done_miri() {
  type DummyWaker (line 118) | struct DummyWaker;
  method wake (line 121) | fn wake(self: Arc<Self>) {}

FILE: tokio/src/future/trace.rs
  type InstrumentedFuture (line 3) | pub(crate) trait InstrumentedFuture: Future {
    method id (line 4) | fn id(&self) -> Option<tracing::Id>;
    method id (line 8) | fn id(&self) -> Option<tracing::Id> {

FILE: tokio/src/future/try_join.rs
  function try_join3 (line 8) | pub(crate) fn try_join3<T1, F1, T2, F2, T3, F3, E>(
  type Output (line 47) | type Output = Result<(T1, T2, T3), E>;
  method poll (line 49) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/async_buf_read.rs
  type AsyncBufRead (line 23) | pub trait AsyncBufRead: AsyncRead {
    method poll_fill_buf (line 45) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method consume (line 62) | fn consume(self: Pin<&mut Self>, amt: usize);
    method poll_fill_buf (line 90) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method consume (line 94) | fn consume(self: Pin<&mut Self>, amt: usize) {
    method poll_fill_buf (line 100) | fn poll_fill_buf(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<...
    method consume (line 104) | fn consume(mut self: Pin<&mut Self>, amt: usize) {
    method poll_fill_buf (line 110) | fn poll_fill_buf(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<...
    method consume (line 114) | fn consume(self: Pin<&mut Self>, amt: usize) {

FILE: tokio/src/io/async_fd.rs
  type AsyncFd (line 181) | pub struct AsyncFd<T: AsRawFd> {
  type AsyncFdReadyGuard (line 194) | pub struct AsyncFdReadyGuard<'a, T: AsRawFd> {
  type AsyncFdReadyMutGuard (line 205) | pub struct AsyncFdReadyMutGuard<'a, T: AsRawFd> {
  function new (line 226) | pub fn new(inner: T) -> io::Result<Self>
  function with_interest (line 243) | pub fn with_interest(inner: T, interest: Interest) -> io::Result<Self>
  function new_with_handle_and_interest (line 251) | pub(crate) fn new_with_handle_and_interest(
  function try_new (line 277) | pub fn try_new(inner: T) -> Result<Self, AsyncFdTryNewError<T>>
  function try_with_interest (line 297) | pub fn try_with_interest(inner: T, interest: Interest) -> Result<Self, A...
  function try_new_with_handle_and_interest (line 305) | pub(crate) fn try_new_with_handle_and_interest(
  function get_ref (line 323) | pub fn get_ref(&self) -> &T {
  function get_mut (line 329) | pub fn get_mut(&mut self) -> &mut T {
  function take_inner (line 333) | fn take_inner(&mut self) -> Option<T> {
  function into_inner (line 344) | pub fn into_inner(mut self) -> T {
  function poll_read_ready (line 375) | pub fn poll_read_ready<'a>(
  function poll_read_ready_mut (line 412) | pub fn poll_read_ready_mut<'a>(
  function poll_write_ready (line 451) | pub fn poll_write_ready<'a>(
  function poll_write_ready_mut (line 488) | pub fn poll_write_ready_mut<'a>(
  function ready (line 589) | pub async fn ready(&self, interest: Interest) -> io::Result<AsyncFdReady...
  function ready_mut (line 685) | pub async fn ready_mut(
  function readable (line 713) | pub async fn readable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, ...
  function readable_mut (line 731) | pub async fn readable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMu...
  function writable (line 751) | pub async fn writable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, ...
  function writable_mut (line 769) | pub async fn writable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMu...
  function async_io (line 850) | pub async fn async_io<R>(
  function async_io_mut (line 866) | pub async fn async_io_mut<R>(
  function try_io (line 902) | pub fn try_io<R>(
  function try_io_mut (line 917) | pub fn try_io_mut<R>(
  method as_raw_fd (line 928) | fn as_raw_fd(&self) -> RawFd {
  function as_fd (line 934) | fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> {
  function fmt (line 940) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method drop (line 948) | fn drop(&mut self) {
  function clear_ready (line 969) | pub fn clear_ready(&mut self) {
  function clear_ready_matching (line 1058) | pub fn clear_ready_matching(&mut self, ready: Ready) {
  function retain_ready (line 1078) | pub fn retain_ready(&mut self) {
  function ready (line 1089) | pub fn ready(&self) -> Ready {
  function try_io (line 1151) | pub fn try_io<R>(
  function get_ref (line 1167) | pub fn get_ref(&self) -> &'a AsyncFd<Inner> {
  function get_inner (line 1172) | pub fn get_inner(&self) -> &'a Inner {
  function clear_ready (line 1193) | pub fn clear_ready(&mut self) {
  function clear_ready_matching (line 1282) | pub fn clear_ready_matching(&mut self, ready: Ready) {
  function retain_ready (line 1302) | pub fn retain_ready(&mut self) {
  function ready (line 1313) | pub fn ready(&self) -> Ready {
  function try_io (line 1336) | pub fn try_io<R>(
  function get_ref (line 1352) | pub fn get_ref(&self) -> &AsyncFd<Inner> {
  function get_mut (line 1357) | pub fn get_mut(&mut self) -> &mut AsyncFd<Inner> {
  function get_inner (line 1362) | pub fn get_inner(&self) -> &Inner {
  function get_inner_mut (line 1367) | pub fn get_inner_mut(&mut self) -> &mut Inner {
  function fmt (line 1373) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fmt (line 1381) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TryIoError (line 1395) | pub struct TryIoError(());
  type AsyncFdTryNewError (line 1401) | pub struct AsyncFdTryNewError<T> {
  function into_parts (line 1412) | pub fn into_parts(self) -> (T, io::Error) {
  function fmt (line 1418) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1424) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 1430) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  function from (line 1436) | fn from(value: AsyncFdTryNewError<T>) -> Self {

FILE: tokio/src/io/async_read.rs
  type AsyncRead (line 44) | pub trait AsyncRead {
    method poll_read (line 55) | fn poll_read(
    method poll_read (line 87) | fn poll_read(
    method poll_read (line 97) | fn poll_read(
    method poll_read (line 111) | fn poll_read(

FILE: tokio/src/io/async_seek.rs
  type AsyncSeek (line 18) | pub trait AsyncSeek {
    method start_seek (line 33) | fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<...
    method poll_complete (line 52) | fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method start_seek (line 80) | fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
    method poll_complete (line 84) | fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method start_seek (line 90) | fn start_seek(mut self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<(...
    method poll_complete (line 93) | fn poll_complete(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io...

FILE: tokio/src/io/async_write.rs
  type AsyncWrite (line 39) | pub trait AsyncWrite {
    method poll_write (line 52) | fn poll_write(
    method poll_flush (line 67) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::...
    method poll_shutdown (line 127) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method poll_write_vectored (line 152) | fn poll_write_vectored(
    method is_write_vectored (line 174) | fn is_write_vectored(&self) -> bool {
    method poll_write (line 224) | fn poll_write(
    method poll_write_vectored (line 232) | fn poll_write_vectored(
    method is_write_vectored (line 240) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 244) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::...
    method poll_shutdown (line 248) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method poll_write (line 254) | fn poll_write(
    method poll_write_vectored (line 263) | fn poll_write_vectored(
    method is_write_vectored (line 271) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 275) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io:...
    method poll_shutdown (line 279) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<...
    method poll_write (line 285) | fn poll_write(
    method poll_write_vectored (line 293) | fn poll_write_vectored(
    method is_write_vectored (line 301) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 305) | fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<i...
    method poll_shutdown (line 309) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method poll_write (line 315) | fn poll_write(
    method poll_write_vectored (line 323) | fn poll_write_vectored(
    method is_write_vectored (line 331) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 335) | fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<i...
    method poll_shutdown (line 339) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method poll_write (line 345) | fn poll_write(
    method poll_write_vectored (line 353) | fn poll_write_vectored(
    method is_write_vectored (line 361) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 365) | fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<i...
    method poll_shutdown (line 369) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...
    method poll_write (line 375) | fn poll_write(
    method poll_write_vectored (line 383) | fn poll_write_vectored(
    method is_write_vectored (line 391) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 395) | fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<i...
    method poll_shutdown (line 399) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<i...

FILE: tokio/src/io/blocking.rs
  type Blocking (line 14) | pub(crate) struct Blocking<T> {
  type Buf (line 22) | pub(crate) struct Buf {
    method with_capacity (line 196) | pub(crate) fn with_capacity(n: usize) -> Buf {
    method is_empty (line 203) | pub(crate) fn is_empty(&self) -> bool {
    method len (line 207) | pub(crate) fn len(&self) -> usize {
    method copy_to (line 211) | pub(crate) fn copy_to(&mut self, dst: &mut ReadBuf<'_>) -> usize {
    method copy_from (line 224) | pub(crate) fn copy_from(&mut self, src: &[u8], max_buf_size: usize) ->...
    method bytes (line 233) | pub(crate) fn bytes(&self) -> &[u8] {
    method read_from (line 241) | pub(crate) unsafe fn read_from<T: Read>(
    method write_to (line 270) | pub(crate) fn write_to<T: Write>(&mut self, wr: &mut T) -> io::Result<...
  constant DEFAULT_MAX_BUF_SIZE (line 27) | pub(crate) const DEFAULT_MAX_BUF_SIZE: usize = 2 * 1024 * 1024;
  type State (line 30) | enum State<T> {
  method poll_read (line 57) | fn poll_read(
  method poll_write (line 109) | fn poll_write(
  method poll_flush (line 146) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_shutdown (line 178) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...

FILE: tokio/src/io/bsd/poll_aio.rs
  type AioSource (line 20) | pub trait AioSource {
    method register (line 22) | fn register(&mut self, kq: RawFd, token: usize);
    method deregister (line 25) | fn deregister(&mut self);
  type MioSource (line 30) | struct MioSource<T>(T);
  method register (line 33) | fn register(
  method deregister (line 44) | fn deregister(&mut self, _registry: &Registry) -> io::Result<()> {
  method reregister (line 49) | fn reregister(
  type Aio (line 90) | pub struct Aio<E> {
  function new_for_aio (line 104) | pub fn new_for_aio(io: E) -> io::Result<Self> {
  function new_for_lio (line 116) | pub fn new_for_lio(io: E) -> io::Result<Self> {
  function new_with_interest (line 120) | fn new_with_interest(io: E, interest: Interest) -> io::Result<Self> {
  function clear_ready (line 144) | pub fn clear_ready(&self, ev: AioEvent) {
  function into_inner (line 149) | pub fn into_inner(self) -> E {
  function poll_ready (line 167) | pub fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<AioEve...
  type Target (line 174) | type Target = E;
  method deref (line 176) | fn deref(&self) -> &E {
  method deref_mut (line 182) | fn deref_mut(&mut self) -> &mut E {
  function fmt (line 188) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AioEvent (line 197) | pub struct AioEvent(ReadyEvent);

FILE: tokio/src/io/interest.rs
  constant READABLE (line 10) | const READABLE: usize = 0b0001;
  constant WRITABLE (line 11) | const WRITABLE: usize = 0b0010;
  constant AIO (line 14) | const AIO: usize = 0b0100;
  constant LIO (line 16) | const LIO: usize = 0b1000;
  constant PRIORITY (line 18) | const PRIORITY: usize = 0b0001_0000;
  constant ERROR (line 21) | const ERROR: usize = 0b0010_0000;
  type Interest (line 29) | pub struct Interest(usize);
    constant READABLE (line 55) | pub const READABLE: Interest = Interest(READABLE);
    constant WRITABLE (line 60) | pub const WRITABLE: Interest = Interest(WRITABLE);
    constant ERROR (line 66) | pub const ERROR: Interest = Interest(ERROR);
    constant PRIORITY (line 71) | pub const PRIORITY: Interest = Interest(PRIORITY);
    method is_readable (line 86) | pub const fn is_readable(self) -> bool {
    method is_writable (line 103) | pub const fn is_writable(self) -> bool {
    method is_error (line 120) | pub const fn is_error(self) -> bool {
    method is_aio (line 125) | const fn is_aio(self) -> bool {
    method is_lio (line 130) | const fn is_lio(self) -> bool {
    method is_priority (line 149) | pub const fn is_priority(self) -> bool {
    method add (line 167) | pub const fn add(self, other: Interest) -> Interest {
    method remove (line 195) | pub fn remove(self, other: Interest) -> Option<Interest> {
    method to_mio (line 206) | pub(crate) fn to_mio(self) -> mio::Interest {
    method mask (line 258) | pub(crate) fn mask(self) -> Ready {
    type Output (line 271) | type Output = Self;
    method bitor (line 274) | fn bitor(self, other: Self) -> Self {
    method bitor_assign (line 281) | fn bitor_assign(&mut self, other: Self) {
    method fmt (line 287) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/io/join.rs
  function join (line 11) | pub fn join<R, W>(reader: R, writer: W) -> Join<R, W>
  function into_inner (line 38) | pub fn into_inner(self) -> (R, W) {
  function reader (line 43) | pub fn reader(&self) -> &R {
  function writer (line 48) | pub fn writer(&self) -> &W {
  function reader_mut (line 53) | pub fn reader_mut(&mut self) -> &mut R {
  function writer_mut (line 58) | pub fn writer_mut(&mut self) -> &mut W {
  function reader_pin_mut (line 63) | pub fn reader_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R> {
  function writer_pin_mut (line 68) | pub fn writer_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
  method poll_read (line 77) | fn poll_read(
  method poll_write (line 90) | fn poll_write(
  method poll_flush (line 98) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 102) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write_vectored (line 106) | fn poll_write_vectored(
  method is_write_vectored (line 114) | fn is_write_vectored(&self) -> bool {
  method poll_fill_buf (line 123) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 127) | fn consume(self: Pin<&mut Self>, amt: usize) {

FILE: tokio/src/io/poll_evented.rs
  function new (line 89) | pub(crate) fn new(io: E) -> io::Result<Self> {
  function new_with_interest (line 110) | pub(crate) fn new_with_interest(io: E, interest: Interest) -> io::Result...
  function new_with_interest_and_handle (line 115) | pub(crate) fn new_with_interest_and_handle(
  function registration (line 129) | pub(crate) fn registration(&self) -> &Registration {
  function into_inner (line 135) | pub(crate) fn into_inner(mut self) -> io::Result<E> {
  function reregister (line 143) | pub(crate) fn reregister(&mut self, interest: Interest) -> io::Result<()> {
  type Target (line 299) | type Target = E;
  method deref (line 301) | fn deref(&self) -> &E {
  function fmt (line 307) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 313) | fn drop(&mut self) {

FILE: tokio/src/io/read_buf.rs
  type ReadBuf (line 23) | pub struct ReadBuf<'a> {
  function new (line 32) | pub fn new(buf: &'a mut [u8]) -> ReadBuf<'a> {
  function uninit (line 48) | pub fn uninit(buf: &'a mut [MaybeUninit<u8>]) -> ReadBuf<'a> {
  function capacity (line 58) | pub fn capacity(&self) -> usize {
  function filled (line 64) | pub fn filled(&self) -> &[u8] {
  function filled_mut (line 73) | pub fn filled_mut(&mut self) -> &mut [u8] {
  function take (line 82) | pub fn take(&mut self, n: usize) -> ReadBuf<'_> {
  function initialized (line 92) | pub fn initialized(&self) -> &[u8] {
  function initialized_mut (line 103) | pub fn initialized_mut(&mut self) -> &mut [u8] {
  function inner_mut (line 125) | pub unsafe fn inner_mut(&mut self) -> &mut [MaybeUninit<u8>] {
  function unfilled_mut (line 137) | pub unsafe fn unfilled_mut(&mut self) -> &mut [MaybeUninit<u8>] {
  function initialize_unfilled (line 146) | pub fn initialize_unfilled(&mut self) -> &mut [u8] {
  function initialize_unfilled_to (line 158) | pub fn initialize_unfilled_to(&mut self, n: usize) -> &mut [u8] {
  function remaining (line 181) | pub fn remaining(&self) -> usize {
  function clear (line 189) | pub fn clear(&mut self) {
  function advance (line 202) | pub fn advance(&mut self, n: usize) {
  function set_filled (line 219) | pub fn set_filled(&mut self, n: usize) {
  function assume_init (line 236) | pub unsafe fn assume_init(&mut self, n: usize) {
  function put_slice (line 250) | pub fn put_slice(&mut self, buf: &[u8]) {
  function remaining_mut (line 280) | fn remaining_mut(&self) -> usize {
  function advance_mut (line 285) | unsafe fn advance_mut(&mut self, cnt: usize) {
  function chunk_mut (line 292) | fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
  function fmt (line 307) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function slice_to_uninit_mut (line 320) | unsafe fn slice_to_uninit_mut(slice: &mut [u8]) -> &mut [MaybeUninit<u8>] {
  function slice_assume_init (line 330) | unsafe fn slice_assume_init(slice: &[MaybeUninit<u8>]) -> &[u8] {
  function slice_assume_init_mut (line 340) | unsafe fn slice_assume_init_mut(slice: &mut [MaybeUninit<u8>]) -> &mut [...

FILE: tokio/src/io/ready.rs
  constant READABLE (line 8) | const READABLE: usize = 0b0_01;
  constant WRITABLE (line 9) | const WRITABLE: usize = 0b0_10;
  constant READ_CLOSED (line 10) | const READ_CLOSED: usize = 0b0_0100;
  constant WRITE_CLOSED (line 11) | const WRITE_CLOSED: usize = 0b0_1000;
  constant PRIORITY (line 13) | const PRIORITY: usize = 0b1_0000;
  constant ERROR (line 14) | const ERROR: usize = 0b10_0000;
  type Ready (line 21) | pub struct Ready(usize);
    constant EMPTY (line 25) | pub const EMPTY: Ready = Ready(0);
    constant READABLE (line 28) | pub const READABLE: Ready = Ready(READABLE);
    constant WRITABLE (line 31) | pub const WRITABLE: Ready = Ready(WRITABLE);
    constant READ_CLOSED (line 34) | pub const READ_CLOSED: Ready = Ready(READ_CLOSED);
    constant WRITE_CLOSED (line 37) | pub const WRITE_CLOSED: Ready = Ready(WRITE_CLOSED);
    constant PRIORITY (line 42) | pub const PRIORITY: Ready = Ready(PRIORITY);
    constant ERROR (line 45) | pub const ERROR: Ready = Ready(ERROR);
    constant ALL (line 49) | pub const ALL: Ready =
    constant ALL (line 54) | pub const ALL: Ready = Ready(READABLE | WRITABLE | READ_CLOSED | WRITE...
    method from_mio (line 57) | pub(crate) fn from_mio(event: &mio::event::Event) -> Ready {
    method is_empty (line 111) | pub fn is_empty(self) -> bool {
    method is_readable (line 127) | pub fn is_readable(self) -> bool {
    method is_writable (line 143) | pub fn is_writable(self) -> bool {
    method is_read_closed (line 158) | pub fn is_read_closed(self) -> bool {
    method is_write_closed (line 173) | pub fn is_write_closed(self) -> bool {
    method is_priority (line 190) | pub fn is_priority(self) -> bool {
    method is_error (line 205) | pub fn is_error(self) -> bool {
    method contains (line 214) | pub(crate) fn contains<T: Into<Self>>(self, other: T) -> bool {
    method from_usize (line 226) | pub(crate) fn from_usize(val: usize) -> Ready {
    method as_usize (line 234) | pub(crate) fn as_usize(self) -> usize {
    method from_interest (line 238) | pub(crate) fn from_interest(interest: Interest) -> Ready {
    method intersection (line 264) | pub(crate) fn intersection(self, interest: Interest) -> Ready {
    method satisfies (line 268) | pub(crate) fn satisfies(self, interest: Interest) -> bool {
    type Output (line 274) | type Output = Ready;
    method bitor (line 277) | fn bitor(self, other: Ready) -> Ready {
    method bitor_assign (line 284) | fn bitor_assign(&mut self, other: Ready) {
    type Output (line 290) | type Output = Ready;
    method bitand (line 293) | fn bitand(self, other: Ready) -> Ready {
    type Output (line 299) | type Output = Ready;
    method sub (line 302) | fn sub(self, other: Ready) -> Ready {
    method fmt (line 308) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/io/seek.rs
  function seek (line 23) | pub(crate) fn seek<S>(seek: &mut S, pos: SeekFrom) -> Seek<'_, S>
  type Output (line 38) | type Output = io::Result<u64>;
  method poll (line 40) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/split.rs
  type Inner (line 53) | struct Inner<T> {
  function with_lock (line 59) | fn with_lock<R>(&self, f: impl FnOnce(Pin<&mut T>) -> R) -> R {
  function is_pair_of (line 72) | pub fn is_pair_of(&self, other: &WriteHalf<T>) -> bool {
  function unsplit (line 84) | pub fn unsplit(self, wr: WriteHalf<T>) -> T
  function is_pair_of (line 105) | pub fn is_pair_of(&self, other: &ReadHalf<T>) -> bool {
  method poll_read (line 111) | fn poll_read(
  method poll_write (line 121) | fn poll_write(
  method poll_flush (line 129) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 133) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write_vectored (line 137) | fn poll_write_vectored(
  method is_write_vectored (line 146) | fn is_write_vectored(&self) -> bool {
  function fmt (line 157) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 163) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/io/stderr.rs
  method as_raw_fd (line 101) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 107) | fn as_fd(&self) -> BorrowedFd<'_> {
  method poll_write (line 130) | fn poll_write(
  method poll_flush (line 138) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_shutdown (line 142) | fn poll_shutdown(

FILE: tokio/src/io/stdin.rs
  method as_raw_fd (line 62) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 68) | fn as_fd(&self) -> BorrowedFd<'_> {
  method poll_read (line 91) | fn poll_read(

FILE: tokio/src/io/stdio_common.rs
  type SplitByUtf8BoundaryIfWindows (line 12) | pub(crate) struct SplitByUtf8BoundaryIfWindows<W> {
  function new (line 17) | pub(crate) fn new(inner: W) -> Self {
  constant MAX_BYTES_PER_CHAR (line 23) | const MAX_BYTES_PER_CHAR: usize = 4;
  constant MAGIC_CONST (line 26) | const MAGIC_CONST: usize = 8;
  function poll_write (line 32) | fn poll_write(
  function poll_flush (line 94) | fn poll_flush(
  function poll_shutdown (line 101) | fn poll_shutdown(
  type TextMockWriter (line 119) | struct TextMockWriter;
    method poll_write (line 122) | fn poll_write(
    method poll_flush (line 132) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Res...
    method poll_shutdown (line 136) | fn poll_shutdown(
  type LoggingMockWriter (line 144) | struct LoggingMockWriter {
    method new (line 149) | fn new() -> Self {
    method poll_write (line 157) | fn poll_write(
    method poll_flush (line 167) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Res...
    method poll_shutdown (line 171) | fn poll_shutdown(
  function test_splitter (line 181) | fn test_splitter() {
  function test_pseudo_text (line 195) | fn test_pseudo_text() {

FILE: tokio/src/io/stdout.rs
  method as_raw_fd (line 150) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 156) | fn as_fd(&self) -> BorrowedFd<'_> {
  method poll_write (line 179) | fn poll_write(
  method poll_flush (line 187) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_shutdown (line 191) | fn poll_shutdown(

FILE: tokio/src/io/uring/open.rs
  type Open (line 13) | pub(crate) struct Open {
  type Output (line 21) | type Output = io::Result<crate::fs::File>;
  method complete (line 22) | fn complete(self, cqe: CqeResult) -> Self::Output {
  method complete_with_error (line 27) | fn complete_with_error(self, err: Error) -> Self::Output {
  method cancel (line 33) | fn cancel(self) -> CancelData {
  function open (line 40) | pub(crate) fn open(path: &Path, options: &UringOpenOptions) -> io::Resul...

FILE: tokio/src/io/uring/read.rs
  type Read (line 8) | pub(crate) struct Read {
  type Output (line 14) | type Output = (io::Result<u32>, OwnedFd, Vec<u8>);
  method complete (line 16) | fn complete(self, cqe: CqeResult) -> Self::Output {
  method complete_with_error (line 28) | fn complete_with_error(self, err: Error) -> Self::Output {
  method cancel (line 34) | fn cancel(self) -> CancelData {
  function read (line 49) | pub(crate) fn read(fd: OwnedFd, mut buf: Vec<u8>, len: u32, offset: u64)...

FILE: tokio/src/io/uring/utils.rs
  function cstr (line 4) | pub(crate) fn cstr(p: &Path) -> io::Result<CString> {

FILE: tokio/src/io/uring/write.rs
  type Write (line 9) | pub(crate) struct Write {
  type Output (line 15) | type Output = (io::Result<u32>, OwnedBuf, OwnedFd);
  method complete (line 16) | fn complete(self, cqe: CqeResult) -> Self::Output {
  method complete_with_error (line 20) | fn complete_with_error(self, err: Error) -> Self::Output {
  method cancel (line 26) | fn cancel(self) -> CancelData {
  function write_at (line 34) | pub(crate) fn write_at(

FILE: tokio/src/io/util/buf_reader.rs
  function new (line 40) | pub fn new(inner: R) -> Self {
  function with_capacity (line 45) | pub fn with_capacity(capacity: usize, inner: R) -> Self {
  function get_ref (line 59) | pub fn get_ref(&self) -> &R {
  function get_mut (line 66) | pub fn get_mut(&mut self) -> &mut R {
  function get_pin_mut (line 73) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R> {
  function into_inner (line 80) | pub fn into_inner(self) -> R {
  function buffer (line 87) | pub fn buffer(&self) -> &[u8] {
  function discard_buffer (line 93) | fn discard_buffer(self: Pin<&mut Self>) {
  method poll_read (line 101) | fn poll_read(
  method poll_fill_buf (line 123) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 140) | fn consume(self: Pin<&mut Self>, amt: usize) {
  type SeekState (line 147) | pub(super) enum SeekState {
  method start_seek (line 177) | fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
  method poll_complete (line 187) | fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_write (line 262) | fn poll_write(
  method poll_write_vectored (line 270) | fn poll_write_vectored(
  method is_write_vectored (line 278) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 282) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 286) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  function fmt (line 292) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function assert_unpin (line 308) | fn assert_unpin() {

FILE: tokio/src/io/util/buf_stream.rs
  function new (line 29) | pub fn new(stream: RW) -> BufStream<RW> {
  function with_capacity (line 39) | pub fn with_capacity(
  function get_ref (line 55) | pub fn get_ref(&self) -> &RW {
  function get_mut (line 62) | pub fn get_mut(&mut self) -> &mut RW {
  function get_pin_mut (line 69) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut RW> {
  function into_inner (line 76) | pub fn into_inner(self) -> RW {
  function from (line 82) | fn from(b: BufReader<BufWriter<RW>>) -> Self {
  function from (line 88) | fn from(b: BufWriter<BufReader<RW>>) -> Self {
  method poll_write (line 122) | fn poll_write(
  method poll_write_vectored (line 130) | fn poll_write_vectored(
  method is_write_vectored (line 138) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 142) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 146) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method poll_read (line 152) | fn poll_read(
  method start_seek (line 180) | fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
  method poll_complete (line 184) | fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method poll_fill_buf (line 190) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 194) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function assert_unpin (line 204) | fn assert_unpin() {

FILE: tokio/src/io/util/buf_writer.rs
  function new (line 44) | pub fn new(inner: W) -> Self {
  function with_capacity (line 49) | pub fn with_capacity(cap: usize, inner: W) -> Self {
  function flush_buf (line 58) | fn flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Res...
  function get_ref (line 87) | pub fn get_ref(&self) -> &W {
  function get_mut (line 94) | pub fn get_mut(&mut self) -> &mut W {
  function get_pin_mut (line 101) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
  function into_inner (line 108) | pub fn into_inner(self) -> W {
  function buffer (line 113) | pub fn buffer(&self) -> &[u8] {
  method poll_write (line 119) | fn poll_write(
  method poll_write_vectored (line 136) | fn poll_write_vectored(
  method is_write_vectored (line 198) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 202) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 207) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  type SeekState (line 214) | pub(super) enum SeekState {
  method start_seek (line 227) | fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
  method poll_complete (line 235) | fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_read (line 270) | fn poll_read(
  method poll_fill_buf (line 280) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 284) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function fmt (line 290) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function assert_unpin (line 307) | fn assert_unpin() {

FILE: tokio/src/io/util/chain.rs
  function chain (line 22) | pub(super) fn chain<T, U>(first: T, second: U) -> Chain<T, U>
  function get_ref (line 40) | pub fn get_ref(&self) -> (&T, &U) {
  function get_mut (line 49) | pub fn get_mut(&mut self) -> (&mut T, &mut U) {
  function get_pin_mut (line 58) | pub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut T>, Pin<&mut U>) {
  function into_inner (line 64) | pub fn into_inner(self) -> (T, U) {
  function fmt (line 74) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method poll_read (line 87) | fn poll_read(
  method poll_fill_buf (line 112) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 126) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function assert_unpin (line 141) | fn assert_unpin() {

FILE: tokio/src/io/util/copy.rs
  type CopyBuffer (line 9) | pub(super) struct CopyBuffer {
    method new (line 19) | pub(super) fn new(buf_size: usize) -> Self {
    method poll_fill_buf (line 30) | fn poll_fill_buf<R>(
    method poll_write_buf (line 51) | fn poll_write_buf<R, W>(
    method poll_copy (line 75) | pub(super) fn poll_copy<R, W>(
  type Copy (line 221) | struct Copy<'a, R: ?Sized, W: ?Sized> {
  type Output (line 295) | type Output = io::Result<u64>;
  method poll (line 297) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Resu...

FILE: tokio/src/io/util/copy_bidirectional.rs
  type TransferState (line 10) | enum TransferState {
  function transfer_one_direction (line 16) | fn transfer_one_direction<A, B>(
  function copy_bidirectional (line 75) | pub async fn copy_bidirectional<A, B>(a: &mut A, b: &mut B) -> io::Resul...
  function copy_bidirectional_with_sizes (line 94) | pub async fn copy_bidirectional_with_sizes<A, B>(
  function copy_bidirectional_impl (line 113) | async fn copy_bidirectional_impl<A, B>(

FILE: tokio/src/io/util/copy_buf.rs
  type Output (line 87) | type Output = io::Result<u64>;
  method poll (line 89) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function assert_unpin (line 113) | fn assert_unpin() {

FILE: tokio/src/io/util/empty.rs
  method poll_read (line 69) | fn poll_read(
  method poll_fill_buf (line 82) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 89) | fn consume(self: Pin<&mut Self>, _: usize) {}
  method poll_write (line 94) | fn poll_write(
  method poll_flush (line 105) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 112) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method is_write_vectored (line 119) | fn is_write_vectored(&self) -> bool {
  method poll_write_vectored (line 124) | fn poll_write_vectored(
  method start_seek (line 138) | fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<(...
  method poll_complete (line 143) | fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method fmt (line 151) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function assert_unpin (line 161) | fn assert_unpin() {

FILE: tokio/src/io/util/fill_buf.rs
  function fill_buf (line 21) | pub(crate) fn fill_buf<R>(reader: &mut R) -> FillBuf<'_, R>
  type Output (line 32) | type Output = io::Result<&'a [u8]>;
  method poll (line 34) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/flush.rs
  function flush (line 27) | pub(super) fn flush<A>(a: &mut A) -> Flush<'_, A>
  type Output (line 41) | type Output = io::Result<()>;
  method poll (line 43) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/lines.rs
  function lines (line 32) | pub(crate) fn lines<R>(reader: R) -> Lines<R>
  function next_line (line 69) | pub async fn next_line(&mut self) -> io::Result<Option<String>> {
  function get_mut (line 76) | pub fn get_mut(&mut self) -> &mut R {
  function get_ref (line 81) | pub fn get_ref(&mut self) -> &R {
  function into_inner (line 89) | pub fn into_inner(self) -> R {
  function poll_next_line (line 112) | pub fn poll_next_line(
  function assert_unpin (line 142) | fn assert_unpin() {

FILE: tokio/src/io/util/mem.rs
  type DuplexStream (line 49) | pub struct DuplexStream {
  type SimplexStream (line 77) | pub struct SimplexStream {
    method new_unsplit (line 222) | pub fn new_unsplit(max_buf_size: usize) -> SimplexStream {
    method close_write (line 232) | fn close_write(&mut self) {
    method close_read (line 240) | fn close_read(&mut self) {
    method poll_read_internal (line 248) | fn poll_read_internal(
    method poll_write_internal (line 273) | fn poll_write_internal(
    method poll_write_vectored_internal (line 295) | fn poll_write_vectored_internal(
  function duplex (line 104) | pub fn duplex(max_buf_size: usize) -> (DuplexStream, DuplexStream) {
  method poll_read (line 127) | fn poll_read(
  method poll_write (line 138) | fn poll_write(
  method poll_write_vectored (line 146) | fn poll_write_vectored(
  method is_write_vectored (line 154) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 159) | fn poll_flush(
  method poll_shutdown (line 167) | fn poll_shutdown(
  method drop (line 176) | fn drop(&mut self) {
  function simplex (line 211) | pub fn simplex(max_buf_size: usize) -> (ReadHalf<SimplexStream>, WriteHa...
  method is_write_vectored (line 414) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 418) | fn poll_flush(self: Pin<&mut Self>, _: &mut task::Context<'_>) -> Poll<s...
  method poll_shutdown (line 422) | fn poll_shutdown(

FILE: tokio/src/io/util/read.rs
  function read (line 16) | pub(crate) fn read<'a, R>(reader: &'a mut R, buf: &'a mut [u8]) -> Read<...
  type Output (line 47) | type Output = io::Result<usize>;
  method poll (line 49) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/io/util/read_buf.rs
  function read_buf (line 11) | pub(crate) fn read_buf<'a, R, B>(reader: &'a mut R, buf: &'a mut B) -> R...
  type Output (line 40) | type Output = io::Result<usize>;
  method poll (line 42) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/io/util/read_exact.rs
  function read_exact (line 16) | pub(crate) fn read_exact<'a, A>(reader: &'a mut A, buf: &'a mut [u8]) ->...
  function eof (line 43) | fn eof() -> io::Error {
  type Output (line 51) | type Output = io::Result<usize>;
  method poll (line 53) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/io/util/read_line.rs
  function read_line (line 33) | pub(crate) fn read_line<'a, R>(reader: &'a mut R, string: &'a mut String...
  function put_back_original_data (line 46) | fn put_back_original_data(output: &mut String, mut vector: Vec<u8>, num_...
  function finish_string_read (line 56) | pub(super) fn finish_string_read(
  function read_line_internal (line 94) | pub(super) fn read_line_internal<R: AsyncBufRead + ?Sized>(
  type Output (line 112) | type Output = io::Result<usize>;
  method poll (line 114) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/read_to_end.rs
  function read_to_end (line 27) | pub(crate) fn read_to_end<'a, R>(reader: &'a mut R, buffer: &'a mut Vec<...
  function read_to_end_internal (line 39) | pub(super) fn read_to_end_internal<V: VecU8, R: AsyncRead + ?Sized>(
  function poll_read_to_end (line 60) | fn poll_read_to_end<V: VecU8, R: AsyncRead + ?Sized>(
  type Output (line 136) | type Output = io::Result<usize>;
  method poll (line 138) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/read_to_string.rs
  function read_to_string (line 33) | pub(crate) fn read_to_string<'a, R>(
  function read_to_string_internal (line 50) | fn read_to_string_internal<R: AsyncRead + ?Sized>(
  type Output (line 71) | type Output = io::Result<usize>;
  method poll (line 73) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/read_until.rs
  function read_until (line 30) | pub(crate) fn read_until<'a, R>(
  function read_until_internal (line 47) | pub(super) fn read_until_internal<R: AsyncBufRead + ?Sized>(
  type Output (line 74) | type Output = io::Result<usize>;
  method poll (line 76) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/repeat.rs
  method poll_read (line 54) | fn poll_read(
  function assert_unpin (line 71) | fn assert_unpin() {

FILE: tokio/src/io/util/shutdown.rs
  function shutdown (line 26) | pub(super) fn shutdown<A>(a: &mut A) -> Shutdown<'_, A>
  type Output (line 40) | type Output = io::Result<()>;
  method poll (line 42) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/io/util/sink.rs
  method poll_write (line 55) | fn poll_write(
  method poll_flush (line 66) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 73) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method fmt (line 81) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function assert_unpin (line 91) | fn assert_unpin() {

FILE: tokio/src/io/util/split.rs
  function split (line 28) | pub(crate) fn split<R>(reader: R, delim: u8) -> Split<R>
  function next_segment (line 61) | pub async fn next_segment(&mut self) -> io::Result<Option<Vec<u8>>> {
  function poll_next_segment (line 89) | pub fn poll_next_segment(
  function assert_unpin (line 118) | fn assert_unpin() {

FILE: tokio/src/io/util/take.rs
  function take (line 22) | pub(super) fn take<R: AsyncRead>(inner: R, limit: u64) -> Take<R> {
  function limit (line 37) | pub fn limit(&self) -> u64 {
  function set_limit (line 45) | pub fn set_limit(&mut self, limit: u64) {
  function get_ref (line 50) | pub fn get_ref(&self) -> &R {
  function get_mut (line 59) | pub fn get_mut(&mut self) -> &mut R {
  function get_pin_mut (line 68) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R> {
  function into_inner (line 73) | pub fn into_inner(self) -> R {
  method poll_read (line 79) | fn poll_read(
  method poll_fill_buf (line 108) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method consume (line 121) | fn consume(self: Pin<&mut Self>, amt: usize) {
  function assert_unpin (line 135) | fn assert_unpin() {

FILE: tokio/src/io/util/vec_with_initialized.rs
  type VecU8 (line 11) | pub(crate) unsafe trait VecU8: AsRef<Vec<u8>> + AsMut<Vec<u8>> {}
  type VecWithInitialized (line 26) | pub(crate) struct VecWithInitialized<V> {
  function take (line 36) | pub(crate) fn take(&mut self) -> Vec<u8> {
  function new (line 46) | pub(crate) fn new(mut vec: V) -> Self {
  function reserve (line 56) | pub(crate) fn reserve(&mut self, num_bytes: usize) {
  function is_empty (line 68) | pub(crate) fn is_empty(&self) -> bool {
  function get_read_buf (line 72) | pub(crate) fn get_read_buf<'a>(&'a mut self) -> ReadBuf<'a> {
  function apply_read_buf (line 96) | pub(crate) fn apply_read_buf(&mut self, parts: ReadBufParts) {
  function try_small_read_first (line 119) | pub(crate) fn try_small_read_first(&self, num_bytes: usize) -> bool {
  type ReadBufParts (line 127) | pub(crate) struct ReadBufParts {
  function into_read_buf_parts (line 136) | pub(crate) fn into_read_buf_parts(rb: ReadBuf<'_>) -> ReadBufParts {

FILE: tokio/src/io/util/write.rs
  function write (line 25) | pub(crate) fn write<'a, W>(writer: &'a mut W, buf: &'a [u8]) -> Write<'a...
  type Output (line 40) | type Output = io::Result<usize>;
  method poll (line 42) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/io/util/write_all.rs
  function write_all (line 23) | pub(crate) fn write_all<'a, W>(writer: &'a mut W, buf: &'a [u8]) -> Writ...
  type Output (line 38) | type Output = io::Result<()>;
  method poll (line 40) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<(...

FILE: tokio/src/io/util/write_all_buf.rs
  function write_all_buf (line 25) | pub(crate) fn write_all_buf<'a, W, B>(writer: &'a mut W, buf: &'a mut B)...
  type Output (line 42) | type Output = io::Result<()>;
  method poll (line 44) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<(...

FILE: tokio/src/io/util/write_buf.rs
  function write_buf (line 25) | pub(crate) fn write_buf<'a, W, B>(writer: &'a mut W, buf: &'a mut B) -> ...
  type Output (line 42) | type Output = io::Result<usize>;
  method poll (line 44) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/io/util/write_vectored.rs
  function write_vectored (line 23) | pub(crate) fn write_vectored<'a, 'b, W>(
  type Output (line 41) | type Output = io::Result<usize>;
  method poll (line 43) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u...

FILE: tokio/src/lib.rs
  function async_trace_leaf (line 583) | pub(crate) async fn async_trace_leaf() {
  function is_unpin (line 690) | fn is_unpin<T: Unpin>() {}

FILE: tokio/src/loom/mocked.rs
  type Mutex (line 8) | pub(crate) struct Mutex<T>(loom::sync::Mutex<T>);
  function new (line 13) | pub(crate) fn new(t: T) -> Mutex<T> {
  function lock (line 19) | pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
  function try_lock (line 24) | pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
  type RwLock (line 30) | pub(crate) struct RwLock<T>(loom::sync::RwLock<T>);
  function new (line 35) | pub(crate) fn new(t: T) -> Self {
  function read (line 40) | pub(crate) fn read(&self) -> RwLockReadGuard<'_, T> {
  function try_read (line 45) | pub(crate) fn try_read(&self) -> Option<RwLockReadGuard<'_, T>> {
  function write (line 50) | pub(crate) fn write(&self) -> RwLockWriteGuard<'_, T> {
  function try_write (line 55) | pub(crate) fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>> {
  function seed (line 64) | pub(crate) fn seed() -> u64 {
  function num_cpus (line 70) | pub(crate) fn num_cpus() -> usize {

FILE: tokio/src/loom/std/atomic_u16.rs
  type AtomicU16 (line 7) | pub(crate) struct AtomicU16 {
    method new (line 17) | pub(crate) const fn new(val: u16) -> AtomicU16 {
    method unsync_load (line 28) | pub(crate) unsafe fn unsync_load(&self) -> u16 {
    method fmt (line 44) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 34) | type Target = std::sync::atomic::AtomicU16;
  method deref (line 36) | fn deref(&self) -> &Self::Target {

FILE: tokio/src/loom/std/atomic_u32.rs
  type AtomicU32 (line 7) | pub(crate) struct AtomicU32 {
    method new (line 17) | pub(crate) const fn new(val: u32) -> AtomicU32 {
    method unsync_load (line 28) | pub(crate) unsafe fn unsync_load(&self) -> u32 {
    method fmt (line 44) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 34) | type Target = std::sync::atomic::AtomicU32;
  method deref (line 36) | fn deref(&self) -> &Self::Target {

FILE: tokio/src/loom/std/atomic_u64_as_mutex.rs
  type AtomicU64 (line 17) | pub(crate) struct AtomicU64 {
    method load (line 22) | pub(crate) fn load(&self, _: Ordering) -> u64 {
    method store (line 26) | pub(crate) fn store(&self, val: u64, _: Ordering) {
    method fetch_add (line 30) | pub(crate) fn fetch_add(&self, val: u64, _: Ordering) -> u64 {
    method fetch_or (line 37) | pub(crate) fn fetch_or(&self, val: u64, _: Ordering) -> u64 {
    method compare_exchange (line 44) | pub(crate) fn compare_exchange(
    method compare_exchange_weak (line 61) | pub(crate) fn compare_exchange_weak(
  method default (line 73) | fn default() -> AtomicU64 {

FILE: tokio/src/loom/std/atomic_u64_native.rs
  type StaticAtomicU64 (line 4) | pub(crate) type StaticAtomicU64 = AtomicU64;

FILE: tokio/src/loom/std/atomic_u64_static_const_new.rs
  type StaticAtomicU64 (line 4) | pub(crate) type StaticAtomicU64 = AtomicU64;
  method new (line 7) | pub(crate) const fn new(val: u64) -> Self {

FILE: tokio/src/loom/std/atomic_u64_static_once_cell.rs
  type StaticAtomicU64 (line 5) | pub(crate) struct StaticAtomicU64 {
    method new (line 19) | pub(crate) const fn new(val: u64) -> StaticAtomicU64 {
    method load (line 26) | pub(crate) fn load(&self, order: Ordering) -> u64 {
    method fetch_add (line 30) | pub(crate) fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
    method compare_exchange_weak (line 37) | pub(crate) fn compare_exchange_weak(
    method inner (line 54) | fn inner(&self) -> &Mutex<u64> {
  method new (line 11) | pub(crate) fn new(val: u64) -> Self {

FILE: tokio/src/loom/std/atomic_usize.rs
  type AtomicUsize (line 7) | pub(crate) struct AtomicUsize {
    method new (line 17) | pub(crate) const fn new(val: usize) -> AtomicUsize {
    method unsync_load (line 28) | pub(crate) unsafe fn unsync_load(&self) -> usize {
    method with_mut (line 32) | pub(crate) fn with_mut<R>(&mut self, f: impl FnOnce(&mut usize) -> R) ...
    type Target (line 39) | type Target = std::sync::atomic::AtomicUsize;
    method deref (line 41) | fn deref(&self) -> &Self::Target {
    method deref_mut (line 49) | fn deref_mut(&mut self) -> &mut Self::Target {
    method fmt (line 56) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/loom/std/barrier.rs
  type Barrier (line 38) | pub(crate) struct Barrier {
    method fmt (line 64) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 85) | pub(crate) fn new(n: usize) -> Barrier {
    method wait (line 132) | pub(crate) fn wait(&self) -> BarrierWaitResult {
    method wait_timeout (line 153) | pub(crate) fn wait_timeout(&self, timeout: Duration) -> Option<Barrier...
  type BarrierState (line 45) | struct BarrierState {
  type BarrierWaitResult (line 61) | pub(crate) struct BarrierWaitResult(bool);
    method fmt (line 196) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method is_leader (line 220) | pub(crate) fn is_leader(&self) -> bool {

FILE: tokio/src/loom/std/mod.rs
  function seed (line 40) | pub(crate) fn seed() -> u64 {
  function num_cpus (line 85) | pub(crate) fn num_cpus() -> usize {
  function num_cpus (line 108) | pub(crate) fn num_cpus() -> usize {
  function yield_now (line 115) | pub(crate) fn yield_now() {

FILE: tokio/src/loom/std/mutex.rs
  type Mutex (line 6) | pub(crate) struct Mutex<T: ?Sized>(sync::Mutex<T>);
  function new (line 11) | pub(crate) fn new(t: T) -> Mutex<T> {
  function const_new (line 16) | pub(crate) const fn const_new(t: T) -> Mutex<T> {
  function lock (line 21) | pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
  function try_lock (line 29) | pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {

FILE: tokio/src/loom/std/parking_lot.rs
  type Mutex (line 22) | pub(crate) struct Mutex<T: ?Sized>(PhantomData<std::sync::Mutex<T>>, par...
  type RwLock (line 25) | pub(crate) struct RwLock<T>(PhantomData<std::sync::RwLock<T>>, parking_l...
  type Condvar (line 28) | pub(crate) struct Condvar(PhantomData<std::sync::Condvar>, parking_lot::...
    method new (line 142) | pub(crate) fn new() -> Condvar {
    method notify_one (line 147) | pub(crate) fn notify_one(&self) {
    method notify_all (line 152) | pub(crate) fn notify_all(&self) {
    method wait (line 157) | pub(crate) fn wait<'a, T>(
    method wait_timeout (line 166) | pub(crate) fn wait_timeout<'a, T>(
  type MutexGuard (line 31) | pub(crate) struct MutexGuard<'a, T: ?Sized>(
  type RwLockReadGuard (line 37) | pub(crate) struct RwLockReadGuard<'a, T: ?Sized>(
  type RwLockWriteGuard (line 43) | pub(crate) struct RwLockWriteGuard<'a, T: ?Sized>(
  function new (line 50) | pub(crate) fn new(t: T) -> Mutex<T> {
  function const_new (line 56) | pub(crate) const fn const_new(t: T) -> Mutex<T> {
  function lock (line 61) | pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
  function try_lock (line 66) | pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
  function get_mut (line 73) | pub(crate) fn get_mut(&mut self) -> &mut T {
  type Target (line 82) | type Target = T;
  method deref (line 83) | fn deref(&self) -> &T {
  method deref_mut (line 89) | fn deref_mut(&mut self) -> &mut T {
  function new (line 95) | pub(crate) fn new(t: T) -> RwLock<T> {
  function read (line 99) | pub(crate) fn read(&self) -> RwLockReadGuard<'_, T> {
  function try_read (line 103) | pub(crate) fn try_read(&self) -> Option<RwLockReadGuard<'_, T>> {
  function write (line 109) | pub(crate) fn write(&self) -> RwLockWriteGuard<'_, T> {
  function try_write (line 113) | pub(crate) fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>> {
  type Target (line 121) | type Target = T;
  method deref (line 122) | fn deref(&self) -> &T {
  type Target (line 128) | type Target = T;
  method deref (line 129) | fn deref(&self) -> &T {
  method deref_mut (line 135) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 180) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 186) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 192) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/loom/std/rwlock.rs
  type RwLock (line 6) | pub(crate) struct RwLock<T: ?Sized>(sync::RwLock<T>);
  function new (line 11) | pub(crate) fn new(t: T) -> Self {
  function read (line 16) | pub(crate) fn read(&self) -> RwLockReadGuard<'_, T> {
  function try_read (line 24) | pub(crate) fn try_read(&self) -> Option<RwLockReadGuard<'_, T>> {
  function write (line 33) | pub(crate) fn write(&self) -> RwLockWriteGuard<'_, T> {
  function try_write (line 41) | pub(crate) fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>> {

FILE: tokio/src/loom/std/unsafe_cell.rs
  type UnsafeCell (line 2) | pub(crate) struct UnsafeCell<T>(std::cell::UnsafeCell<T>);
  function new (line 5) | pub(crate) const fn new(data: T) -> UnsafeCell<T> {
  function with (line 10) | pub(crate) fn with<R>(&self, f: impl FnOnce(*const T) -> R) -> R {
  function with_mut (line 15) | pub(crate) fn with_mut<R>(&self, f: impl FnOnce(*mut T) -> R) -> R {

FILE: tokio/src/macros/join.rs
  type RotatorSelect (line 229) | pub trait RotatorSelect {
    type Rotator (line 243) | type Rotator<const COUNT: u32> = Rotator<COUNT>;
    type Rotator (line 247) | type Rotator<const COUNT: u32> = BiasedRotator;
  type SelectNormal (line 236) | pub struct SelectNormal;
  type SelectBiased (line 240) | pub struct SelectBiased;
  type Rotator (line 252) | pub struct Rotator<const COUNT: u32> {
  function num_skip (line 259) | pub fn num_skip(&mut self) -> u32 {
  type BiasedRotator (line 271) | pub struct BiasedRotator {}
    method num_skip (line 276) | pub fn num_skip(&mut self) -> u32 {

FILE: tokio/src/net/addr.rs
  type ToSocketAddrs (line 19) | pub trait ToSocketAddrs: sealed::ToSocketAddrsPriv {}
  type ReadyFuture (line 21) | type ReadyFuture<T> = future::Ready<io::Result<T>>;
  type Iter (line 40) | type Iter = T::Iter;
  type Future (line 41) | type Future = T::Future;
  function to_socket_addrs (line 43) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 53) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 54) | type Future = ReadyFuture<Self::Iter>;
  method to_socket_addrs (line 56) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 67) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 68) | type Future = ReadyFuture<Self::Iter>;
  method to_socket_addrs (line 70) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 80) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 81) | type Future = ReadyFuture<Self::Iter>;
  method to_socket_addrs (line 83) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 93) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 94) | type Future = ReadyFuture<Self::Iter>;
  function to_socket_addrs (line 96) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 107) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 108) | type Future = ReadyFuture<Self::Iter>;
  function to_socket_addrs (line 110) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 121) | type Iter = std::option::IntoIter<SocketAddr>;
  type Future (line 122) | type Future = ReadyFuture<Self::Iter>;
  function to_socket_addrs (line 124) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type Iter (line 135) | type Iter = std::vec::IntoIter<SocketAddr>;
  type Future (line 136) | type Future = ReadyFuture<Self::Iter>;
  function to_socket_addrs (line 138) | fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future {
  type ToSocketAddrsPriv (line 262) | pub trait ToSocketAddrsPriv {
    method to_socket_addrs (line 266) | fn to_socket_addrs(&self, internal: Internal) -> Self::Future;
  type Internal (line 270) | pub struct Internal;

FILE: tokio/src/net/tcp/listener.rs
  method accept (line 163) | pub async fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
  method poll_accept (line 180) | pub fn poll_accept(&self, cx: &mut Context<'_>) -> Poll<io::Result<(TcpS...
  method from_std (line 244) | pub fn from_std(listener: net::TcpListener) -> io::Result<TcpListener> {
  method into_std (line 274) | pub fn into_std(self) -> io::Result<std::net::TcpListener> {
  method local_addr (line 333) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method ttl (line 360) | pub fn ttl(&self) -> io::Result<u32> {
  method set_ttl (line 385) | pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
  type Error (line 391) | type Error = io::Error;
  method try_from (line 397) | fn try_from(stream: net::TcpListener) -> Result<Self, Self::Error> {
  method fmt (line 403) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_raw_fd (line 414) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 420) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/tcp/socket.rs
  method new_v4 (line 126) | pub fn new_v4() -> io::Result<TcpSocket> {
  method new_v6 (line 159) | pub fn new_v6() -> io::Result<TcpSocket> {
  method new (line 163) | fn new(domain: socket2::Domain) -> io::Result<TcpSocket> {
  method set_keepalive (line 192) | pub fn set_keepalive(&self, keepalive: bool) -> io::Result<()> {
  method keepalive (line 197) | pub fn keepalive(&self) -> io::Result<bool> {
  method set_reuseaddr (line 227) | pub fn set_reuseaddr(&self, reuseaddr: bool) -> io::Result<()> {
  method reuseaddr (line 253) | pub fn reuseaddr(&self) -> io::Result<bool> {
  method set_reuseport (line 297) | pub fn set_reuseport(&self, reuseport: bool) -> io::Result<()> {
  method reuseport (line 342) | pub fn reuseport(&self) -> io::Result<bool> {
  method set_send_buffer_size (line 349) | pub fn set_send_buffer_size(&self, size: u32) -> io::Result<()> {
  method send_buffer_size (line 376) | pub fn send_buffer_size(&self) -> io::Result<u32> {
  method set_recv_buffer_size (line 383) | pub fn set_recv_buffer_size(&self, size: u32) -> io::Result<()> {
  method recv_buffer_size (line 410) | pub fn recv_buffer_size(&self) -> io::Result<u32> {
  method set_linger (line 438) | pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
  method set_zero_linger (line 456) | pub fn set_zero_linger(&self) -> io::Result<()> {
  method linger (line 467) | pub fn linger(&self) -> io::Result<Option<Duration>> {
  method set_nodelay (line 490) | pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
  method nodelay (line 512) | pub fn nodelay(&self) -> io::Result<bool> {
  method tclass_v6 (line 547) | pub fn tclass_v6(&self) -> io::Result<u32> {
  method set_tclass_v6 (line 585) | pub fn set_tclass_v6(&self, tclass: u32) -> io::Result<()> {
  method tos_v4 (line 612) | pub fn tos_v4(&self) -> io::Result<u32> {
  method tos (line 640) | pub fn tos(&self) -> io::Result<u32> {
  method set_tos_v4 (line 672) | pub fn set_tos_v4(&self, tos: u32) -> io::Result<()> {
  method set_tos (line 700) | pub fn set_tos(&self, tos: u32) -> io::Result<()> {
  method device (line 712) | pub fn device(&self) -> io::Result<Option<Vec<u8>>> {
  method bind_device (line 728) | pub fn bind_device(&self, interface: Option<&[u8]>) -> io::Result<()> {
  method local_addr (line 754) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method take_error (line 759) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  method bind (line 791) | pub fn bind(&self, addr: SocketAddr) -> io::Result<()> {
  method connect (line 827) | pub async fn connect(self, addr: SocketAddr) -> io::Result<TcpStream> {
  method listen (line 892) | pub fn listen(self, backlog: u32) -> io::Result<TcpListener> {
  method from_std_stream (line 947) | pub fn from_std_stream(std_stream: std::net::TcpStream) -> TcpSocket {
  function convert_address (line 966) | fn convert_address(address: socket2::SockAddr) -> io::Result<SocketAddr> {
  method fmt (line 977) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/net/tcp/split.rs
  type ReadHalf (line 33) | pub struct ReadHalf<'a>(&'a TcpStream);
  type WriteHalf (line 49) | pub struct WriteHalf<'a>(&'a TcpStream);
  function split (line 51) | pub(crate) fn split(stream: &mut TcpStream) -> (ReadHalf<'_>, WriteHalf<...
  function poll_peek (line 90) | pub fn poll_peek(
  function peek (line 137) | pub async fn peek(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  function ready (line 165) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  function readable (line 182) | pub async fn readable(&self) -> io::Result<()> {
  function try_read (line 209) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
  function try_read_vectored (line 238) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::...
  function peer_addr (line 268) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  function local_addr (line 273) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  function ready (line 302) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  function writable (line 317) | pub async fn writable(&self) -> io::Result<()> {
  function try_write (line 334) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
  function try_write_vectored (line 355) | pub fn try_write_vectored(&self, bufs: &[io::IoSlice<'_>]) -> io::Result...
  function peer_addr (line 360) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  function local_addr (line 365) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method poll_read (line 371) | fn poll_read(
  method poll_write (line 381) | fn poll_write(
  method poll_write_vectored (line 389) | fn poll_write_vectored(
  method is_write_vectored (line 397) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 402) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 408) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  function as_ref (line 414) | fn as_ref(&self) -> &TcpStream {
  function as_ref (line 420) | fn as_ref(&self) -> &TcpStream {

FILE: tokio/src/net/tcp/split_owned.rs
  type OwnedReadHalf (line 35) | pub struct OwnedReadHalf {
    method reunite (line 107) | pub fn reunite(self, other: OwnedWriteHalf) -> Result<TcpStream, Reuni...
    method poll_peek (line 145) | pub fn poll_peek(
    method peek (line 192) | pub async fn peek(&mut self, buf: &mut [u8]) -> io::Result<usize> {
    method ready (line 220) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method readable (line 237) | pub async fn readable(&self) -> io::Result<()> {
    method try_read (line 264) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
    method try_read_vectored (line 293) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io...
    method peer_addr (line 323) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
    method local_addr (line 328) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method as_ref (line 498) | fn as_ref(&self) -> &TcpStream {
  type OwnedWriteHalf (line 54) | pub struct OwnedWriteHalf {
    method reunite (line 349) | pub fn reunite(self, other: OwnedReadHalf) -> Result<TcpStream, Reunit...
    method forget (line 356) | pub fn forget(mut self) {
    method ready (line 384) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method writable (line 399) | pub async fn writable(&self) -> io::Result<()> {
    method try_write (line 416) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
    method try_write_vectored (line 437) | pub fn try_write_vectored(&self, bufs: &[io::IoSlice<'_>]) -> io::Resu...
    method peer_addr (line 442) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
    method local_addr (line 447) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method as_ref (line 504) | fn as_ref(&self) -> &TcpStream {
  function split_owned (line 59) | pub(crate) fn split_owned(stream: TcpStream) -> (OwnedReadHalf, OwnedWri...
  function reunite (line 71) | pub(crate) fn reunite(
  type ReuniteError (line 88) | pub struct ReuniteError(pub OwnedReadHalf, pub OwnedWriteHalf);
    method fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method poll_read (line 334) | fn poll_read(
  method drop (line 453) | fn drop(&mut self) {
  method poll_write (line 461) | fn poll_write(
  method poll_write_vectored (line 469) | fn poll_write_vectored(
  method is_write_vectored (line 477) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 482) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 488) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...

FILE: tokio/src/net/tcp/stream.rs
  method new (line 160) | pub(crate) fn new(connected: mio::net::TcpStream) -> io::Result<TcpStrea...
  method from_std (line 207) | pub fn from_std(stream: std::net::TcpStream) -> io::Result<TcpStream> {
  method into_std (line 254) | pub fn into_std(self) -> io::Result<std::net::TcpStream> {
  method local_addr (line 297) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method take_error (line 302) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  method peer_addr (line 320) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  method poll_peek (line 366) | pub fn poll_peek(
  method ready (line 465) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  method readable (line 520) | pub async fn readable(&self) -> io::Result<()> {
  method poll_read_ready (line 554) | pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method try_read (line 621) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
  method try_read_vectored (line 699) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::...
  method writable (line 832) | pub async fn writable(&self) -> io::Result<()> {
  method poll_write_ready (line 866) | pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method try_write (line 918) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
  method try_write_vectored (line 980) | pub fn try_write_vectored(&self, bufs: &[io::IoSlice<'_>]) -> io::Result...
  method try_io (line 1020) | pub fn try_io<R>(
  method async_io (line 1055) | pub async fn async_io<R>(
  method peek (line 1110) | pub async fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
  method shutdown_std (line 1127) | pub(super) fn shutdown_std(&self, how: Shutdown) -> io::Result<()> {
  method nodelay (line 1152) | pub fn nodelay(&self) -> io::Result<bool> {
  method set_nodelay (line 1176) | pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
  method quickack (line 1211) | pub fn quickack(&self) -> io::Result<bool> {
  method set_quickack (line 1251) | pub fn set_quickack(&self, quickack: bool) -> io::Result<()> {
  method ttl (line 1374) | pub fn ttl(&self) -> io::Result<u32> {
  method set_ttl (line 1395) | pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
  method split (line 1409) | pub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>) {
  method into_split (line 1424) | pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf) {
  method poll_read_priv (line 1434) | pub(crate) fn poll_read_priv(
  method poll_write_priv (line 1443) | pub(super) fn poll_write_priv(
  method poll_write_vectored_priv (line 1451) | pub(super) fn poll_write_vectored_priv(
  type Error (line 1461) | type Error = io::Error;
  method try_from (line 1467) | fn try_from(stream: std::net::TcpStream) -> Result<Self, Self::Error> {
  method poll_read (line 1475) | fn poll_read(
  method poll_write (line 1485) | fn poll_write(
  method poll_write_vectored (line 1493) | fn poll_write_vectored(
  method is_write_vectored (line 1501) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 1506) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 1511) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  method fmt (line 1518) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_ref (line 1525) | fn as_ref(&self) -> &Self {
  method as_raw_fd (line 1536) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 1542) | fn as_fd(&self) -> BorrowedFd<'_> {
  method as_raw_fd (line 1570) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 1576) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/udp.rs
  method bind (line 150) | pub async fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
  method bind_addr (line 169) | fn bind_addr(addr: SocketAddr) -> io::Result<UdpSocket> {
  method new (line 175) | fn new(socket: mio::net::UdpSocket) -> io::Result<UdpSocket> {
  method from_std (line 227) | pub fn from_std(socket: net::UdpSocket) -> io::Result<UdpSocket> {
  method into_std (line 256) | pub fn into_std(self) -> io::Result<std::net::UdpSocket> {
  method as_socket (line 276) | fn as_socket(&self) -> socket2::SockRef<'_> {
  method local_addr (line 297) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method peer_addr (line 320) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  method connect (line 348) | pub async fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
  method ready (line 435) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  method writable (line 490) | pub async fn writable(&self) -> io::Result<()> {
  method poll_send_ready (line 524) | pub fn poll_send_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method send (line 565) | pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
  method poll_send (line 595) | pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Re...
  method try_send (line 649) | pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
  method readable (line 710) | pub async fn readable(&self) -> io::Result<()> {
  method poll_recv_ready (line 744) | pub fn poll_recv_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method recv (line 785) | pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
  method poll_recv (line 815) | pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> ...
  method try_recv (line 884) | pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
  method send_to (line 1174) | pub async fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> io...
  method poll_send_to (line 1203) | pub fn poll_send_to(
  method try_send_to (line 1261) | pub fn try_send_to(&self, buf: &[u8], target: SocketAddr) -> io::Result<...
  method send_to_addr (line 1267) | async fn send_to_addr(&self, buf: &[u8], target: SocketAddr) -> io::Resu...
  method recv_from (line 1315) | pub async fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, Sock...
  method poll_recv_from (line 1348) | pub fn poll_recv_from(
  method try_recv_from (line 1429) | pub fn try_recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, Socket...
  method try_io (line 1467) | pub fn try_io<R>(
  method async_io (line 1502) | pub async fn async_io<R>(
  method peek (line 1556) | pub async fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
  method poll_peek (line 1602) | pub fn poll_peek(&self, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> ...
  method try_peek (line 1648) | pub fn try_peek(&self, buf: &mut [u8]) -> io::Result<usize> {
  method peek_from (line 1698) | pub async fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, Sock...
  method poll_peek_from (line 1745) | pub fn poll_peek_from(
  method try_peek_from (line 1796) | pub fn try_peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, Socket...
  method peek_sender (line 1815) | pub async fn peek_sender(&self) -> io::Result<SocketAddr> {
  method poll_peek_sender (line 1842) | pub fn poll_peek_sender(&self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method try_peek_sender (line 1860) | pub fn try_peek_sender(&self) -> io::Result<SocketAddr> {
  method peek_sender_inner (line 1867) | fn peek_sender_inner(&self) -> io::Result<SocketAddr> {
  method broadcast (line 1884) | pub fn broadcast(&self) -> io::Result<bool> {
  method set_broadcast (line 1892) | pub fn set_broadcast(&self, on: bool) -> io::Result<()> {
  method multicast_loop_v4 (line 1901) | pub fn multicast_loop_v4(&self) -> io::Result<bool> {
  method set_multicast_loop_v4 (line 1912) | pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> {
  method multicast_ttl_v4 (line 1921) | pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
  method set_multicast_ttl_v4 (line 1934) | pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> {
  method multicast_loop_v6 (line 1943) | pub fn multicast_loop_v6(&self) -> io::Result<bool> {
  method set_multicast_loop_v6 (line 1954) | pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> {
  method tclass_v6 (line 1989) | pub fn tclass_v6(&self) -> io::Result<u32> {
  method set_tclass_v6 (line 2027) | pub fn set_tclass_v6(&self, tclass: u32) -> io::Result<()> {
  method ttl (line 2050) | pub fn ttl(&self) -> io::Result<u32> {
  method set_ttl (line 2072) | pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
  method tos_v4 (line 2099) | pub fn tos_v4(&self) -> io::Result<u32> {
  method tos (line 2127) | pub fn tos(&self) -> io::Result<u32> {
  method set_tos_v4 (line 2159) | pub fn set_tos_v4(&self, tos: u32) -> io::Result<()> {
  method set_tos (line 2187) | pub fn set_tos(&self, tos: u32) -> io::Result<()> {
  method device (line 2199) | pub fn device(&self) -> io::Result<Option<Vec<u8>>> {
  method bind_device (line 2215) | pub fn bind_device(&self, interface: Option<&[u8]>) -> io::Result<()> {
  method join_multicast_v4 (line 2226) | pub fn join_multicast_v4(&self, multiaddr: Ipv4Addr, interface: Ipv4Addr...
  method join_multicast_v6 (line 2235) | pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) ->...
  method leave_multicast_v4 (line 2244) | pub fn leave_multicast_v4(&self, multiaddr: Ipv4Addr, interface: Ipv4Add...
  method leave_multicast_v6 (line 2253) | pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -...
  method take_error (line 2277) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  type Error (line 2283) | type Error = io::Error;
  method try_from (line 2289) | fn try_from(stream: std::net::UdpSocket) -> Result<Self, Self::Error> {
  method fmt (line 2295) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_raw_fd (line 2306) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 2312) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/unix/datagram/socket.rs
  method from_mio (line 102) | pub(crate) fn from_mio(sys: mio::net::UnixDatagram) -> io::Result<UnixDa...
  method ready (line 182) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  method writable (line 239) | pub async fn writable(&self) -> io::Result<()> {
  method poll_send_ready (line 273) | pub fn poll_send_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method readable (line 335) | pub async fn readable(&self) -> io::Result<()> {
  method poll_recv_ready (line 369) | pub fn poll_recv_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method bind (line 395) | pub fn bind<P>(path: P) -> io::Result<UnixDatagram>
  method pair (line 433) | pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> {
  method from_std (line 491) | pub fn from_std(datagram: net::UnixDatagram) -> io::Result<UnixDatagram> {
  method into_std (line 520) | pub fn into_std(self) -> io::Result<std::os::unix::net::UnixDatagram> {
  method new (line 527) | fn new(socket: mio::net::UnixDatagram) -> io::Result<UnixDatagram> {
  method unbound (line 564) | pub fn unbound() -> io::Result<UnixDatagram> {
  method connect (line 607) | pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
  method send (line 644) | pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
  method try_send (line 689) | pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
  method try_send_to (line 732) | pub fn try_send_to<P>(&self, buf: &[u8], target: P) -> io::Result<usize>
  method recv (line 775) | pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
  method try_recv (line 826) | pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
  method send_to (line 1101) | pub async fn send_to<P>(&self, buf: &[u8], target: P) -> io::Result<usize>
  method recv_from (line 1152) | pub async fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, Sock...
  method poll_recv_from (line 1179) | pub fn poll_recv_from(
  method poll_send_to (line 1219) | pub fn poll_send_to<P>(
  method poll_send (line 1256) | pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Re...
  method poll_recv (line 1285) | pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> ...
  method try_recv_from (line 1347) | pub fn try_recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, Socket...
  method try_io (line 1388) | pub fn try_io<R>(
  method async_io (line 1423) | pub async fn async_io<R>(
  method local_addr (line 1476) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method peer_addr (line 1527) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  method take_error (line 1551) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  method shutdown (line 1588) | pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
  type Error (line 1594) | type Error = io::Error;
  method try_from (line 1600) | fn try_from(stream: std::os::unix::net::UnixDatagram) -> Result<Self, Se...
  method fmt (line 1606) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_raw_fd (line 1612) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 1618) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/unix/listener.rs
  method new (line 60) | pub(crate) fn new(listener: mio::net::UnixListener) -> io::Result<UnixLi...
  method bind (line 76) | pub fn bind<P>(path: P) -> io::Result<UnixListener>
  method from_std (line 140) | pub fn from_std(listener: net::UnixListener) -> io::Result<UnixListener> {
  method into_std (line 168) | pub fn into_std(self) -> io::Result<std::os::unix::net::UnixListener> {
  method local_addr (line 176) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method take_error (line 181) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  method accept (line 193) | pub async fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
  method poll_accept (line 211) | pub fn poll_accept(&self, cx: &mut Context<'_>) -> Poll<io::Result<(Unix...
  type Error (line 220) | type Error = io::Error;
  method try_from (line 226) | fn try_from(stream: std::os::unix::net::UnixListener) -> io::Result<Self> {
  method fmt (line 232) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_raw_fd (line 238) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 244) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/unix/mod.rs
  type uid_t (line 31) | pub type uid_t = u32;
  type gid_t (line 35) | pub type gid_t = u32;
  type pid_t (line 39) | pub type pid_t = i32;

FILE: tokio/src/net/unix/pipe.rs
  function pipe (line 67) | pub fn pipe() -> io::Result<(Sender, Receiver)> {
  type OpenOptions (line 122) | pub struct OpenOptions {
    method new (line 132) | pub fn new() -> OpenOptions {
    method read_write (line 173) | pub fn read_write(&mut self, value: bool) -> &mut Self {
    method unchecked (line 205) | pub fn unchecked(&mut self, value: bool) -> &mut Self {
    method open_receiver (line 229) | pub fn open_receiver<P: AsRef<Path>>(&self, path: P) -> io::Result<Rec...
    method open_sender (line 255) | pub fn open_sender<P: AsRef<Path>>(&self, path: P) -> io::Result<Sende...
    method open (line 260) | fn open(&self, path: &Path, pipe_end: PipeEnd) -> io::Result<File> {
  method default (line 283) | fn default() -> OpenOptions {
  type PipeEnd (line 289) | enum PipeEnd {
  type Sender (line 365) | pub struct Sender {
    method from_mio (line 370) | fn from_mio(mio_tx: mio_pipe::Sender) -> io::Result<Sender> {
    method from_file (line 394) | pub fn from_file(file: File) -> io::Result<Sender> {
    method from_owned_fd (line 419) | pub fn from_owned_fd(owned_fd: OwnedFd) -> io::Result<Sender> {
    method from_file_unchecked (line 474) | pub fn from_file_unchecked(file: File) -> io::Result<Sender> {
    method from_owned_fd_unchecked (line 494) | pub fn from_owned_fd_unchecked(owned_fd: OwnedFd) -> io::Result<Sender> {
    method ready (line 519) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method writable (line 564) | pub async fn writable(&self) -> io::Result<()> {
    method poll_write_ready (line 596) | pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Resul...
    method try_write (line 653) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
    method try_write_vectored (line 719) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Resul...
    method into_blocking_fd (line 729) | pub fn into_blocking_fd(self) -> io::Result<OwnedFd> {
    method into_nonblocking_fd (line 740) | pub fn into_nonblocking_fd(self) -> io::Result<OwnedFd> {
  method poll_write (line 752) | fn poll_write(
  method poll_write_vectored (line 760) | fn poll_write_vectored(
  method is_write_vectored (line 768) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 772) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 776) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  method as_raw_fd (line 782) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 788) | fn as_fd(&self) -> BorrowedFd<'_> {
  type Receiver (line 861) | pub struct Receiver {
    method from_mio (line 866) | fn from_mio(mio_rx: mio_pipe::Receiver) -> io::Result<Receiver> {
    method from_file (line 890) | pub fn from_file(file: File) -> io::Result<Receiver> {
    method from_owned_fd (line 915) | pub fn from_owned_fd(owned_fd: OwnedFd) -> io::Result<Receiver> {
    method from_file_unchecked (line 970) | pub fn from_file_unchecked(file: File) -> io::Result<Receiver> {
    method from_owned_fd_unchecked (line 990) | pub fn from_owned_fd_unchecked(owned_fd: OwnedFd) -> io::Result<Receiv...
    method ready (line 1015) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method readable (line 1064) | pub async fn readable(&self) -> io::Result<()> {
    method poll_read_ready (line 1096) | pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result...
    method try_read (line 1160) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
    method try_read_vectored (line 1234) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io...
    method into_blocking_fd (line 1322) | pub fn into_blocking_fd(self) -> io::Result<OwnedFd> {
    method into_nonblocking_fd (line 1333) | pub fn into_nonblocking_fd(self) -> io::Result<OwnedFd> {
  method poll_read (line 1345) | fn poll_read(
  method as_raw_fd (line 1357) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 1363) | fn as_fd(&self) -> BorrowedFd<'_> {
  function is_pipe (line 1369) | fn is_pipe(fd: BorrowedFd<'_>) -> io::Result<bool> {
  function get_file_flags (line 1386) | fn get_file_flags(fd: BorrowedFd<'_>) -> io::Result<libc::c_int> {
  function has_read_access (line 1397) | fn has_read_access(flags: libc::c_int) -> bool {
  function has_write_access (line 1403) | fn has_write_access(flags: libc::c_int) -> bool {
  function set_nonblocking (line 1409) | fn set_nonblocking(fd: BorrowedFd<'_>, current_flags: libc::c_int) -> io...
  function set_blocking (line 1425) | fn set_blocking<T: AsRawFd>(fd: &T) -> io::Result<()> {

FILE: tokio/src/net/unix/socket.rs
  method ty (line 95) | fn ty(&self) -> socket2::Type {
  method new_datagram (line 107) | pub fn new_datagram() -> io::Result<UnixSocket> {
  method new_stream (line 119) | pub fn new_stream() -> io::Result<UnixSocket> {
  method new (line 123) | fn new(ty: socket2::Type) -> io::Result<UnixSocket> {
  method bind (line 153) | pub fn bind(&self, path: impl AsRef<Path>) -> io::Result<()> {
  method listen (line 171) | pub fn listen(self, backlog: u32) -> io::Result<UnixListener> {
  method connect (line 201) | pub async fn connect(self, path: impl AsRef<Path>) -> io::Result<UnixStr...
  method datagram (line 230) | pub fn datagram(self) -> io::Result<UnixDatagram> {
  method as_raw_fd (line 249) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 255) | fn as_fd(&self) -> BorrowedFd<'_> {
  method from_raw_fd (line 261) | unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket {
  method into_raw_fd (line 270) | fn into_raw_fd(self) -> RawFd {

FILE: tokio/src/net/unix/socketaddr.rs
  type SocketAddr (line 10) | pub struct SocketAddr(pub(super) std::os::unix::net::SocketAddr);
    method is_unnamed (line 18) | pub fn is_unnamed(&self) -> bool {
    method as_pathname (line 27) | pub fn as_pathname(&self) -> Option<&Path> {
    method as_abstract_name (line 40) | pub fn as_abstract_name(&self) -> Option<&[u8]> {
    method fmt (line 51) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 57) | fn from(value: std::os::unix::net::SocketAddr) -> Self {
  function from (line 63) | fn from(value: SocketAddr) -> Self {

FILE: tokio/src/net/unix/split.rs
  type ReadHalf (line 33) | pub struct ReadHalf<'a>(&'a UnixStream);
  type WriteHalf (line 49) | pub struct WriteHalf<'a>(&'a UnixStream);
  function split (line 51) | pub(crate) fn split(stream: &mut UnixStream) -> (ReadHalf<'_>, WriteHalf...
  function ready (line 79) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  function readable (line 94) | pub async fn readable(&self) -> io::Result<()> {
  function try_read (line 121) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
  function try_read_vectored (line 174) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::...
  function peer_addr (line 179) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  function local_addr (line 184) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  function ready (line 213) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  function writable (line 228) | pub async fn writable(&self) -> io::Result<()> {
  function try_write (line 245) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
  function try_write_vectored (line 266) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Result<...
  function peer_addr (line 271) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  function local_addr (line 276) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method poll_read (line 282) | fn poll_read(
  method poll_write (line 292) | fn poll_write(
  method poll_write_vectored (line 300) | fn poll_write_vectored(
  method is_write_vectored (line 308) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 312) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 316) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  function as_ref (line 322) | fn as_ref(&self) -> &UnixStream {
  function as_ref (line 328) | fn as_ref(&self) -> &UnixStream {

FILE: tokio/src/net/unix/split_owned.rs
  type OwnedReadHalf (line 35) | pub struct OwnedReadHalf {
    method reunite (line 107) | pub fn reunite(self, other: OwnedWriteHalf) -> Result<UnixStream, Reun...
    method ready (line 134) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method readable (line 149) | pub async fn readable(&self) -> io::Result<()> {
    method try_read (line 176) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
    method try_read_vectored (line 230) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io...
    method peer_addr (line 235) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
    method local_addr (line 240) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method as_ref (line 410) | fn as_ref(&self) -> &UnixStream {
  type OwnedWriteHalf (line 54) | pub struct OwnedWriteHalf {
    method reunite (line 261) | pub fn reunite(self, other: OwnedReadHalf) -> Result<UnixStream, Reuni...
    method forget (line 268) | pub fn forget(mut self) {
    method ready (line 296) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method writable (line 311) | pub async fn writable(&self) -> io::Result<()> {
    method try_write (line 328) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
    method try_write_vectored (line 349) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Resul...
    method peer_addr (line 354) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
    method local_addr (line 359) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method as_ref (line 416) | fn as_ref(&self) -> &UnixStream {
  function split_owned (line 59) | pub(crate) fn split_owned(stream: UnixStream) -> (OwnedReadHalf, OwnedWr...
  function reunite (line 71) | pub(crate) fn reunite(
  type ReuniteError (line 88) | pub struct ReuniteError(pub OwnedReadHalf, pub OwnedWriteHalf);
    method fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method poll_read (line 246) | fn poll_read(
  method drop (line 365) | fn drop(&mut self) {
  method poll_write (line 373) | fn poll_write(
  method poll_write_vectored (line 381) | fn poll_write_vectored(
  method is_write_vectored (line 389) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 394) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 400) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...

FILE: tokio/src/net/unix/stream.rs
  method connect_mio (line 49) | pub(crate) async fn connect_mio(sys: mio::net::UnixStream) -> io::Result...
  method connect (line 72) | pub async fn connect<P>(path: P) -> io::Result<UnixStream>
  method ready (line 176) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
  method readable (line 233) | pub async fn readable(&self) -> io::Result<()> {
  method poll_read_ready (line 267) | pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method try_read (line 336) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
  method try_read_vectored (line 414) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::...
  method writable (line 549) | pub async fn writable(&self) -> io::Result<()> {
  method poll_write_ready (line 583) | pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method try_write (line 637) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
  method try_write_vectored (line 699) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Result<...
  method try_io (line 737) | pub fn try_io<R>(
  method async_io (line 772) | pub async fn async_io<R>(
  method from_std (line 825) | pub fn from_std(stream: net::UnixStream) -> io::Result<UnixStream> {
  method into_std (line 873) | pub fn into_std(self) -> io::Result<std::os::unix::net::UnixStream> {
  method pair (line 885) | pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
  method new (line 893) | pub(crate) fn new(stream: mio::net::UnixStream) -> io::Result<UnixStream> {
  method local_addr (line 914) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
  method peer_addr (line 934) | pub fn peer_addr(&self) -> io::Result<SocketAddr> {
  method peer_cred (line 939) | pub fn peer_cred(&self) -> io::Result<UCred> {
  method take_error (line 944) | pub fn take_error(&self) -> io::Result<Option<io::Error>> {
  method shutdown_std (line 953) | pub(super) fn shutdown_std(&self, how: Shutdown) -> io::Result<()> {
  method split (line 967) | pub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>) {
  method into_split (line 982) | pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf) {
  type Error (line 988) | type Error = io::Error;
  method try_from (line 994) | fn try_from(stream: net::UnixStream) -> io::Result<Self> {
  method poll_read (line 1000) | fn poll_read(
  method poll_write (line 1010) | fn poll_write(
  method poll_write_vectored (line 1018) | fn poll_write_vectored(
  method is_write_vectored (line 1026) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 1030) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 1034) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  method poll_read_priv (line 1047) | pub(crate) fn poll_read_priv(
  method poll_write_priv (line 1056) | pub(crate) fn poll_write_priv(
  method poll_write_vectored_priv (line 1064) | pub(super) fn poll_write_vectored_priv(
  method fmt (line 1074) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_ref (line 1080) | fn as_ref(&self) -> &Self {
  method as_raw_fd (line 1086) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 1092) | fn as_fd(&self) -> BorrowedFd<'_> {

FILE: tokio/src/net/unix/ucred.rs
  type UCred (line 5) | pub struct UCred {
    method uid (line 16) | pub fn uid(&self) -> unix::uid_t {
    method gid (line 21) | pub fn gid(&self) -> unix::gid_t {
    method pid (line 29) | pub fn pid(&self) -> Option<unix::pid_t> {
  function get_peer_cred (line 93) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 142) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 184) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 222) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 266) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 298) | pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCre...
  function get_peer_cred (line 325) | pub(crate) fn get_peer_cred(_sock: &UnixStream) -> io::Result<super::UCr...

FILE: tokio/src/net/windows/named_pipe.rs
  type NamedPipe (line 37) | pub type NamedPipe = crate::doc::NotDefinedHere;
  type NamedPipeServer (line 105) | pub struct NamedPipeServer {
    method from_raw_handle (line 128) | pub unsafe fn from_raw_handle(handle: RawHandle) -> io::Result<Self> {
    method info (line 157) | pub fn info(&self) -> io::Result<PipeInfo> {
    method connect (line 192) | pub async fn connect(&self) -> io::Result<()> {
    method disconnect (line 233) | pub fn disconnect(&self) -> io::Result<()> {
    method ready (line 305) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method readable (line 355) | pub async fn readable(&self) -> io::Result<()> {
    method poll_read_ready (line 388) | pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result...
    method try_read (line 457) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
    method try_read_vectored (line 535) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io...
    method writable (line 662) | pub async fn writable(&self) -> io::Result<()> {
    method poll_write_ready (line 695) | pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Resul...
    method try_write (line 749) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
    method try_write_vectored (line 811) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Resul...
    method try_io (line 849) | pub fn try_io<R>(
    method async_io (line 882) | pub async fn async_io<R>(
  method poll_read (line 892) | fn poll_read(
  method poll_write (line 902) | fn poll_write(
  method poll_write_vectored (line 910) | fn poll_write_vectored(
  method poll_flush (line 918) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::R...
  method poll_shutdown (line 922) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method as_raw_handle (line 928) | fn as_raw_handle(&self) -> RawHandle {
  method as_handle (line 934) | fn as_handle(&self) -> BorrowedHandle<'_> {
  type NamedPipeClient (line 978) | pub struct NamedPipeClient {
    method from_raw_handle (line 1001) | pub unsafe fn from_raw_handle(handle: RawHandle) -> io::Result<Self> {
    method info (line 1028) | pub fn info(&self) -> io::Result<PipeInfo> {
    method ready (line 1100) | pub async fn ready(&self, interest: Interest) -> io::Result<Ready> {
    method readable (line 1149) | pub async fn readable(&self) -> io::Result<()> {
    method poll_read_ready (line 1182) | pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result...
    method try_read (line 1250) | pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
    method try_read_vectored (line 1327) | pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io...
    method writable (line 1453) | pub async fn writable(&self) -> io::Result<()> {
    method poll_write_ready (line 1486) | pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Resul...
    method try_write (line 1539) | pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
    method try_write_vectored (line 1600) | pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Resul...
    method try_io (line 1638) | pub fn try_io<R>(
    method async_io (line 1671) | pub async fn async_io<R>(
  method poll_read (line 1681) | fn poll_read(
  method poll_write (line 1691) | fn poll_write(
  method poll_write_vectored (line 1699) | fn poll_write_vectored(
  method poll_flush (line 1707) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::R...
  method poll_shutdown (line 1711) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method as_raw_handle (line 1717) | fn as_raw_handle(&self) -> RawHandle {
  method as_handle (line 1723) | fn as_handle(&self) -> BorrowedHandle<'_> {
  type ServerOptions (line 1734) | pub struct ServerOptions {
    method new (line 1764) | pub fn new() -> ServerOptions {
    method pipe_mode (line 1789) | pub fn pipe_mode(&mut self, pipe_mode: PipeMode) -> &mut Self {
    method access_inbound (line 1885) | pub fn access_inbound(&mut self, allowed: bool) -> &mut Self {
    method access_outbound (line 1983) | pub fn access_outbound(&mut self, allowed: bool) -> &mut Self {
    method first_pipe_instance (line 2051) | pub fn first_pipe_instance(&mut self, first: bool) -> &mut Self {
    method write_dac (line 2133) | pub fn write_dac(&mut self, requested: bool) -> &mut Self {
    method write_owner (line 2143) | pub fn write_owner(&mut self, requested: bool) -> &mut Self {
    method access_system_security (line 2153) | pub fn access_system_security(&mut self, requested: bool) -> &mut Self {
    method reject_remote_clients (line 2164) | pub fn reject_remote_clients(&mut self, reject: bool) -> &mut Self {
    method max_instances (line 2224) | pub fn max_instances(&mut self, instances: usize) -> &mut Self {
    method out_buffer_size (line 2235) | pub fn out_buffer_size(&mut self, buffer: u32) -> &mut Self {
    method in_buffer_size (line 2245) | pub fn in_buffer_size(&mut self, buffer: u32) -> &mut Self {
    method create (line 2275) | pub fn create(&self, addr: impl AsRef<OsStr>) -> io::Result<NamedPipeS...
    method create_with_security_attributes_raw (line 2304) | pub unsafe fn create_with_security_attributes_raw(
  type ClientOptions (line 2373) | pub struct ClientOptions {
    method new (line 2394) | pub fn new() -> Self {
    method read (line 2410) | pub fn read(&mut self, allowed: bool) -> &mut Self {
    method write (line 2421) | pub fn write(&mut self, allowed: bool) -> &mut Self {
    method security_qos_flags (line 2447) | pub fn security_qos_flags(&mut self, flags: u32) -> &mut Self {
    method pipe_mode (line 2457) | pub fn pipe_mode(&mut self, pipe_mode: PipeMode) -> &mut Self {
    method open (line 2512) | pub fn open(&self, addr: impl AsRef<OsStr>) -> io::Result<NamedPipeCli...
    method open_with_security_attributes_raw (line 2533) | pub unsafe fn open_with_security_attributes_raw(
    method get_flags (line 2585) | fn get_flags(&self) -> u32 {
  type PipeMode (line 2595) | pub enum PipeMode {
  type PipeEnd (line 2618) | pub enum PipeEnd {
  type PipeInfo (line 2638) | pub struct PipeInfo {
  function encode_addr (line 2652) | fn encode_addr(addr: impl AsRef<OsStr>) -> Box<[u16]> {
  function named_pipe_info (line 2661) | unsafe fn named_pipe_info(handle: RawHandle) -> io::Result<PipeInfo> {

FILE: tokio/src/process/kill.rs
  type Kill (line 4) | pub(crate) trait Kill {
    method kill (line 6) | fn kill(&mut self) -> io::Result<()>;
    method kill (line 10) | fn kill(&mut self) -> io::Result<()> {

FILE: tokio/src/process/mod.rs
  type Command (line 274) | pub struct Command {
    method new (line 317) | pub fn new<S: AsRef<OsStr>>(program: S) -> Command {
    method as_std (line 323) | pub fn as_std(&self) -> &StdCommand {
    method as_std_mut (line 329) | pub fn as_std_mut(&mut self) -> &mut StdCommand {
    method into_std (line 338) | pub fn into_std(self) -> StdCommand {
    method arg (line 382) | pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Command {
    method args (line 406) | pub fn args<I, S>(&mut self, args: I) -> &mut Command
    method env (line 444) | pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command
    method envs (line 479) | pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command
    method env_remove (line 504) | pub fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Command {
    method env_clear (line 524) | pub fn env_clear(&mut self) -> &mut Command {
    method current_dir (line 554) | pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Command {
    method stdin (line 579) | pub fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
    method stdout (line 606) | pub fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
    method stderr (line 633) | pub fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
    method kill_on_drop (line 664) | pub fn kill_on_drop(&mut self, kill_on_drop: bool) -> &mut Command {
    method uid (line 686) | pub fn uid(&mut self, id: u32) -> &mut Command {
    method gid (line 697) | pub fn gid(&mut self, id: u32) -> &mut Command {
    method arg0 (line 710) | pub fn arg0<S>(&mut self, arg: S) -> &mut Command
    method pre_exec (line 749) | pub unsafe fn pre_exec<F>(&mut self, f: F) -> &mut Command
    method process_group (line 790) | pub fn process_group(&mut self, pgroup: i32) -> &mut Command {
    method spawn (line 863) | pub fn spawn(&mut self) -> io::Result<Child> {
    method spawn_with (line 934) | pub fn spawn_with(
    method build_child (line 950) | fn build_child(&self, child: StdChild) -> io::Result<Child> {
    method status (line 1002) | pub fn status(&mut self) -> impl Future<Output = io::Result<ExitStatus...
    method output (line 1065) | pub fn output(&mut self) -> impl Future<Output = io::Result<Output>> {
    method get_kill_on_drop (line 1090) | pub fn get_kill_on_drop(&self) -> bool {
    method from (line 1096) | fn from(std: StdCommand) -> Command {
  type SpawnedChild (line 279) | pub(crate) struct SpawnedChild {
  type ChildDropGuard (line 1106) | struct ChildDropGuard<T: Kill> {
  method kill (line 1112) | fn kill(&mut self) -> io::Result<()> {
  method drop (line 1124) | fn drop(&mut self) {
  type Output (line 1135) | type Output = Result<T, E>;
  method poll (line 1137) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type FusedChild (line 1160) | enum FusedChild {
  type Child (line 1176) | pub struct Child {
    method id (line 1222) | pub fn id(&self) -> Option<u32> {
    method start_kill (line 1247) | pub fn start_kill(&mut self) -> io::Result<()> {
    method kill (line 1326) | pub async fn kill(&mut self) -> io::Result<()> {
    method wait (line 1379) | pub async fn wait(&mut self) -> io::Result<ExitStatus> {
    method try_wait (line 1413) | pub fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
    method wait_with_output (line 1446) | pub async fn wait_with_output(mut self) -> io::Result<Output> {
  type ChildStdin (line 1482) | pub struct ChildStdin {
    method from_std (line 1512) | pub fn from_std(inner: std::process::ChildStdin) -> io::Result<Self> {
    type Error (line 1600) | type Error = io::Error;
    method try_into (line 1602) | fn try_into(self) -> Result<Stdio, Self::Error> {
  type ChildStdout (line 1491) | pub struct ChildStdout {
    method from_std (line 1527) | pub fn from_std(inner: std::process::ChildStdout) -> io::Result<Self> {
    type Error (line 1608) | type Error = io::Error;
    method try_into (line 1610) | fn try_into(self) -> Result<Stdio, Self::Error> {
  type ChildStderr (line 1500) | pub struct ChildStderr {
    method from_std (line 1542) | pub fn from_std(inner: std::process::ChildStderr) -> io::Result<Self> {
    type Error (line 1616) | type Error = io::Error;
    method try_into (line 1618) | fn try_into(self) -> Result<Stdio, Self::Error> {
  method poll_write (line 1550) | fn poll_write(
  method poll_flush (line 1558) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 1562) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_write_vectored (line 1566) | fn poll_write_vectored(
  method is_write_vectored (line 1574) | fn is_write_vectored(&self) -> bool {
  method poll_read (line 1580) | fn poll_read(
  method poll_read (line 1590) | fn poll_read(
  type Mock (line 1731) | struct Mock {
    method new (line 1738) | fn new() -> Self {
    method with_result (line 1742) | fn with_result(result: Poll<Result<(), ()>>) -> Self {
  method kill (line 1752) | fn kill(&mut self) -> io::Result<()> {
  type Output (line 1759) | type Output = Result<(), ()>;
  method poll (line 1761) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Outpu...
  function kills_on_drop_if_specified (line 1769) | fn kills_on_drop_if_specified() {
  function no_kill_on_drop_by_default (line 1785) | fn no_kill_on_drop_by_default() {
  function no_kill_if_already_killed (line 1801) | fn no_kill_if_already_killed() {
  function no_kill_if_reaped (line 1818) | fn no_kill_if_reaped() {

FILE: tokio/src/process/unix/mod.rs
  method id (line 52) | fn id(&self) -> u32 {
  method try_wait (line 56) | fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  method kill (line 62) | fn kill(&mut self) -> io::Result<()> {
  type GlobalOrphanQueue (line 85) | pub(crate) struct GlobalOrphanQueue;
    method fmt (line 88) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method reap_orphans (line 94) | pub(crate) fn reap_orphans(handle: &SignalHandle) {
    method push_orphan (line 100) | fn push_orphan(&self, orphan: StdChild) {
  type Child (line 106) | pub(crate) enum Child {
    method fmt (line 113) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method id (line 148) | pub(crate) fn id(&self) -> u32 {
    method std_child (line 156) | fn std_child(&mut self) -> &mut StdChild {
    method try_wait (line 164) | pub(crate) fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  function build_child (line 118) | pub(crate) fn build_child(mut child: StdChild) -> io::Result<SpawnedChil...
  method kill (line 170) | fn kill(&mut self) -> io::Result<()> {
  type Output (line 176) | type Output = io::Result<ExitStatus>;
  method poll (line 178) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Pipe (line 188) | pub(crate) struct Pipe {
    method from (line 195) | fn from(fd: T) -> Self {
  function read (line 202) | fn read(&mut self, bytes: &mut [u8]) -> io::Result<usize> {
  function write (line 208) | fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
  function flush (line 212) | fn flush(&mut self) -> io::Result<()> {
  function write_vectored (line 216) | fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usi...
  method as_raw_fd (line 222) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 228) | fn as_fd(&self) -> BorrowedFd<'_> {
  function convert_to_blocking_file (line 233) | fn convert_to_blocking_file(io: ChildStdio) -> io::Result<File> {
  function convert_to_stdio (line 245) | pub(crate) fn convert_to_stdio(io: ChildStdio) -> io::Result<Stdio> {
  method register (line 250) | fn register(
  method reregister (line 259) | fn reregister(
  method deregister (line 268) | fn deregister(&mut self, registry: &mio::Registry) -> io::Result<()> {
  type ChildStdio (line 273) | pub(crate) struct ChildStdio {
    method into_owned_fd (line 278) | pub(super) fn into_owned_fd(self) -> io::Result<OwnedFd> {
    method fmt (line 284) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method as_raw_fd (line 290) | fn as_raw_fd(&self) -> RawFd {
  method as_fd (line 296) | fn as_fd(&self) -> BorrowedFd<'_> {
  method poll_write (line 302) | fn poll_write(
  method poll_flush (line 310) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::R...
  method poll_shutdown (line 314) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io...
  method poll_write_vectored (line 318) | fn poll_write_vectored(
  method is_write_vectored (line 326) | fn is_write_vectored(&self) -> bool {
  method poll_read (line 332) | fn poll_read(
  function set_nonblocking (line 342) | fn set_nonblocking<T: AsRawFd>(fd: &mut T, nonblocking: bool) -> io::Res...
  function stdio (line 365) | pub(super) fn stdio<T>(io: T) -> io::Result<ChildStdio>

FILE: tokio/src/process/unix/orphan.rs
  type Wait (line 9) | pub(crate) trait Wait {
    method id (line 12) | fn id(&self) -> u32;
    method try_wait (line 14) | fn try_wait(&mut self) -> io::Result<Option<ExitStatus>>;
    method id (line 18) | fn id(&self) -> u32 {
    method try_wait (line 22) | fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
    method id (line 187) | fn id(&self) -> u32 {
    method try_wait (line 191) | fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  type OrphanQueue (line 28) | pub(crate) trait OrphanQueue<T> {
    method push_orphan (line 30) | fn push_orphan(&self, orphan: T);
  function push_orphan (line 34) | fn push_orphan(&self, orphan: T) {
  type OrphanQueueImpl (line 41) | pub(crate) struct OrphanQueueImpl<T> {
  function len (line 66) | fn len(&self) -> usize {
  function push_orphan (line 70) | pub(crate) fn push_orphan(&self, orphan: T)
  function reap_orphans (line 79) | pub(crate) fn reap_orphans(&self, handle: &SignalHandle)
  function drain_orphan_queue (line 113) | fn drain_orphan_queue<T>(mut queue: MutexGuard<'_, Vec<T>>)
  type MockQueue (line 144) | pub(crate) struct MockQueue<W> {
  function new (line 149) | pub(crate) fn new() -> Self {
  function push_orphan (line 157) | fn push_orphan(&self, orphan: W) {
  type MockWait (line 162) | struct MockWait {
    method new (line 169) | fn new(num_wait_until_status: usize) -> Self {
    method with_err (line 177) | fn with_err() -> Self {
  function drain_attempts_a_single_reap_of_all_queued_orphans (line 210) | fn drain_attempts_a_single_reap_of_all_queued_orphans() {
  function no_reap_if_no_signal_received (line 255) | fn no_reap_if_no_signal_received() {
  function no_reap_if_signal_lock_held (line 279) | fn no_reap_if_signal_lock_held() {
  function does_not_register_signal_if_queue_empty (line 297) | fn does_not_register_signal_if_queue_empty() {
  function does_nothing_if_signal_could_not_be_registered (line 319) | fn does_nothing_if_signal_could_not_be_registered() {

FILE: tokio/src/process/unix/pidfd_reaper.rs
  type Pidfd (line 25) | struct Pidfd {
    method open (line 30) | fn open(pid: u32) -> Option<Pidfd> {
  method as_raw_fd (line 59) | fn as_raw_fd(&self) -> RawFd {
  method register (line 65) | fn register(
  method reregister (line 74) | fn reregister(
  method deregister (line 83) | fn deregister(&mut self, registry: &mio::Registry) -> io::Result<()> {
  type PidfdReaperInner (line 89) | struct PidfdReaperInner<W>
  type Output (line 101) | type Output = io::Result<ExitStatus>;
  method poll (line 103) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type PidfdReaper (line 125) | pub(crate) struct PidfdReaper<W, Q>
  type Target (line 139) | type Target = W;
  method deref (line 141) | fn deref(&self) -> &Self::Target {
  function new (line 151) | pub(crate) fn new(inner: W, orphan_queue: Q) -> Result<Self, (Option<io:...
  function inner_mut (line 165) | pub(crate) fn inner_mut(&mut self) -> &mut W {
  type Output (line 175) | type Output = io::Result<ExitStatus>;
  method poll (line 177) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method kill (line 193) | fn kill(&mut self) -> io::Result<()> {
  method drop (line 203) | fn drop(&mut self) {
  function create_runtime (line 222) | fn create_runtime() -> Runtime {
  function run_test (line 229) | fn run_test(fut: impl Future<Output = ()>) {
  function is_pidfd_available (line 233) | fn is_pidfd_available() -> bool {
  function test_pidfd_reaper_poll (line 251) | fn test_pidfd_reaper_poll() {
  function test_pidfd_reaper_kill (line 271) | fn test_pidfd_reaper_kill() {
  function test_pidfd_reaper_drop (line 293) | fn test_pidfd_reaper_drop() {

FILE: tokio/src/process/unix/reap.rs
  type Reaper (line 16) | pub(crate) struct Reaper<W, Q, S>
  type Target (line 31) | type Target = W;
  method deref (line 33) | fn deref(&self) -> &Self::Target {
  function new (line 43) | pub(crate) fn new(inner: W, orphan_queue: Q, signal: S) -> Self {
  function inner (line 51) | fn inner(&self) -> &W {
  function inner_mut (line 55) | pub(crate) fn inner_mut(&mut self) -> &mut W {
  type Output (line 66) | type Output = io::Result<ExitStatus>;
  method poll (line 68) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method kill (line 112) | fn kill(&mut self) -> io::Result<()> {
  method drop (line 122) | fn drop(&mut self) {
  type MockWait (line 144) | struct MockWait {
    method new (line 152) | fn new(status: ExitStatus, num_wait_until_status: usize) -> Self {
  method id (line 163) | fn id(&self) -> u32 {
  method try_wait (line 167) | fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  method kill (line 180) | fn kill(&mut self) -> io::Result<()> {
  type MockStream (line 186) | struct MockStream {
    method new (line 192) | fn new(values: Vec<Option<()>>) -> Self {
  method poll_recv (line 201) | fn poll_recv(&mut self, _cx: &mut Context<'_>) -> Poll<Option<()>> {
  function reaper (line 211) | fn reaper() {
  function kill (line 250) | fn kill() {
  function drop_reaps_if_possible (line 264) | fn drop_reaps_if_possible() {
  function drop_enqueues_orphan_if_wait_fails (line 283) | fn drop_enqueues_orphan_if_wait_fails() {

FILE: tokio/src/process/windows.rs
  type Child (line 44) | pub(crate) struct Child {
    method fmt (line 50) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method id (line 85) | pub(crate) fn id(&self) -> u32 {
    method try_wait (line 89) | pub(crate) fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  type Waiting (line 59) | struct Waiting {
  function build_child (line 68) | pub(crate) fn build_child(mut child: StdChild) -> io::Result<SpawnedChil...
  method kill (line 95) | fn kill(&mut self) -> io::Result<()> {
  type Output (line 101) | type Output = io::Result<ExitStatus>;
  method poll (line 103) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method as_raw_handle (line 147) | fn as_raw_handle(&self) -> RawHandle {
  method drop (line 153) | fn drop(&mut self) {
  function callback (line 164) | unsafe extern "system" fn callback(ptr: *mut std::ffi::c_void, _timer_fi...
  type ArcFile (line 170) | struct ArcFile(Arc<StdFile>);
    method read (line 173) | fn read(&mut self, bytes: &mut [u8]) -> io::Result<usize> {
    method write (line 179) | fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
    method flush (line 183) | fn flush(&mut self) -> io::Result<()> {
  type ChildStdio (line 189) | pub(crate) struct ChildStdio {
    method into_owned_handle (line 197) | pub(super) fn into_owned_handle(self) -> io::Result<OwnedHandle> {
  method as_raw_handle (line 203) | fn as_raw_handle(&self) -> RawHandle {
  method poll_read (line 209) | fn poll_read(
  method poll_write (line 219) | fn poll_write(
  method poll_flush (line 227) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 231) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  function stdio (line 236) | pub(super) fn stdio<T>(io: T) -> io::Result<ChildStdio>
  function convert_to_file (line 251) | fn convert_to_file(child_stdio: ChildStdio) -> io::Result<StdFile> {
  function convert_to_stdio (line 258) | pub(crate) fn convert_to_stdio(child_stdio: ChildStdio) -> io::Result<St...
  function duplicate_handle (line 262) | fn duplicate_handle<T: AsRawHandle>(io: &T) -> io::Result<StdFile> {

FILE: tokio/src/runtime/blocking/mod.rs
  function create_blocking_pool (line 24) | pub(crate) fn create_blocking_pool(builder: &Builder, thread_cap: usize)...

FILE: tokio/src/runtime/blocking/pool.rs
  type BlockingPool (line 19) | pub(crate) struct BlockingPool {
    method new (line 210) | pub(crate) fn new(builder: &Builder, thread_cap: usize) -> BlockingPool {
    method spawner (line 240) | pub(crate) fn spawner(&self) -> &Spawner {
    method shutdown (line 244) | pub(crate) fn shutdown(&mut self, timeout: Option<Duration>) {
    method fmt (line 289) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Spawner (line 25) | pub(crate) struct Spawner {
    method spawn_blocking (line 298) | pub(crate) fn spawn_blocking<F, R>(&self, rt: &Handle, func: F) -> Joi...
    method spawn_blocking_inner (line 367) | pub(crate) fn spawn_blocking_inner<F, R>(
    method spawn_task (line 393) | fn spawn_task(&self, task: Task, rt: &Handle) -> Result<(), SpawnError> {
    method spawn_thread (line 457) | fn spawn_thread(
    method fmt (line 607) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SpawnerMetrics (line 30) | pub(crate) struct SpawnerMetrics {
    method num_threads (line 37) | fn num_threads(&self) -> usize {
    method num_idle_threads (line 41) | fn num_idle_threads(&self) -> usize {
    method inc_num_threads (line 51) | fn inc_num_threads(&self) {
    method dec_num_threads (line 55) | fn dec_num_threads(&self) {
    method inc_num_idle_threads (line 59) | fn inc_num_idle_threads(&self) {
    method dec_num_idle_threads (line 63) | fn dec_num_idle_threads(&self) -> usize {
    method inc_queue_depth (line 67) | fn inc_queue_depth(&self) {
    method dec_queue_depth (line 71) | fn dec_queue_depth(&self) {
  type Inner (line 76) | struct Inner {
    method run (line 503) | fn run(&self, worker_thread_id: usize) {
  type Shared (line 105) | struct Shared {
  type Task (line 124) | pub(crate) struct Task {
    method new (line 156) | pub(crate) fn new(task: task::UnownedTask<BlockingSchedule>, mandatory...
    method run (line 160) | fn run(self) {
    method shutdown_or_run_if_mandatory (line 164) | fn shutdown_or_run_if_mandatory(self) {
  type Mandatory (line 130) | pub(crate) enum Mandatory {
  type SpawnError (line 136) | pub(crate) enum SpawnError {
  function from (line 145) | fn from(e: SpawnError) -> Self {
  constant KEEP_ALIVE (line 172) | const KEEP_ALIVE: Duration = Duration::from_secs(10);
  function spawn_blocking (line 179) | pub(crate) fn spawn_blocking<F, R>(func: F) -> JoinHandle<R>
  method drop (line 283) | fn drop(&mut self) {
  function is_temporary_os_thread_error (line 498) | fn is_temporary_os_thread_error(error: &io::Error) -> bool {

FILE: tokio/src/runtime/blocking/schedule.rs
  type BlockingSchedule (line 12) | pub(crate) struct BlockingSchedule {
    method new (line 20) | pub(crate) fn new(handle: &Handle) -> Self {
    method release (line 42) | fn release(&self, _task: &Task<Self>) -> Option<Task<Self>> {
    method schedule (line 57) | fn schedule(&self, _task: task::Notified<Self>) {
    method hooks (line 61) | fn hooks(&self) -> TaskHarnessScheduleHooks {

FILE: tokio/src/runtime/blocking/shutdown.rs
  type Sender (line 12) | pub(super) struct Sender {
  type Receiver (line 17) | pub(super) struct Receiver {
    method wait (line 37) | pub(crate) fn wait(&mut self, timeout: Option<Duration>) -> bool {
  function channel (line 21) | pub(super) fn channel() -> (Sender, Receiver) {

FILE: tokio/src/runtime/blocking/task.rs
  type BlockingTask (line 6) | pub(crate) struct BlockingTask<T> {
  function new (line 12) | pub(crate) fn new(func: T) -> BlockingTask<T> {
  type Output (line 25) | type Output = R;
  method poll (line 27) | fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<R> {

FILE: tokio/src/runtime/builder.rs
  type Builder (line 53) | pub struct Builder {
    method new_current_thread (line 246) | pub fn new_current_thread() -> Builder {
    method new_multi_thread (line 261) | pub fn new_multi_thread() -> Builder {
    method new (line 270) | pub(crate) fn new(kind: Kind, event_interval: u32) -> Builder {
    method enable_all (line 351) | pub fn enable_all(&mut self) -> &mut Self {
    method enable_alt_timer (line 403) | pub fn enable_alt_timer(&mut self) -> &mut Self {
    method worker_threads (line 460) | pub fn worker_threads(&mut self, val: usize) -> &mut Self {
    method max_blocking_threads (line 511) | pub fn max_blocking_threads(&mut self, val: usize) -> &mut Self {
    method thread_name (line 535) | pub fn thread_name(&mut self, val: impl Into<String>) -> &mut Self {
    method thread_name_fn (line 563) | pub fn thread_name_fn<F>(&mut self, f: F) -> &mut Self
    method thread_stack_size (line 593) | pub fn thread_stack_size(&mut self, val: usize) -> &mut Self {
    method on_thread_start (line 619) | pub fn on_thread_start<F>(&mut self, f: F) -> &mut Self
    method on_thread_stop (line 647) | pub fn on_thread_stop<F>(&mut self, f: F) -> &mut Self
    method on_thread_park (line 728) | pub fn on_thread_park<F>(&mut self, f: F) -> &mut Self
    method on_thread_unpark (line 766) | pub fn on_thread_unpark<F>(&mut self, f: F) -> &mut Self
    method on_task_spawn (line 816) | pub fn on_task_spawn<F>(&mut self, f: F) -> &mut Self
    method on_before_task_poll (line 863) | pub fn on_before_task_poll<F>(&mut self, f: F) -> &mut Self
    method on_after_task_poll (line 910) | pub fn on_after_task_poll<F>(&mut self, f: F) -> &mut Self
    method on_task_terminate (line 959) | pub fn on_task_terminate<F>(&mut self, f: F) -> &mut Self
    method build (line 985) | pub fn build(&mut self) -> io::Result<Runtime> {
    method build_local (line 1019) | pub fn build_local(&mut self, options: LocalOptions) -> io::Result<Loc...
    method get_cfg (line 1027) | fn get_cfg(&self) -> driver::Cfg {
    method thread_keep_alive (line 1061) | pub fn thread_keep_alive(&mut self, duration: Duration) -> &mut Self {
    method global_queue_interval (line 1103) | pub fn global_queue_interval(&mut self, val: u32) -> &mut Self {
    method event_interval (line 1144) | pub fn event_interval(&mut self, val: u32) -> &mut Self {
    method build_current_thread_runtime (line 1561) | fn build_current_thread_runtime(&mut self) -> io::Result<Runtime> {
    method build_current_thread_local_runtime (line 1575) | fn build_current_thread_local_runtime(&mut self) -> io::Result<LocalRu...
    method build_current_thread_runtime_components (line 1590) | fn build_current_thread_runtime_components(
    method metrics_poll_count_histogram_builder (line 1645) | fn metrics_poll_count_histogram_builder(&self) -> Option<HistogramBuil...
    method fmt (line 1831) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ThreadNameFn (line 226) | pub(crate) type ThreadNameFn = std::sync::Arc<dyn Fn() -> String + Send ...
  type Kind (line 229) | pub(crate) enum Kind {

FILE: tokio/src/runtime/config.rs
  type Config (line 8) | pub(crate) struct Config {

FILE: tokio/src/runtime/context.rs
  type Context (line 36) | struct Context {
  function thread_rng_n (line 125) | pub(crate) fn thread_rng_n(n: u32) -> u32 {
  function budget (line 134) | pub(crate) fn budget<R>(f: impl FnOnce(&Cell<coop::Budget>) -> R) -> Res...

FILE: tokio/src/runtime/context/blocking.rs
  type BlockingRegionGuard (line 11) | pub(crate) struct BlockingRegionGuard {
    method new (line 53) | pub(super) fn new() -> BlockingRegionGuard {
    method block_on (line 59) | pub(crate) fn block_on<F>(&mut self, f: F) -> Result<F::Output, Access...
    method block_on_timeout (line 73) | pub(crate) fn block_on_timeout<F>(&mut self, f: F, timeout: Duration) ...
  type DisallowBlockInPlaceGuard (line 15) | pub(crate) struct DisallowBlockInPlaceGuard(bool);
  function try_enter_blocking_region (line 17) | pub(crate) fn try_enter_blocking_region() -> Option<BlockingRegionGuard> {
  function disallow_block_in_place (line 34) | pub(crate) fn disallow_block_in_place() -> DisallowBlockInPlaceGuard {
  method drop (line 106) | fn drop(&mut self) {

FILE: tokio/src/runtime/context/current.rs
  type SetCurrentGuard (line 11) | pub(crate) struct SetCurrentGuard {
  type HandleCell (line 22) | pub(super) struct HandleCell {
    method new (line 67) | pub(super) const fn new() -> HandleCell {
  function try_set_current (line 33) | pub(crate) fn try_set_current(handle: &scheduler::Handle) -> Option<SetC...
  function with_current (line 37) | pub(crate) fn with_current<F, R>(f: F) -> Result<R, TryCurrentError>
  method set_current (line 49) | pub(super) fn set_current(&self, handle: &scheduler::Handle) -> SetCurre...
  method drop (line 76) | fn drop(&mut self) {

FILE: tokio/src/runtime/context/runtime.rs
  type EnterRuntime (line 10) | pub(crate) enum EnterRuntime {
    method is_entered (line 96) | pub(crate) fn is_entered(self) -> bool {
  type EnterRuntimeGuard (line 21) | pub(crate) struct EnterRuntimeGuard {
    method fmt (line 77) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function enter_runtime (line 35) | pub(crate) fn enter_runtime<F, R>(handle: &scheduler::Handle, allow_bloc...
  method drop (line 83) | fn drop(&mut self) {

FILE: tokio/src/runtime/context/runtime_mt.rs
  function current_enter_context (line 4) | pub(crate) fn current_enter_context() -> EnterRuntime {
  function exit_runtime (line 10) | pub(crate) fn exit_runtime<F: FnOnce() -> R, R>(f: F) -> R {

FILE: tokio/src/runtime/context/scoped.rs
  type Scoped (line 5) | pub(super) struct Scoped<T> {
  function new (line 10) | pub(super) const fn new() -> Scoped<T> {
  function set (line 17) | pub(super) fn set<F, R>(&self, t: &T, f: F) -> R
  function with (line 44) | pub(super) fn with<F, R>(&self, f: F) -> R

FILE: tokio/src/runtime/driver.rs
  type Driver (line 16) | pub(crate) struct Driver {
    method new (line 47) | pub(crate) fn new(cfg: Cfg) -> io::Result<(Self, Handle)> {
    method park (line 66) | pub(crate) fn park(&mut self, handle: &Handle) {
    method park_timeout (line 70) | pub(crate) fn park_timeout(&mut self, handle: &Handle, duration: Durat...
    method shutdown (line 74) | pub(crate) fn shutdown(&mut self, handle: &Handle) {
  type Handle (line 21) | pub(crate) struct Handle {
    method unpark (line 80) | pub(crate) fn unpark(&self) {
  type Cfg (line 37) | pub(crate) struct Cfg {

FILE: tokio/src/runtime/driver/op.rs
  type CancelData (line 18) | pub(crate) enum CancelData {
  type Lifecycle (line 25) | pub(crate) enum Lifecycle {
  type State (line 44) | pub(crate) enum State {
  type Op (line 50) | pub(crate) struct Op<T: Cancellable> {
  function new (line 64) | pub(crate) unsafe fn new(entry: Entry, data: T) -> Self {
  function take_data (line 72) | pub(crate) fn take_data(&mut self) -> Option<T> {
  method drop (line 78) | fn drop(&mut self) {
  type CqeResult (line 96) | pub(crate) struct CqeResult {
    method from (line 101) | fn from(cqe: cqueue::Entry) -> Self {
  type Completable (line 113) | pub(crate) trait Completable {
    method complete (line 115) | fn complete(self, cqe: CqeResult) -> Self::Output;
    method complete_with_error (line 121) | fn complete_with_error(self, error: Error) -> Self::Output;
  type Cancellable (line 125) | pub(crate) trait Cancellable {
    method cancel (line 126) | fn cancel(self) -> CancelData;
  type Output (line 132) | type Output = T::Output;
  method poll (line 134) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/runtime/dump.rs
  type Dump (line 14) | pub struct Dump {
    method new (line 288) | pub(crate) fn new(tasks: Vec<Task>) -> Self {
    method tasks (line 295) | pub fn tasks(&self) -> &Tasks {
  type Tasks (line 22) | pub struct Tasks {
    method iter (line 302) | pub fn iter(&self) -> impl Iterator<Item = &Task> {
  type Task (line 30) | pub struct Task {
    method new (line 308) | pub(crate) fn new(id: Id, trace: super::task::trace::Trace) -> Self {
    method id (line 326) | pub fn id(&self) -> Id {
    method trace (line 331) | pub fn trace(&self) -> &Trace {
  type Address (line 40) | struct Address(*mut std::ffi::c_void);
  type BacktraceSymbol (line 50) | pub struct BacktraceSymbol {
    method from_backtrace_symbol (line 60) | pub(crate) fn from_backtrace_symbol(sym: &backtrace::BacktraceSymbol) ...
    method name_raw (line 73) | pub fn name_raw(&self) -> Option<&[u8]> {
    method name_demangled (line 78) | pub fn name_demangled(&self) -> Option<&str> {
    method addr (line 83) | pub fn addr(&self) -> Option<*mut std::ffi::c_void> {
    method filename (line 89) | pub fn filename(&self) -> Option<&Path> {
    method lineno (line 96) | pub fn lineno(&self) -> Option<u32> {
    method colno (line 103) | pub fn colno(&self) -> Option<u32> {
  type BacktraceFrame (line 112) | pub struct BacktraceFrame {
    method from_resolved_backtrace_frame (line 119) | pub(crate) fn from_resolved_backtrace_frame(frame: &backtrace::Backtra...
    method ip (line 134) | pub fn ip(&self) -> *mut std::ffi::c_void {
    method symbol_address (line 139) | pub fn symbol_address(&self) -> *mut std::ffi::c_void {
    method symbols (line 148) | pub fn symbols(&self) -> impl Iterator<Item = &BacktraceSymbol> {
  type Backtrace (line 157) | pub struct Backtrace {
    method frames (line 164) | pub fn frames(&self) -> impl Iterator<Item = &BacktraceFrame> {
  type Trace (line 188) | pub struct Trace {
    method resolve_backtraces (line 202) | pub fn resolve_backtraces(&self) -> Vec<Backtrace> {
    method capture (line 266) | pub fn capture<F, R>(f: F) -> (R, Trace)
    method root (line 279) | pub fn root<F>(f: F) -> Root<F>
    method fmt (line 337) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/handle.rs
  type Handle (line 13) | pub struct Handle {
    method enter (line 86) | pub fn enter(&self) -> EnterGuard<'_> {
    method current (line 144) | pub fn current() -> Self {
    method try_current (line 155) | pub fn try_current() -> Result<Self, TryCurrentError> {
    method spawn (line 197) | pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    method spawn_blocking (line 234) | pub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R>
    method block_on (line 342) | pub fn block_on<F: Future>(&self, future: F) -> F::Output {
    method block_on_inner (line 352) | fn block_on_inner<F: Future>(&self, future: F, _meta: SpawnMeta<'_>) -...
    method spawn_named (line 374) | pub(crate) fn spawn_named<F>(&self, future: F, meta: SpawnMeta<'_>) ->...
    method spawn_local_named (line 399) | pub(crate) unsafe fn spawn_local_named<F>(
    method runtime_flavor (line 446) | pub fn runtime_flavor(&self) -> RuntimeFlavor {
    method id (line 468) | pub fn id(&self) -> runtime::Id {
    method metrics (line 479) | pub fn metrics(&self) -> RuntimeMetrics {
  type EnterGuard (line 34) | pub struct EnterGuard<'a> {
  type TryCurrentError (line 656) | pub struct TryCurrentError {
    method new_no_context (line 661) | pub(crate) fn new_no_context() -> Self {
    method new_thread_local_destroyed (line 667) | pub(crate) fn new_thread_local_destroyed() -> Self {
    method is_missing_context (line 675) | pub fn is_missing_context(&self) -> bool {
    method is_thread_local_destroyed (line 682) | pub fn is_thread_local_destroyed(&self) -> bool {
    method fmt (line 702) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TryCurrentErrorKind (line 687) | enum TryCurrentErrorKind {
    method fmt (line 693) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/id.rs
  type Id (line 30) | pub struct Id(NonZeroU64);
    method new (line 33) | pub(crate) fn new(integer: impl Into<NonZeroU64>) -> Self {
    method fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/io/driver.rs
  type Driver (line 25) | pub(crate) struct Driver {
    method new (line 117) | pub(crate) fn new(nevents: usize) -> io::Result<(Driver, Handle)> {
    method park (line 159) | pub(crate) fn park(&mut self, rt_handle: &driver::Handle) {
    method park_timeout (line 164) | pub(crate) fn park_timeout(&mut self, rt_handle: &driver::Handle, dura...
    method shutdown (line 169) | pub(crate) fn shutdown(&mut self, rt_handle: &driver::Handle) {
    method turn (line 179) | fn turn(&mut self, handle: &Handle, max_wait: Option<Duration>) {
    method fmt (line 243) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Handle (line 37) | pub(crate) struct Handle {
    method unpark (line 258) | pub(crate) fn unpark(&self) {
    method add_source (line 266) | pub(super) fn add_source(
    method deregister_source (line 293) | pub(super) fn deregister_source(
    method release_pending_registrations (line 314) | fn release_pending_registrations(&self) {
    method fmt (line 322) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ReadyEvent (line 74) | pub(crate) struct ReadyEvent {
  type Direction (line 93) | pub(super) enum Direction {
    method mask (line 328) | pub(super) fn mask(self) -> Ready {
  type Tick (line 98) | pub(super) enum Tick {
  constant TOKEN_WAKEUP (line 103) | const TOKEN_WAKEUP: mio::Token = mio::Token(0);
  constant TOKEN_SIGNAL (line 104) | const TOKEN_SIGNAL: mio::Token = mio::Token(1);
  function _assert_kinds (line 106) | fn _assert_kinds() {

FILE: tokio/src/runtime/io/driver/signal.rs
  method register_signal_receiver (line 6) | pub(crate) fn register_signal_receiver(
  method consume_signal_ready (line 17) | pub(crate) fn consume_signal_ready(&mut self) -> bool {

FILE: tokio/src/runtime/io/driver/uring.rs
  constant DEFAULT_RING_SIZE (line 13) | const DEFAULT_RING_SIZE: u32 = 256;
  type UringContext (line 15) | pub(crate) struct UringContext {
    method new (line 21) | pub(crate) fn new() -> Self {
    method ring (line 28) | pub(crate) fn ring(&self) -> &io_uring::IoUring {
    method ring_mut (line 32) | pub(crate) fn ring_mut(&mut self) -> &mut io_uring::IoUring {
    method try_init (line 41) | pub(crate) fn try_init(&mut self, probe: &mut Probe) -> io::Result<boo...
    method dispatch_completions (line 63) | pub(crate) fn dispatch_completions(&mut self) {
    method submit (line 99) | pub(crate) fn submit(&mut self) -> io::Result<()> {
    method remove_op (line 119) | pub(crate) fn remove_op(&mut self, index: usize) -> Lifecycle {
  method drop (line 126) | fn drop(&mut self) {
  method add_uring_source (line 157) | fn add_uring_source(&self, uringfd: RawFd) -> io::Result<()> {
  method get_uring (line 163) | pub(crate) fn get_uring(&self) -> &Mutex<UringContext> {
  method check_and_init (line 179) | pub(crate) async fn check_and_init(&self, opcode: u8) -> io::Result<bool> {
  method try_init (line 204) | fn try_init(&self, probe: &mut Probe) -> io::Result<()> {
  method register_op (line 223) | pub(crate) unsafe fn register_op(&self, entry: Entry, waker: Waker) -> i...
  method cancel_op (line 259) | pub(crate) fn cancel_op<T: Cancellable>(&self, index: usize, data: Optio...

FILE: tokio/src/runtime/io/registration.rs
  method new_with_interest_and_handle (line 73) | pub(crate) fn new_with_interest_and_handle(
  method deregister (line 99) | pub(crate) fn deregister(&mut self, io: &mut impl Source) -> io::Result<...
  method clear_readiness (line 103) | pub(crate) fn clear_readiness(&self, event: ReadyEvent) {
  method poll_read_ready (line 109) | pub(crate) fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::R...
  method poll_write_ready (line 115) | pub(crate) fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::...
  method poll_read_io (line 122) | pub(crate) fn poll_read_io<R>(
  method poll_write_io (line 132) | pub(crate) fn poll_write_io<R>(
  method poll_ready (line 144) | fn poll_ready(
  method poll_io (line 162) | fn poll_io<R>(
  method try_io (line 183) | pub(crate) fn try_io<R>(
  method readiness (line 204) | pub(crate) async fn readiness(&self, interest: Interest) -> io::Result<R...
  method async_io (line 214) | pub(crate) async fn async_io<R>(
  method handle (line 236) | fn handle(&self) -> &Handle {
  method drop (line 242) | fn drop(&mut self) {
  function gone (line 254) | fn gone() -> io::Error {

FILE: tokio/src/runtime/io/registration_set.rs
  constant NOTIFY_AFTER (line 11) | const NOTIFY_AFTER: usize = 16;
  type RegistrationSet (line 13) | pub(super) struct RegistrationSet {
    method new (line 33) | pub(super) fn new() -> (RegistrationSet, Synced) {
    method is_shutdown (line 47) | pub(super) fn is_shutdown(&self, synced: &Synced) -> bool {
    method needs_release (line 52) | pub(super) fn needs_release(&self) -> bool {
    method allocate (line 56) | pub(super) fn allocate(&self, synced: &mut Synced) -> io::Result<Arc<S...
    method deregister (line 74) | pub(super) fn deregister(&self, synced: &mut Synced, registration: &Ar...
    method shutdown (line 83) | pub(super) fn shutdown(&self, synced: &mut Synced) -> Vec<Arc<Schedule...
    method release (line 104) | pub(super) fn release(&self, synced: &mut Synced) {
    method remove (line 117) | pub(super) unsafe fn remove(&self, synced: &mut Synced, io: &Arc<Sched...
  type Synced (line 17) | pub(super) struct Synced {
  type Handle (line 129) | type Handle = Arc<ScheduledIo>;
  type Target (line 130) | type Target = ScheduledIo;
  function as_raw (line 132) | fn as_raw(handle: &Self::Handle) -> NonNull<ScheduledIo> {
  function from_raw (line 137) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Arc<ScheduledIo> {
  function pointers (line 142) | unsafe fn pointers(

FILE: tokio/src/runtime/io/scheduled_io.rs
  type ScheduledIo (line 101) | pub(crate) struct ScheduledIo {
    method token (line 189) | pub(crate) fn token(&self) -> mio::Token {
    method shutdown (line 195) | pub(super) fn shutdown(&self) {
    method set_readiness (line 209) | pub(super) fn set_readiness(&self, tick_op: Tick, f: impl Fn(Ready) ->...
    method wake (line 238) | pub(super) fn wake(&self, ready: Ready) {
    method ready_event (line 290) | pub(super) fn ready_event(&self, interest: Interest) -> ReadyEvent {
    method poll_readiness (line 305) | pub(super) fn poll_readiness(
    method clear_readiness (line 359) | pub(crate) fn clear_readiness(&self, event: ReadyEvent) {
    method clear_wakers (line 366) | pub(crate) fn clear_wakers(&self) {
    method readiness (line 384) | pub(crate) async fn readiness(&self, interest: Interest) -> ReadyEvent {
    method readiness_fut (line 392) | fn readiness_fut(&self, interest: Interest) -> Readiness<'_> {
  type WaitList (line 110) | type WaitList = LinkedList<Waiter, <Waiter as linked_list::Link>::Target>;
  type Waiters (line 113) | struct Waiters {
  type Waiter (line 125) | struct Waiter {
    type Handle (line 408) | type Handle = NonNull<Waiter>;
    type Target (line 409) | type Target = Waiter;
    method as_raw (line 411) | fn as_raw(handle: &NonNull<Waiter>) -> NonNull<Waiter> {
    method from_raw (line 415) | unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter> {
    method pointers (line 419) | unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<linked_list::Po...
  type Readiness (line 149) | struct Readiness<'a> {
  type State (line 158) | enum State {
  constant READINESS (line 170) | const READINESS: bit::Pack = bit::Pack::least_significant(16);
  constant TICK (line 172) | const TICK: bit::Pack = READINESS.then(15);
  constant SHUTDOWN (line 174) | const SHUTDOWN: bit::Pack = TICK.then(1);
  method default (line 179) | fn default() -> ScheduledIo {
  method drop (line 374) | fn drop(&mut self) {
  type Output (line 427) | type Output = ReadyEvent;
  method poll (line 429) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method drop (line 569) | fn drop(&mut self) {

FILE: tokio/src/runtime/local_runtime/options.rs
  type LocalOptions (line 15) | pub struct LocalOptions {

FILE: tokio/src/runtime/local_runtime/runtime.rs
  type LocalRuntime (line 33) | pub struct LocalRuntime {
    method from_parts (line 55) | pub(crate) fn from_parts(
    method new (line 92) | pub fn new() -> std::io::Result<LocalRuntime> {
    method handle (line 120) | pub fn handle(&self) -> &Handle {
    method spawn_local (line 147) | pub fn spawn_local<F>(&self, future: F) -> JoinHandle<F::Output>
    method spawn_blocking (line 190) | pub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R>
    method block_on (line 220) | pub fn block_on<F: Future>(&self, future: F) -> F::Output {
    method block_on_inner (line 232) | fn block_on_inner<F: Future>(&self, future: F, _meta: SpawnMeta<'_>) -...
    method enter (line 301) | pub fn enter(&self) -> EnterGuard<'_> {
    method shutdown_timeout (line 337) | pub fn shutdown_timeout(mut self, duration: Duration) {
    method shutdown_background (line 371) | pub fn shutdown_background(self) {
    method metrics (line 377) | pub fn metrics(&self) -> crate::runtime::RuntimeMetrics {
  type LocalRuntimeScheduler (line 49) | pub(crate) enum LocalRuntimeScheduler {
  method drop (line 383) | fn drop(&mut self) {

FILE: tokio/src/runtime/metrics/batch.rs
  type MetricsBatch (line 10) | pub(crate) struct MetricsBatch {
    method new (line 69) | pub(crate) fn new(worker_metrics: &WorkerMetrics) -> MetricsBatch {
    method submit (line 116) | pub(crate) fn submit(&mut self, worker: &WorkerMetrics, mean_poll_time...
    method unparked (line 187) | pub(crate) fn unparked(&mut self) {
    method start_processing_scheduled_tasks (line 192) | pub(crate) fn start_processing_scheduled_tasks(&mut self) {
    method end_processing_scheduled_tasks (line 197) | pub(crate) fn end_processing_scheduled_tasks(&mut self) {
  function duration_as_u64 (line 287) | pub(crate) fn duration_as_u64(dur: Duration) -> u64 {
  function now (line 293) | fn now() -> Option<Instant> {

FILE: tokio/src/runtime/metrics/histogram.rs
  type Histogram (line 14) | pub(crate) struct Histogram {
    method num_buckets (line 191) | pub(crate) fn num_buckets(&self) -> usize {
    method bucket_range (line 201) | pub(crate) fn bucket_range(&self, bucket: usize) -> Range<u64> {
  type HistogramBuilder (line 25) | pub(crate) struct HistogramBuilder {
    method new (line 235) | pub(crate) fn new() -> HistogramBuilder {
    method legacy_mut (line 245) | pub(crate) fn legacy_mut(&mut self, f: impl Fn(&mut LegacyBuilder)) {
    method build (line 250) | pub(crate) fn build(&self) -> Histogram {
  type LegacyBuilder (line 31) | pub(crate) struct LegacyBuilder {
  method default (line 38) | fn default() -> Self {
  type HistogramBatch (line 48) | pub(crate) struct HistogramBatch {
    method from_histogram (line 207) | pub(crate) fn from_histogram(histogram: &Histogram) -> HistogramBatch {
    method measure (line 216) | pub(crate) fn measure(&mut self, value: u64, count: u64) {
    method submit (line 220) | pub(crate) fn submit(&self, histogram: &Histogram) {
    method value_to_bucket (line 229) | fn value_to_bucket(&self, value: u64) -> usize {
  type HistogramType (line 100) | pub(crate) enum HistogramType {
    method num_buckets (line 112) | pub(crate) fn num_buckets(&self) -> usize {
    method value_to_bucket (line 119) | fn value_to_bucket(&self, value: u64) -> usize {
    method bucket_range (line 145) | fn bucket_range(&self, bucket: usize) -> Range<u64> {
  type LinearHistogram (line 179) | pub(crate) struct LinearHistogram {
  type LegacyLogHistogram (line 185) | pub(crate) struct LegacyLogHistogram {
  method default (line 280) | fn default() -> HistogramBuilder {
  function linear (line 295) | fn linear(resolution: u64, num_buckets: usize) -> Histogram {
  function test_legacy_builder (line 307) | fn test_legacy_builder() {
  function log_scale_resolution_1 (line 314) | fn log_scale_resolution_1() {
  function log_scale_resolution_2 (line 371) | fn log_scale_resolution_2() {
  function linear_scale_resolution_1 (line 460) | fn linear_scale_resolution_1() {
  function linear_scale_resolution_100 (line 516) | fn linear_scale_resolution_100() {
  function inc_by_more_than_one (line 590) | fn inc_by_more_than_one() {

FILE: tokio/src/runtime/metrics/histogram/h2_histogram.rs
  constant DEFAULT_MIN_VALUE (line 7) | const DEFAULT_MIN_VALUE: Duration = Duration::from_nanos(100);
  constant DEFAULT_MAX_VALUE (line 8) | const DEFAULT_MAX_VALUE: Duration = Duration::from_secs(60);
  constant DEFAULT_PRECISION (line 11) | const DEFAULT_PRECISION: u32 = 2;
  constant MAX_PRECISION (line 12) | const MAX_PRECISION: u32 = 10;
  type LogHistogram (line 27) | pub struct LogHistogram {
    method from_n_p (line 51) | fn from_n_p(n: u32, p: u32, bucket_offset: usize) -> Self {
    method truncate_to_max_value (line 61) | fn truncate_to_max_value(&self, max_value: u64) -> LogHistogram {
    method builder (line 71) | pub fn builder() -> LogHistogramBuilder {
    method max_value (line 76) | pub fn max_value(&self) -> u64 {
    method value_to_bucket (line 80) | pub(crate) fn value_to_bucket(&self, value: u64) -> usize {
    method bucket_range (line 87) | pub(crate) fn bucket_range(&self, bucket: usize) -> std::ops::Range<u6...
    method from (line 151) | fn from(value: LogHistogramBuilder) -> Self {
  method default (line 41) | fn default() -> Self {
  type LogHistogramBuilder (line 144) | pub struct LogHistogramBuilder {
    method max_error (line 175) | pub fn max_error(mut self, max_error: f64) -> Self {
    method precision_exact (line 200) | pub fn precision_exact(mut self, p: u32) -> Self {
    method min_value (line 211) | pub fn min_value(mut self, duration: Duration) -> Self {
    method max_value (line 222) | pub fn max_value(mut self, duration: Duration) -> Self {
    method max_buckets (line 231) | pub fn max_buckets(
    method build (line 245) | pub fn build(&self) -> LogHistogram {
  type InvalidHistogramConfiguration (line 262) | pub enum InvalidHistogramConfiguration {
  method fmt (line 271) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function bucket_index (line 284) | fn bucket_index(value: u64, p: u32) -> u64 {
  function valid_log_histogram_strategy (line 313) | fn valid_log_histogram_strategy() -> impl Strategy<Value = LogHistogram> {
  function log_histogram_settings (line 321) | fn log_histogram_settings() -> impl Strategy<Value = (u64, u64, u32)> {
  function bucket_ranges_are_correct (line 420) | fn bucket_ranges_are_correct() {
  function bucket_computation_spot_check (line 451) | fn bucket_computation_spot_check() {
  function last_bucket_goes_to_infinity (line 487) | fn last_bucket_goes_to_infinity() {
  function bucket_offset (line 493) | fn bucket_offset() {
  function max_buckets_enforcement (line 508) | fn max_buckets_enforcement() {
  function default_configuration_size (line 522) | fn default_configuration_size() {

FILE: tokio/src/runtime/metrics/io.rs
  type IoDriverMetrics (line 7) | pub(crate) struct IoDriverMetrics {
    method incr_fd_count (line 14) | pub(crate) fn incr_fd_count(&self) {
    method dec_fd_count (line 18) | pub(crate) fn dec_fd_count(&self) {
    method incr_ready_count_by (line 22) | pub(crate) fn incr_ready_count_by(&self, amt: u64) {

FILE: tokio/src/runtime/metrics/mock.rs
  type SchedulerMetrics (line 3) | pub(crate) struct SchedulerMetrics {}
    method new (line 9) | pub(crate) fn new() -> Self {
    method inc_remote_schedule_count (line 14) | pub(crate) fn inc_remote_schedule_count(&self) {}
  type HistogramBuilder (line 6) | pub(crate) struct HistogramBuilder {}

FILE: tokio/src/runtime/metrics/runtime.rs
  type RuntimeMetrics (line 20) | pub struct RuntimeMetrics {
    method new (line 25) | pub(crate) fn new(handle: Handle) -> RuntimeMetrics {
    method num_workers (line 48) | pub fn num_workers(&self) -> usize {
    method num_alive_tasks (line 74) | pub fn num_alive_tasks(&self) -> usize {
    method global_queue_depth (line 100) | pub fn global_queue_depth(&self) -> usize {

FILE: tokio/src/runtime/metrics/scheduler.rs
  type SchedulerMetrics (line 12) | pub(crate) struct SchedulerMetrics {
    method new (line 19) | pub(crate) fn new() -> SchedulerMetrics {
    method inc_remote_schedule_count (line 27) | pub(crate) fn inc_remote_schedule_count(&self) {
    method inc_budget_forced_yield_count (line 32) | pub(crate) fn inc_budget_forced_yield_count(&self) {

FILE: tokio/src/runtime/metrics/worker.rs
  type WorkerMetrics (line 20) | pub(crate) struct WorkerMetrics {
    method new (line 71) | pub(crate) fn new() -> WorkerMetrics {
    method set_queue_depth (line 75) | pub(crate) fn set_queue_depth(&self, len: usize) {
    method set_thread_id (line 79) | pub(crate) fn set_thread_id(&self, thread_id: ThreadId) {

FILE: tokio/src/runtime/mod.rs
  type TimerFlavor (line 413) | pub(crate) enum TimerFlavor {

FILE: tokio/src/runtime/park.rs
  type ParkThread (line 10) | pub(crate) struct ParkThread {
    method new (line 44) | pub(crate) fn new() -> Self {
    method unpark (line 54) | pub(crate) fn unpark(&self) -> UnparkThread {
    method park (line 59) | pub(crate) fn park(&mut self) {
    method park_timeout (line 65) | pub(crate) fn park_timeout(&mut self, duration: Duration) {
    method shutdown (line 71) | pub(crate) fn shutdown(&mut self) {
  type UnparkThread (line 16) | pub(crate) struct UnparkThread {
    method unpark (line 220) | pub(crate) fn unpark(&self) {
    method into_waker (line 294) | pub(crate) fn into_waker(self) -> Waker {
  type Inner (line 21) | struct Inner {
    method park (line 79) | fn park(&self) {
    method park_timeout (line 127) | fn park_timeout(&self, dur: Duration) {
    method unpark (line 177) | fn unpark(&self) {
    method shutdown (line 206) | fn shutdown(&self) {
    method into_raw (line 304) | fn into_raw(this: Arc<Inner>) -> *const () {
    method from_raw (line 311) | unsafe fn from_raw(ptr: *const ()) -> Arc<Inner> {
  constant EMPTY (line 27) | const EMPTY: usize = 0;
  constant PARKED (line 28) | const PARKED: usize = 1;
  constant NOTIFIED (line 29) | const NOTIFIED: usize = 2;
  method default (line 212) | fn default() -> Self {
  type CachedParkThread (line 233) | pub(crate) struct CachedParkThread {
    method new (line 242) | pub(crate) fn new() -> CachedParkThread {
    method waker (line 248) | pub(crate) fn waker(&self) -> Result<Waker, AccessError> {
    method unpark (line 252) | fn unpark(&self) -> Result<UnparkThread, AccessError> {
    method park (line 256) | pub(crate) fn park(&mut self) {
    method park_timeout (line 261) | pub(crate) fn park_timeout(&mut self, duration: Duration) {
    method with_current (line 267) | fn with_current<F, R>(&self, f: F) -> Result<R, AccessError>
    method block_on (line 274) | pub(crate) fn block_on<F: Future>(&mut self, f: F) -> Result<F::Output...
  function unparker_to_raw_waker (line 317) | unsafe fn unparker_to_raw_waker(unparker: Arc<Inner>) -> RawWaker {
  function clone (line 327) | unsafe fn clone(raw: *const ()) -> RawWaker {
  function drop_waker (line 337) | unsafe fn drop_waker(raw: *const ()) {
  function wake (line 344) | unsafe fn wake(raw: *const ()) {
  function wake_by_ref (line 352) | unsafe fn wake_by_ref(raw: *const ()) {
  function current_thread_park_count (line 360) | pub(crate) fn current_thread_park_count() -> usize {

FILE: tokio/src/runtime/process.rs
  type Driver (line 13) | pub(crate) struct Driver {
    method new (line 22) | pub(crate) fn new(park: SignalDriver) -> Self {
    method park (line 31) | pub(crate) fn park(&mut self, handle: &driver::Handle) {
    method park_timeout (line 36) | pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duratio...
    method shutdown (line 41) | pub(crate) fn shutdown(&mut self, handle: &driver::Handle) {

FILE: tokio/src/runtime/runtime.rs
  type Runtime (line 97) | pub struct Runtime {
    method from_parts (line 132) | pub(super) fn from_parts(
    method new (line 174) | pub fn new() -> std::io::Result<Runtime> {
    method handle (line 201) | pub fn handle(&self) -> &Handle {
    method spawn (line 239) | pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    method spawn_blocking (line 275) | pub fn spawn_blocking<F, R>(&self, func: F) -> JoinHandle<R>
    method block_on (line 340) | pub fn block_on<F: Future>(&self, future: F) -> F::Output {
    method block_on_inner (line 350) | fn block_on_inner<F: Future>(&self, future: F, _meta: SpawnMeta<'_>) -...
    method enter (line 416) | pub fn enter(&self) -> EnterGuard<'_> {
    method shutdown_timeout (line 449) | pub fn shutdown_timeout(mut self, duration: Duration) {
    method shutdown_background (line 486) | pub fn shutdown_background(self) {
    method metrics (line 492) | pub fn metrics(&self) -> crate::runtime::RuntimeMetrics {
  type RuntimeFlavor (line 113) | pub enum RuntimeFlavor {
  type Scheduler (line 122) | pub(super) enum Scheduler {
  method drop (line 498) | fn drop(&mut self) {
  function display_eq (line 520) | fn display_eq(d: impl std::fmt::Display, s: &str) -> bool {
  function is_rt_shutdown_err (line 577) | pub fn is_rt_shutdown_err(err: &io::Error) -> bool {

FILE: tokio/src/runtime/scheduler/block_in_place.rs
  function block_in_place (line 4) | pub(crate) fn block_in_place<F, R>(f: F) -> R

FILE: tokio/src/runtime/scheduler/current_thread/mod.rs
  type CurrentThread (line 26) | pub(crate) struct CurrentThread {
    method new (line 128) | pub(crate) fn new(
    method block_on (line 185) | pub(crate) fn block_on<F: Future>(&self, handle: &scheduler::Handle, f...
    method take_core (line 226) | fn take_core(&self, handle: &Arc<Handle>) -> Option<CoreGuard<'_>> {
    method shutdown (line 239) | pub(crate) fn shutdown(&mut self, handle: &scheduler::Handle) {
    method fmt (line 306) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Handle (line 36) | pub(crate) struct Handle {
    method spawn (line 463) | pub(crate) fn spawn<F>(
    method spawn_local (line 496) | pub(crate) unsafe fn spawn_local<F>(
    method dump (line 533) | pub(crate) fn dump(&self) -> crate::runtime::Dump {
    method next_remote_task (line 576) | fn next_remote_task(&self) -> Option<Notified> {
    method waker_ref (line 580) | fn waker_ref(me: &Arc<Self>) -> WakerRef<'_> {
    method reset_woken (line 588) | pub(crate) fn reset_woken(&self) -> bool {
    method num_alive_tasks (line 592) | pub(crate) fn num_alive_tasks(&self) -> usize {
    method injection_queue_depth (line 596) | pub(crate) fn injection_queue_depth(&self) -> usize {
    method worker_metrics (line 600) | pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {
    method owned_id (line 639) | pub(crate) fn owned_id(&self) -> NonZeroU64 {
    method fmt (line 645) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Core (line 58) | struct Core {
    method tick (line 315) | fn tick(&mut self) {
    method next_task (line 319) | fn next_task(&mut self, handle: &Handle) -> Option<Notified> {
    method next_local_task (line 330) | fn next_local_task(&mut self, handle: &Handle) -> Option<Notified> {
    method push_task (line 339) | fn push_task(&mut self, handle: &Handle, task: Notified) {
    method submit_metrics (line 348) | fn submit_metrics(&mut self, handle: &Handle) {
  type Shared (line 82) | struct Shared {
  type Context (line 105) | pub(crate) struct Context {
    method run_task (line 366) | fn run_task<R>(&self, mut core: Box<Core>, f: impl FnOnce() -> R) -> (...
    method park (line 375) | fn park(&self, mut core: Box<Core>, handle: &Handle) -> Box<Core> {
    method park_yield (line 406) | fn park_yield(&self, mut core: Box<Core>, handle: &Handle) -> Box<Core> {
    method has_pending_work (line 417) | fn has_pending_work(&self, core: &Core) -> bool {
    method park_internal (line 421) | fn park_internal(
    method enter (line 439) | fn enter<R>(&self, core: Box<Core>, f: impl FnOnce() -> R) -> (Box<Cor...
    method defer (line 453) | pub(crate) fn defer(&self, waker: &Waker) {
  type Notified (line 117) | type Notified = task::Notified<Arc<Handle>>;
  constant INITIAL_CAPACITY (line 120) | const INITIAL_CAPACITY: usize = 64;
  constant DEFAULT_GLOBAL_QUEUE_INTERVAL (line 125) | const DEFAULT_GLOBAL_QUEUE_INTERVAL: u32 = 31;
  function shutdown2 (line 272) | fn shutdown2(mut core: Box<Core>, handle: &Handle) -> Box<Core> {
  function wake_deferred_tasks_and_free (line 354) | fn wake_deferred_tasks_and_free(context: &Context) {
  method release (line 653) | fn release(&self, task: &Task<Self>) -> Option<Task<Self>> {
  method schedule (line 657) | fn schedule(&self, task: task::Notified<Self>) {
  method hooks (line 681) | fn hooks(&self) -> TaskHarnessScheduleHooks {
  method wake (line 721) | fn wake(arc_self: Arc<Self>) {
  method wake_by_ref (line 726) | fn wake_by_ref(arc_self: &Arc<Self>) {
  type CoreGuard (line 748) | struct CoreGuard<'a> {
  function block_on (line 755) | fn block_on<F: Future>(self, future: F) -> F::Output {
  function enter (line 846) | fn enter<F, R>(self, f: F) -> R
  method drop (line 865) | fn drop(&mut self) {

FILE: tokio/src/runtime/scheduler/defer.rs
  type Defer (line 4) | pub(crate) struct Defer {
    method new (line 9) | pub(crate) fn new() -> Defer {
    method defer (line 15) | pub(crate) fn defer(&self, waker: &Waker) {
    method is_empty (line 28) | pub(crate) fn is_empty(&self) -> bool {
    method wake (line 32) | pub(crate) fn wake(&self) {
    method take_deferred (line 39) | pub(crate) fn take_deferred(&self) -> Vec<Waker> {

FILE: tokio/src/runtime/scheduler/inject.rs
  type Inject (line 23) | pub(crate) struct Inject<T: 'static> {
  function new (line 29) | pub(crate) fn new() -> Inject<T> {
  function is_closed (line 40) | pub(crate) fn is_closed(&self) -> bool {
  function close (line 47) | pub(crate) fn close(&self) -> bool {
  function push (line 55) | pub(crate) fn push(&self, task: task::Notified<T>) {
  function pop (line 61) | pub(crate) fn pop(&self) -> Option<task::Notified<T>> {

FILE: tokio/src/runtime/scheduler/inject/metrics.rs
  function len (line 4) | pub(crate) fn len(&self) -> usize {

FILE: tokio/src/runtime/scheduler/inject/pop.rs
  type Pop (line 7) | pub(crate) struct Pop<'a, T: 'static> {
  function new (line 14) | pub(super) fn new(len: usize, synced: &'a mut Synced) -> Pop<'a, T> {
  type Item (line 24) | type Item = task::Notified<T>;
  method next (line 26) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 40) | fn size_hint(&self) -> (usize, Option<usize>) {
  method len (line 46) | fn len(&self) -> usize {
  method drop (line 52) | fn drop(&mut self) {

FILE: tokio/src/runtime/scheduler/inject/rt_multi_thread.rs
  type Handle (line 9) | type Handle = &'a mut Synced;
  function lock (line 11) | fn lock(self) -> Self::Handle {
  method as_mut (line 17) | fn as_mut(&mut self) -> &mut Synced {
  function push_batch (line 29) | pub(crate) unsafe fn push_batch<L, I>(&self, shared: L, mut iter: I)
  function push_batch_inner (line 74) | unsafe fn push_batch_inner<L>(

FILE: tokio/src/runtime/scheduler/inject/shared.rs
  type Shared (line 9) | pub(crate) struct Shared<T: 'static> {
  function new (line 21) | pub(crate) fn new() -> (Shared<T>, Synced) {
  function is_empty (line 36) | pub(crate) fn is_empty(&self) -> bool {
  function is_closed (line 42) | pub(crate) fn is_closed(&self, synced: &Synced) -> bool {
  function close (line 48) | pub(crate) fn close(&self, synced: &mut Synced) -> bool {
  function len (line 57) | pub(crate) fn len(&self) -> usize {
  function push (line 68) | pub(crate) unsafe fn push(&self, synced: &mut Synced, task: task::Notifi...
  function pop (line 97) | pub(crate) unsafe fn pop(&self, synced: &mut Synced) -> Option<task::Not...
  function pop_n (line 106) | pub(crate) unsafe fn pop_n<'a>(&'a self, synced: &'a mut Synced, n: usiz...

FILE: tokio/src/runtime/scheduler/inject/synced.rs
  type Synced (line 8) | pub(crate) struct Synced {
    method pop (line 23) | pub(super) fn pop<T: 'static>(&mut self) -> Option<task::Notified<T>> {

FILE: tokio/src/runtime/scheduler/lock.rs
  type Lock (line 2) | pub(crate) trait Lock<T> {
    method lock (line 5) | fn lock(self) -> Self::Handle;

FILE: tokio/src/runtime/scheduler/mod.rs
  type Handle (line 32) | pub(crate) enum Handle {
    method driver (line 56) | pub(crate) fn driver(&self) -> &driver::Handle {
  type Context (line 47) | pub(super) enum Context {

FILE: tokio/src/runtime/scheduler/multi_thread/counters.rs
  method drop (line 13) | fn drop(&mut self) {
  function inc_num_inc_notify_local (line 29) | pub(crate) fn inc_num_inc_notify_local() {
  function inc_num_unparks_local (line 33) | pub(crate) fn inc_num_unparks_local() {
  function inc_num_maintenance (line 37) | pub(crate) fn inc_num_maintenance() {
  function inc_lifo_schedules (line 41) | pub(crate) fn inc_lifo_schedules() {
  function inc_lifo_capped (line 45) | pub(crate) fn inc_lifo_capped() {
  function inc_num_inc_notify_local (line 52) | pub(crate) fn inc_num_inc_notify_local() {}
  function inc_num_unparks_local (line 53) | pub(crate) fn inc_num_unparks_local() {}
  function inc_num_maintenance (line 54) | pub(crate) fn inc_num_maintenance() {}
  function inc_lifo_schedules (line 55) | pub(crate) fn inc_lifo_schedules() {}
  function inc_lifo_capped (line 56) | pub(crate) fn inc_lifo_capped() {}
  type Counters (line 60) | pub(crate) struct Counters;

FILE: tokio/src/runtime/scheduler/multi_thread/handle.rs
  type Handle (line 25) | pub(crate) struct Handle {
    method spawn (line 52) | pub(crate) fn spawn<F>(
    method is_shutdown (line 66) | pub(crate) fn is_shutdown(&self) -> bool {
    method shutdown (line 71) | pub(crate) fn shutdown(&self) {
    method bind_new_task (line 78) | pub(super) fn bind_new_task<T>(
    method owned_id (line 123) | pub(crate) fn owned_id(&self) -> NonZeroU64 {
    method fmt (line 129) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function release (line 103) | fn release(&self, task: &Task<Self>) -> Option<Task<Self>> {
  function schedule (line 107) | fn schedule(&self, task: Notified<Self>) {
  function hooks (line 111) | fn hooks(&self) -> TaskHarnessScheduleHooks {
  function yield_now (line 117) | fn yield_now(&self, task: Notified<Self>) {

FILE: tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs
  method num_workers (line 9) | pub(crate) fn num_workers(&self) -> usize {
  method num_alive_tasks (line 13) | pub(crate) fn num_alive_tasks(&self) -> usize {
  method injection_queue_depth (line 17) | pub(crate) fn injection_queue_depth(&self) -> usize {
  method worker_metrics (line 21) | pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {

FILE: tokio/src/runtime/scheduler/multi_thread/handle/taskdump.rs
  method dump (line 6) | pub(crate) async fn dump(&self) -> Dump {

FILE: tokio/src/runtime/scheduler/multi_thread/idle.rs
  type Idle (line 9) | pub(super) struct Idle {
    method new (line 34) | pub(super) fn new(num_workers: usize) -> (Idle, Synced) {
    method worker_to_notify (line 51) | pub(super) fn worker_to_notify(&self, shared: &Shared) -> Option<usize> {
    method transition_worker_to_parked (line 86) | pub(super) fn transition_worker_to_parked(
    method transition_worker_to_searching (line 104) | pub(super) fn transition_worker_to_searching(&self) -> bool {
    method transition_worker_from_searching (line 121) | pub(super) fn transition_worker_from_searching(&self) -> bool {
    method unpark_worker_by_id (line 129) | pub(super) fn unpark_worker_by_id(&self, shared: &Shared, worker_id: u...
    method is_parked (line 148) | pub(super) fn is_parked(&self, shared: &Shared, worker_id: usize) -> b...
    method notify_should_wakeup (line 153) | fn notify_should_wakeup(&self) -> bool {
  type Synced (line 21) | pub(super) struct Synced {
  constant UNPARK_SHIFT (line 26) | const UNPARK_SHIFT: usize = 16;
  constant UNPARK_MASK (line 27) | const UNPARK_MASK: usize = !SEARCH_MASK;
  constant SEARCH_MASK (line 28) | const SEARCH_MASK: usize = (1 << UNPARK_SHIFT) - 1;
  type State (line 31) | struct State(usize);
    method new (line 160) | fn new(num_workers: usize) -> State {
    method load (line 168) | fn load(cell: &AtomicUsize, ordering: Ordering) -> State {
    method unpark_one (line 172) | fn unpark_one(cell: &AtomicUsize, num_searching: usize) {
    method inc_num_searching (line 176) | fn inc_num_searching(cell: &AtomicUsize, ordering: Ordering) {
    method dec_num_searching (line 181) | fn dec_num_searching(cell: &AtomicUsize) -> bool {
    method dec_num_unparked (line 189) | fn dec_num_unparked(cell: &AtomicUsize, is_searching: bool) -> bool {
    method num_searching (line 201) | fn num_searching(self) -> usize {
    method num_unparked (line 206) | fn num_unparked(self) -> usize {
    method from (line 212) | fn from(src: usize) -> State {
    method fmt (line 224) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 218) | fn from(src: State) -> usize {
  function test_state (line 233) | fn test_state() {

FILE: tokio/src/runtime/scheduler/multi_thread/mod.rs
  type MultiThread (line 52) | pub(crate) struct MultiThread;
    method new (line 57) | pub(crate) fn new(
    method block_on (line 84) | pub(crate) fn block_on<F>(&self, handle: &scheduler::Handle, future: F...
    method shutdown (line 93) | pub(crate) fn shutdown(&mut self, handle: &scheduler::Handle) {
    method fmt (line 102) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/scheduler/multi_thread/overflow.rs
  type Overflow (line 6) | pub(crate) trait Overflow<T: 'static> {
    method push (line 7) | fn push(&self, task: task::Notified<T>);
    method push_batch (line 9) | fn push_batch<I>(&self, iter: I)
  function push (line 16) | fn push(&self, task: task::Notified<T>) {
  function push_batch (line 20) | fn push_batch<I>(&self, iter: I)

FILE: tokio/src/runtime/scheduler/multi_thread/park.rs
  type Parker (line 16) | pub(crate) struct Parker {
    method new (line 50) | pub(crate) fn new(driver: Driver) -> Parker {
    method unpark (line 63) | pub(crate) fn unpark(&self) -> Unparker {
    method park (line 69) | pub(crate) fn park(&mut self, handle: &driver::Handle) {
    method park_timeout (line 78) | pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duratio...
    method shutdown (line 93) | pub(crate) fn shutdown(&mut self, handle: &driver::Handle) {
  type Unparker (line 20) | pub(crate) struct Unparker {
    method unpark (line 112) | pub(crate) fn unpark(&self, driver: &driver::Handle) {
  type Inner (line 24) | struct Inner {
    method park (line 119) | fn park(&self, handle: &driver::Handle) {
    method park_condvar (line 144) | fn park_condvar(&self, duration: Option<Duration>) {
    method park_driver (line 214) | fn park_driver(
    method unpark (line 261) | fn unpark(&self, driver: &driver::Handle) {
    method unpark_condvar (line 276) | fn unpark_condvar(&self) {
    method shutdown (line 293) | fn shutdown(&self, handle: &driver::Handle) {
  constant EMPTY (line 38) | const EMPTY: usize = 0;
  constant PARKED_CONDVAR (line 39) | const PARKED_CONDVAR: usize = 1;
  constant PARKED_DRIVER (line 40) | const PARKED_DRIVER: usize = 2;
  constant NOTIFIED (line 41) | const NOTIFIED: usize = 3;
  type Shared (line 44) | struct Shared {
  method clone (line 99) | fn clone(&self) -> Parker {

FILE: tokio/src/runtime/scheduler/multi_thread/queue.rs
  type Local (line 29) | pub(crate) struct Local<T: 'static> {
  type Steal (line 34) | pub(crate) struct Steal<T: 'static>(Arc<Inner<T>>);
  type Inner (line 36) | pub(crate) struct Inner<T: 'static> {
  constant LOCAL_QUEUE_CAPACITY (line 63) | const LOCAL_QUEUE_CAPACITY: usize = 256;
  constant LOCAL_QUEUE_CAPACITY (line 69) | const LOCAL_QUEUE_CAPACITY: usize = 4;
  constant MASK (line 71) | const MASK: usize = LOCAL_QUEUE_CAPACITY - 1;
  function make_fixed_size (line 77) | fn make_fixed_size<T>(buffer: Box<[T]>) -> Box<[T; LOCAL_QUEUE_CAPACITY]> {
  function local (line 85) | pub(crate) fn local<T: 'static>() -> (Steal<T>, Local<T>) {
  function len (line 109) | pub(crate) fn len(&self) -> usize {
  function remaining_slots (line 117) | pub(crate) fn remaining_slots(&self) -> usize {
  function max_capacity (line 125) | pub(crate) fn max_capacity(&self) -> usize {
  function has_tasks (line 133) | pub(crate) fn has_tasks(&self) -> bool {
  function push_back (line 143) | pub(crate) fn push_back(&mut self, tasks: impl ExactSizeIterator<Item = ...
  function push_back_or_overflow (line 192) | pub(crate) fn push_back_or_overflow<O: Overflow<T>>(
  function push_back_finish (line 230) | fn push_back_finish(&self, task: task::Notified<T>, tail: UnsignedShort) {
  function push_overflow (line 257) | fn push_overflow<O: Overflow<T>>(
  function pop (line 352) | pub(crate) fn pop(&mut self) -> Option<task::Notified<T>> {
  function len (line 395) | pub(crate) fn len(&self) -> usize {
  function is_empty (line 403) | pub(crate) fn is_empty(&self) -> bool {
  function steal_into (line 408) | pub(crate) fn steal_into(
  function steal_into2 (line 463) | fn steal_into2(&self, dst: &mut Local<T>, dst_tail: UnsignedShort) -> Un...
  method clone (line 563) | fn clone(&self) -> Steal<T> {
  method drop (line 569) | fn drop(&mut self) {
  function len (line 578) | fn len(head: UnsignedShort, tail: UnsignedShort) -> usize {
  function unpack (line 584) | fn unpack(n: UnsignedLong) -> (UnsignedShort, UnsignedShort) {
  function pack (line 592) | fn pack(steal: UnsignedShort, real: UnsignedShort) -> UnsignedLong {
  function test_local_queue_capacity (line 597) | fn test_local_queue_capacity() {

FILE: tokio/src/runtime/scheduler/multi_thread/stats.rs
  type Stats (line 7) | pub(crate) struct Stats {
    method new (line 42) | pub(crate) fn new(worker_metrics: &WorkerMetrics) -> Stats {
    method tuned_global_queue_interval (line 55) | pub(crate) fn tuned_global_queue_interval(&self, config: &Config) -> u...
    method submit (line 69) | pub(crate) fn submit(&mut self, to: &WorkerMetrics) {
    method about_to_park (line 73) | pub(crate) fn about_to_park(&mut self) {
    method unparked (line 77) | pub(crate) fn unparked(&mut self) {
    method inc_local_schedule_count (line 81) | pub(crate) fn inc_local_schedule_count(&mut self) {
    method start_processing_scheduled_tasks (line 85) | pub(crate) fn start_processing_scheduled_tasks(&mut self) {
    method end_processing_scheduled_tasks (line 92) | pub(crate) fn end_processing_scheduled_tasks(&mut self) {
    method start_poll (line 116) | pub(crate) fn start_poll(&mut self) {
    method end_poll (line 122) | pub(crate) fn end_poll(&mut self) {
    method incr_steal_count (line 126) | pub(crate) fn incr_steal_count(&mut self, by: u16) {
    method incr_steal_operations (line 130) | pub(crate) fn incr_steal_operations(&mut self) {
    method incr_overflow_count (line 134) | pub(crate) fn incr_overflow_count(&mut self) {
  constant TASK_POLL_TIME_EWMA_ALPHA (line 30) | const TASK_POLL_TIME_EWMA_ALPHA: f64 = 0.1;
  constant TARGET_GLOBAL_QUEUE_INTERVAL (line 33) | const TARGET_GLOBAL_QUEUE_INTERVAL: f64 = Duration::from_micros(200).as_...
  constant MAX_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL (line 36) | const MAX_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL: u32 = 127;
  constant TARGET_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL (line 39) | const TARGET_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL: u32 = 61;

FILE: tokio/src/runtime/scheduler/multi_thread/trace.rs
  type TraceStatus (line 8) | pub(super) struct TraceStatus {
    method new (line 17) | pub(super) fn new(remotes_len: usize) -> Self {
    method trace_requested (line 27) | pub(super) fn trace_requested(&self) -> bool {
    method start_trace_request (line 31) | pub(super) async fn start_trace_request(&self, handle: &Handle) {
    method stash_result (line 42) | pub(super) fn stash_result(&self, dump: Dump) {
    method take_result (line 47) | pub(super) fn take_result(&self) -> Option<Dump> {
    method end_trace_request (line 51) | pub(super) async fn end_trace_request(&self, handle: &Handle) {

FILE: tokio/src/runtime/scheduler/multi_thread/trace_mock.rs
  type TraceStatus (line 1) | pub(super) struct TraceStatus {}
    method new (line 4) | pub(super) fn new(_: usize) -> Self {
    method trace_requested (line 8) | pub(super) fn trace_requested(&self) -> bool {

FILE: tokio/src/runtime/scheduler/multi_thread/worker.rs
  type Worker (line 99) | pub(super) struct Worker {
    method inject (line 1267) | fn inject(&self) -> &inject::Shared<Arc<Handle>> {
  type Core (line 111) | struct Core {
    method tick (line 1018) | fn tick(&mut self) {
    method next_task (line 1023) | fn next_task(&mut self, worker: &Worker) -> Option<Notified> {
    method next_local_task (line 1078) | fn next_local_task(&mut self) -> Option<Notified> {
    method steal_work (line 1087) | fn steal_work(&mut self, worker: &Worker) -> Option<Notified> {
    method transition_to_searching (line 1117) | fn transition_to_searching(&mut self, worker: &Worker) -> bool {
    method transition_from_searching (line 1125) | fn transition_from_searching(&mut self, worker: &Worker) {
    method has_tasks (line 1134) | fn has_tasks(&self) -> bool {
    method should_notify_others (line 1138) | fn should_notify_others(&self) -> bool {
    method transition_to_parked (line 1150) | fn transition_to_parked(&mut self, worker: &Worker) -> bool {
    method transition_from_parked (line 1177) | fn transition_from_parked(&mut self, worker: &Worker) -> bool {
    method maintenance (line 1208) | fn maintenance(&mut self, worker: &Worker) {
    method pre_shutdown (line 1226) | fn pre_shutdown(&mut self, worker: &Worker) {
    method shutdown (line 1243) | fn shutdown(&mut self, handle: &Handle) {
    method tune_global_queue_interval (line 1253) | fn tune_global_queue_interval(&mut self, worker: &Worker) {
  type Shared (line 159) | pub(crate) struct Shared {
  type Synced (line 204) | pub(crate) struct Synced {
  type Remote (line 219) | struct Remote {
  type Context (line 228) | pub(crate) struct Context {
    method run (line 547) | fn run(&self, mut core: Box<Core>) -> RunResult {
    method run_task (line 616) | fn run_task(&self, task: Notified, mut core: Box<Core>) -> RunResult {
    method reset_lifo_enabled (line 732) | fn reset_lifo_enabled(&self, core: &mut Core) {
    method assert_lifo_enabled_is_correct (line 736) | fn assert_lifo_enabled_is_correct(&self, core: &Core) {
    method maintenance (line 743) | fn maintenance(&self, mut core: Box<Core>) -> Box<Core> {
    method park (line 773) | fn park(&self, mut core: Box<Core>) -> Box<Core> {
    method park_yield (line 803) | fn park_yield(&self, core: Box<Core>) -> Box<Core> {
    method park_internal (line 807) | fn park_internal(&self, mut core: Box<Core>, duration: Option<Duration...
    method defer (line 868) | pub(crate) fn defer(&self, waker: &Waker) {
    method maintain_local_timers_before_parking (line 890) | fn maintain_local_timers_before_parking(
    method maintain_local_timers_after_parking (line 958) | fn maintain_local_timers_after_parking(&self, auto_advance_duration: O...
    method with_core (line 986) | fn with_core<F, R>(&self, f: F) -> R
    method with_time_temp_local_context (line 997) | pub(crate) fn with_time_temp_local_context<F, R>(&self, f: F) -> R
    method worker_index (line 1011) | pub(crate) fn worker_index(&self) -> usize {
  type Launch (line 241) | pub(crate) struct Launch(Vec<Arc<Worker>>);
    method launch (line 487) | pub(crate) fn launch(mut self) {
  type RunResult (line 246) | type RunResult = Result<Box<Core>, ()>;
  type Notified (line 249) | type Notified = task::Notified<Arc<Handle>>;
  constant MAX_LIFO_POLLS_PER_TICK (line 255) | const MAX_LIFO_POLLS_PER_TICK: usize = 3;
  function create (line 257) | pub(super) fn create(
  function block_in_place (line 345) | pub(crate) fn block_in_place<F, R>(f: F) -> R
  function run (line 494) | fn run(worker: Arc<Worker>) {
  type InjectGuard (line 1472) | pub(crate) struct InjectGuard<'a> {
  function as_mut (line 1477) | fn as_mut(&mut self) -> &mut inject::Synced {
  type Handle (line 1483) | type Handle = InjectGuard<'a>;
    method schedule_task (line 1273) | pub(super) fn schedule_task(&self, task: Notified, is_yield: bool) {
    method schedule_option_task_without_yield (line 1293) | pub(super) fn schedule_option_task_without_yield(&self, task: Option<N...
    method schedule_local (line 1299) | fn schedule_local(&self, core: &mut Core, task: Notified, is_yield: bo...
    method next_remote_task (line 1333) | fn next_remote_task(&self) -> Option<Notified> {
    method push_remote_task (line 1343) | fn push_remote_task(&self, task: Notified) {
    method push_remote_timer (line 1354) | pub(crate) fn push_remote_timer(&self, hdl: time_alt::EntryHandle) {
    method take_remote_timers (line 1364) | pub(crate) fn take_remote_timers(&self) -> Vec<time_alt::EntryHandle> {
    method close (line 1374) | pub(super) fn close(&self) {
    method notify_parked_local (line 1384) | fn notify_parked_local(&self) {
    method notify_parked_remote (line 1393) | fn notify_parked_remote(&self) {
    method notify_all (line 1399) | pub(super) fn notify_all(&self) {
    method notify_if_work_pending (line 1405) | fn notify_if_work_pending(&self) {
    method transition_worker_from_searching (line 1418) | fn transition_worker_from_searching(&self) {
    method shutdown_core (line 1430) | fn shutdown_core(&self, core: Box<Core>) {
    method ptr_eq (line 1452) | fn ptr_eq(&self, other: &Handle) -> bool {
    method push (line 1458) | fn push(&self, task: task::Notified<Arc<Handle>>) {
    method push_batch (line 1462) | fn push_batch<I>(&self, iter: I)
  function lock (line 1485) | fn lock(self) -> Self::Handle {
  type MaintainLocalTimer (line 1494) | struct MaintainLocalTimer {
  function with_current (line 1500) | fn with_current<R>(f: impl FnOnce(Option<&Context>) -> R) -> R {

FILE: tokio/src/runtime/scheduler/multi_thread/worker/metrics.rs
  method injection_queue_depth (line 4) | pub(crate) fn injection_queue_depth(&self) -> usize {

FILE: tokio/src/runtime/scheduler/multi_thread/worker/taskdump.rs
  method trace_core (line 11) | pub(super) fn trace_core(&self, mut core: Box<Core>) -> Box<Core> {
  method steal_all (line 62) | pub(super) fn steal_all(&self) -> super::queue::Local<Arc<Handle>> {

FILE: tokio/src/runtime/scheduler/multi_thread/worker/taskdump_mock.rs
  method trace_core (line 4) | pub(super) fn trace_core(&self, core: Box<Core>) -> Box<Core> {

FILE: tokio/src/runtime/scheduler/util/time_alt.rs
  function min_duration (line 6) | pub(crate) fn min_duration(a: Option<Duration>, b: Option<Duration>) -> ...
  function process_registration_queue (line 15) | pub(crate) fn process_registration_queue(
  function insert_inject_timers (line 35) | pub(crate) fn insert_inject_timers(
  function remove_cancelled_timers (line 55) | pub(crate) fn remove_cancelled_timers(wheel: &mut Wheel, rx: &mut Receiv...
  function next_expiration_time (line 68) | pub(crate) fn next_expiration_time(wheel: &Wheel, drv_hdl: &driver::Hand...
  function pre_auto_advance (line 86) | pub(crate) fn pre_auto_advance(drv_hdl: &driver::Handle, duration: Optio...
  function process_expired_timers (line 106) | pub(crate) fn process_expired_timers(
  function shutdown_local_timers (line 125) | pub(crate) fn shutdown_local_timers(
  function post_auto_advance (line 153) | pub(crate) fn post_auto_advance(drv_hdl: &driver::Handle, duration: Opti...
  function pre_auto_advance (line 172) | pub(crate) fn pre_auto_advance(_drv_hdl: &driver::Handle, _duration: Opt...
  function post_auto_advance (line 177) | pub(crate) fn post_auto_advance(_drv_hdl: &driver::Handle, _duration: Op...

FILE: tokio/src/runtime/signal/mod.rs
  type Driver (line 19) | pub(crate) struct Driver {
    method new (line 43) | pub(crate) fn new(io: io::Driver, io_handle: &io::Handle) -> std_io::R...
    method handle (line 85) | pub(crate) fn handle(&self) -> Handle {
    method park (line 91) | pub(crate) fn park(&mut self, handle: &driver::Handle) {
    method park_timeout (line 96) | pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duratio...
    method shutdown (line 101) | pub(crate) fn shutdown(&mut self, handle: &driver::Handle) {
    method process (line 105) | fn process(&mut self) {
  type Handle (line 33) | pub(crate) struct Handle {
    method check_inner (line 133) | pub(crate) fn check_inner(&self) -> std_io::Result<()> {

FILE: tokio/src/runtime/task/abort.rs
  type AbortHandle (line 23) | pub struct AbortHandle {
    method new (line 28) | pub(super) fn new(raw: RawTask) -> Self {
    method abort (line 53) | pub fn abort(&self) {
    method is_finished (line 63) | pub fn is_finished(&self) -> bool {
    method id (line 72) | pub fn id(&self) -> super::Id {
    method fmt (line 85) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 94) | fn drop(&mut self) {
  method clone (line 101) | fn clone(&self) -> Self {

FILE: tokio/src/runtime/task/core.rs
  type Cell (line 126) | pub(super) struct Cell<T: Future, S> {
  type CoreStage (line 137) | pub(super) struct CoreStage<T: Future> {
  type Core (line 148) | pub(super) struct Core<T: Future, S> {
  type Header (line 168) | pub(crate) struct Header {
    method set_next (line 434) | pub(super) unsafe fn set_next(&self, next: Option<NonNull<Header>>) {
    method set_owner_id (line 441) | pub(super) unsafe fn set_owner_id(&self, owner: NonZeroU64) {
    method get_owner_id (line 445) | pub(super) fn get_owner_id(&self) -> Option<NonZeroU64> {
    method get_trailer (line 456) | pub(super) unsafe fn get_trailer(me: NonNull<Header>) -> NonNull<Trail...
    method get_scheduler (line 470) | pub(super) unsafe fn get_scheduler<S>(me: NonNull<Header>) -> NonNull<...
    method get_id_ptr (line 481) | pub(super) unsafe fn get_id_ptr(me: NonNull<Header>) -> NonNull<Id> {
    method get_id (line 492) | pub(super) unsafe fn get_id(me: NonNull<Header>) -> Id {
    method get_spawn_location_ptr (line 504) | pub(super) unsafe fn get_spawn_location_ptr(
    method get_spawn_location (line 523) | pub(super) unsafe fn get_spawn_location(me: NonNull<Header>) -> &'stat...
    method get_tracing_id (line 534) | pub(super) unsafe fn get_tracing_id(me: &NonNull<Header>) -> Option<&t...
  type Trailer (line 201) | pub(super) struct Trailer {
    method new (line 540) | fn new(hooks: TaskHarnessScheduleHooks) -> Self {
    method set_waker (line 548) | pub(super) unsafe fn set_waker(&self, waker: Option<Waker>) {
    method will_wake (line 554) | pub(super) unsafe fn will_wake(&self, waker: &Waker) -> bool {
    method wake_join (line 559) | pub(super) fn wake_join(&self) {
  type Stage (line 221) | pub(super) enum Stage<T: Future> {
  function new (line 230) | pub(super) fn new(
  function with_mut (line 323) | pub(super) fn with_mut<R>(&self, f: impl FnOnce(*mut Stage<T>) -> R) -> R {
  type TaskIdGuard (line 330) | pub(crate) struct TaskIdGuard {
    method enter (line 335) | fn enter(id: Id) -> Self {
  method drop (line 343) | fn drop(&mut self) {
  function poll (line 362) | pub(super) fn poll(&self, mut cx: Context<'_>) -> Poll<T::Output> {
  function drop_future_or_output (line 391) | pub(super) fn drop_future_or_output(&self) {
  function store_output (line 403) | pub(super) fn store_output(&self, output: super::Result<T::Output>) {
  function take_output (line 415) | pub(super) fn take_output(&self) -> super::Result<T::Output> {
  function set_stage (line 427) | unsafe fn set_stage(&self, stage: Stage<T>) {
  function header_lte_cache_line (line 569) | fn header_lte_cache_line() {

FILE: tokio/src/runtime/task/error.rs
  type Repr (line 15) | enum Repr {
  method cancelled (line 21) | pub(crate) fn cancelled(id: Id) -> JoinError {
  method panic (line 28) | pub(crate) fn panic(id: Id, err: Box<dyn Any + Send + 'static>) -> JoinE...
  method is_cancelled (line 40) | pub fn is_cancelled(&self) -> bool {
  method is_panic (line 63) | pub fn is_panic(&self) -> bool {
  method into_panic (line 93) | pub fn into_panic(self) -> Box<dyn Any + Send + 'static> {
  method try_into_panic (line 119) | pub fn try_into_panic(self) -> Result<Box<dyn Any + Send + 'static>, Joi...
  method id (line 130) | pub fn id(&self) -> Id {
  method fmt (line 136) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 156) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 172) | fn from(src: JoinError) -> io::Error {
  function panic_payload_as_str (line 183) | fn panic_payload_as_str(payload: &SyncWrapper<Box<dyn Any + Send>>) -> O...

FILE: tokio/src/runtime/task/harness.rs
  type Harness (line 17) | pub(super) struct Harness<T: Future, S: 'static> {
  function from_raw (line 26) | pub(super) unsafe fn from_raw(ptr: NonNull<Header>) -> Harness<T, S> {
  function header_ptr (line 32) | fn header_ptr(&self) -> NonNull<Header> {
  function header (line 36) | fn header(&self) -> &Header {
  function state (line 40) | fn state(&self) -> &State {
  function trailer (line 44) | fn trailer(&self) -> &Trailer {
  function core (line 48) | fn core(&self) -> &Core<T, S> {
  method drop_reference (line 57) | pub(super) fn drop_reference(self) {
  method wake_by_val (line 68) | pub(super) fn wake_by_val(&self) {
  method wake_by_ref (line 96) | pub(super) fn wake_by_ref(&self) {
  method remote_abort (line 118) | pub(super) fn remote_abort(&self) {
  method try_set_join_waker (line 133) | pub(super) fn try_set_join_waker(&self, waker: &Waker) -> bool {
  function drop_reference (line 143) | pub(super) fn drop_reference(self) {
  function poll (line 153) | pub(super) fn poll(self) {
  function poll_inner (line 193) | fn poll_inner(&self) -> PollFuture {
  function shutdown (line 240) | pub(super) fn shutdown(self) {
  function dealloc (line 253) | pub(super) fn dealloc(self) {
  function try_read_output (line 281) | pub(super) fn try_read_output(self, dst: &mut Poll<super::Result<T::Outp...
  function drop_join_handle_slow (line 287) | pub(super) fn drop_join_handle_slow(self) {
  function complete (line 331) | fn complete(self) {
  function release (line 392) | fn release(&self) -> usize {
  function get_new_task (line 413) | fn get_new_task(&self) -> Task<S> {
  function can_read_output (line 420) | fn can_read_output(header: &Header, trailer: &Trailer, waker: &Waker) ->...
  function set_join_waker (line 464) | fn set_join_waker(
  type PollFuture (line 492) | enum PollFuture {
  function cancel_task (line 500) | fn cancel_task<T: Future, S: Schedule>(core: &Core<T, S>) {
  function panic_result_to_join_error (line 509) | fn panic_result_to_join_error(
  function poll_future (line 521) | fn poll_future<T: Future, S: Schedule>(core: &Core<T, S>, cx: Context<'_...
  function panic_to_error (line 560) | fn panic_to_error<S: Schedule>(

FILE: tokio/src/runtime/task/id.rs
  type Id (line 32) | pub struct Id(pub(crate) NonZeroU64);
    method fmt (line 63) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method next (line 69) | pub(crate) fn next() -> Self {
    method as_u64 (line 88) | pub(crate) fn as_u64(&self) -> u64 {
  function id (line 45) | pub fn id() -> Id {
  function try_id (line 58) | pub fn try_id() -> Option<Id> {

FILE: tokio/src/runtime/task/join.rs
  function new (line 176) | pub(super) fn new(raw: RawTask) -> JoinHandle<T> {
  function abort (line 227) | pub fn abort(&self) {
  function is_finished (line 258) | pub fn is_finished(&self) -> bool {
  function set_join_waker (line 264) | pub(crate) fn set_join_waker(&mut self, waker: &Waker) {
  function abort_handle (line 307) | pub fn abort_handle(&self) -> AbortHandle {
  function id (line 316) | pub fn id(&self) -> super::Id {
  type Output (line 325) | type Output = super::Result<T>;
  method poll (line 327) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method drop (line 358) | fn drop(&mut self) {
  function fmt (line 371) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/task/list.rs
  type OwnedTasks (line 58) | pub(crate) struct OwnedTasks<S: 'static> {
  type List (line 64) | type List<S> = sharded_list::ShardedList<Task<S>, <Task<S> as Link>::Tar...
  type LocalOwnedTasks (line 66) | pub(crate) struct LocalOwnedTasks<S: 'static> {
  type OwnedTasksInner (line 72) | struct OwnedTasksInner<S: 'static> {
  function new (line 78) | pub(crate) fn new(num_cores: usize) -> Self {
  function bind (line 89) | pub(crate) fn bind<T>(
  function bind_local (line 111) | pub(crate) unsafe fn bind_local<T>(
  function bind_inner (line 129) | unsafe fn bind_inner(&self, task: Task<S>, notified: Notified<S>) -> Opt...
  function assert_owner (line 154) | pub(crate) fn assert_owner(&self, task: Notified<S>) -> LocalNotified<S> {
  function close_and_shutdown_all (line 169) | pub(crate) fn close_and_shutdown_all(&self, start: usize)
  function get_shard_size (line 188) | pub(crate) fn get_shard_size(&self) -> usize {
  function num_alive_tasks (line 192) | pub(crate) fn num_alive_tasks(&self) -> usize {
  function remove (line 204) | pub(crate) fn remove(&self, task: &Task<S>) -> Option<Task<S>> {
  function is_empty (line 216) | pub(crate) fn is_empty(&self) -> bool {
  function gen_shared_list_size (line 231) | fn gen_shared_list_size(num_cores: usize) -> usize {
  function new (line 250) | pub(crate) fn new() -> Self {
  function bind (line 261) | pub(crate) fn bind<T>(
  function close_and_shutdown_all (line 295) | pub(crate) fn close_and_shutdown_all(&self)
  function remove (line 306) | pub(crate) fn remove(&self, task: &Task<S>) -> Option<Task<S>> {
  function assert_owner (line 322) | pub(crate) fn assert_owner(&self, task: Notified<S>) -> LocalNotified<S> {
  function with_inner (line 335) | fn with_inner<F, T>(&self, f: F) -> T
  function is_closed (line 345) | pub(crate) fn is_closed(&self) -> bool {
  function is_empty (line 349) | pub(crate) fn is_empty(&self) -> bool {
  function test_id_not_broken (line 361) | fn test_id_not_broken() {

FILE: tokio/src/runtime/task/mod.rs
  type Task (line 232) | pub(crate) struct Task<S: 'static> {
  type Notified (line 242) | pub(crate) struct Notified<S: 'static>(Task<S>);
  function task_meta (line 247) | pub(crate) fn task_meta<'meta>(&self) -> crate::runtime::TaskMeta<'meta> {
  type LocalNotified (line 260) | pub(crate) struct LocalNotified<S: 'static> {
  function task_meta (line 268) | pub(crate) fn task_meta<'meta>(&self) -> crate::runtime::TaskMeta<'meta> {
  type UnownedTask (line 275) | pub(crate) struct UnownedTask<S: 'static> {
  type Result (line 285) | pub(crate) type Result<T> = std::result::Result<T, JoinError>;
  type TaskHarnessScheduleHooks (line 289) | pub(crate) struct TaskHarnessScheduleHooks {
  type Schedule (line 293) | pub(crate) trait Schedule: Sync + Sized + 'static {
    method release (line 299) | fn release(&self, task: &Task<Self>) -> Option<Task<Self>>;
    method schedule (line 302) | fn schedule(&self, task: Notified<Self>);
    method hooks (line 304) | fn hooks(&self) -> TaskHarnessScheduleHooks;
    method yield_now (line 308) | fn yield_now(&self, task: Notified<Self>) {
    method unhandled_panic (line 313) | fn unhandled_panic(&self) {
  function new (line 389) | unsafe fn new(raw: RawTask) -> Task<S> {
  function from_raw (line 399) | unsafe fn from_raw(ptr: NonNull<Header>) -> Task<S> {
  function as_raw (line 410) | pub(super) fn as_raw(&self) -> RawTask {
  function header (line 414) | fn header(&self) -> &Header {
  function header_ptr (line 418) | fn header_ptr(&self) -> NonNull<Header> {
  function id (line 427) | pub(crate) fn id(&self) -> crate::task::Id {
  function spawned_at (line 433) | pub(crate) fn spawned_at(&self) -> &'static Location<'static> {
  function task_meta (line 442) | pub(crate) fn task_meta<'meta>(&self) -> crate::runtime::TaskMeta<'meta> {
  function header (line 468) | fn header(&self) -> &Header {
  function task_id (line 474) | pub(crate) fn task_id(&self) -> crate::task::Id {
  function from_raw (line 483) | pub(crate) unsafe fn from_raw(ptr: RawTask) -> Notified<S> {
  function into_raw (line 489) | pub(crate) fn into_raw(self) -> RawTask {
  function shutdown (line 498) | pub(crate) fn shutdown(self) {
  function run (line 507) | pub(crate) fn run(self) {
  function into_notified (line 518) | pub(super) fn into_notified(self) -> Notified<S> {
  function into_task (line 522) | fn into_task(self) -> Task<S> {
  function run (line 536) | pub(crate) fn run(self) {
  function shutdown (line 552) | pub(crate) fn shutdown(self) {
  method drop (line 558) | fn drop(&mut self) {
  method drop (line 568) | fn drop(&mut self) {
  function fmt (line 578) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 584) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Handle (line 593) | type Handle = Task<S>;
  type Target (line 594) | type Target = Header;
  function as_raw (line 596) | fn as_raw(handle: &Task<S>) -> NonNull<Header> {
  function from_raw (line 600) | unsafe fn from_raw(ptr: NonNull<Header>) -> Task<S> {
  function pointers (line 604) | unsafe fn pointers(target: NonNull<Header>) -> NonNull<linked_list::Poin...
  function get_shard_id (line 615) | unsafe fn get_shard_id(target: NonNull<Self::Target>) -> usize {
  type SpawnLocation (line 630) | pub(crate) struct SpawnLocation(pub &'static Location<'static>);
    method from (line 633) | fn from(location: &'static Location<'static>) -> Self {
    method from (line 647) | fn from(_: &'static Location<'static>) -> Self {
    method capture (line 662) | pub(crate) fn capture() -> Self {
  type SpawnLocation (line 644) | pub(crate) struct SpawnLocation();
    method from (line 633) | fn from(location: &'static Location<'static>) -> Self {
    method from (line 647) | fn from(_: &'static Location<'static>) -> Self {
    method capture (line 662) | pub(crate) fn capture() -> Self {
  function spawn_location_is_zero_sized (line 654) | fn spawn_location_is_zero_sized() {

FILE: tokio/src/runtime/task/raw.rs
  type RawTask (line 20) | pub(crate) struct RawTask {
    method new (line 211) | pub(super) fn new<T, S>(
    method from_raw (line 237) | pub(super) unsafe fn from_raw(ptr: NonNull<Header>) -> RawTask {
    method header_ptr (line 241) | pub(super) fn header_ptr(&self) -> NonNull<Header> {
    method trailer_ptr (line 245) | pub(super) fn trailer_ptr(&self) -> NonNull<Trailer> {
    method header (line 250) | pub(super) fn header(&self) -> &Header {
    method trailer (line 255) | pub(super) fn trailer(&self) -> &Trailer {
    method state (line 260) | pub(super) fn state(&self) -> &State {
    method poll (line 265) | pub(crate) fn poll(self) {
    method schedule (line 270) | pub(super) fn schedule(self) {
    method dealloc (line 275) | pub(super) fn dealloc(self) {
    method try_read_output (line 284) | pub(super) unsafe fn try_read_output<O>(self, dst: *mut Poll<super::Re...
    method drop_join_handle_slow (line 289) | pub(super) fn drop_join_handle_slow(self) {
    method drop_abort_handle (line 294) | pub(super) fn drop_abort_handle(self) {
    method shutdown (line 299) | pub(super) fn shutdown(self) {
    method ref_inc (line 307) | pub(super) fn ref_inc(self) {
    method get_queue_next (line 316) | pub(crate) unsafe fn get_queue_next(self) -> Option<RawTask> {
    method set_queue_next (line 328) | pub(crate) unsafe fn set_queue_next(self, val: Option<RawTask>) {
  type Vtable (line 24) | pub(super) struct Vtable {
  function vtable (line 61) | pub(super) fn vtable<T: Future, S: Schedule>() -> &'static Vtable {
  type OffsetHelper (line 83) | struct OffsetHelper<T, S>(T, S);
  constant TRAILER_OFFSET (line 88) | const TRAILER_OFFSET: usize = get_trailer_offset(
  constant SCHEDULER_OFFSET (line 97) | const SCHEDULER_OFFSET: usize = get_core_offset(
  constant ID_OFFSET (line 102) | const ID_OFFSET: usize = get_id_offset(
  constant SPAWN_LOCATION_OFFSET (line 110) | const SPAWN_LOCATION_OFFSET: usize = get_spawn_location_offset(
  function get_trailer_offset (line 125) | const fn get_trailer_offset(
  function get_core_offset (line 152) | const fn get_core_offset(header_size: usize, core_align: usize) -> usize {
  function get_id_offset (line 168) | const fn get_id_offset(
  function get_spawn_location_offset (line 191) | const fn get_spawn_location_offset(
  function poll (line 335) | unsafe fn poll<T: Future, S: Schedule>(ptr: NonNull<Header>) {
  function schedule (line 340) | unsafe fn schedule<S: Schedule>(ptr: NonNull<Header>) {
  function dealloc (line 349) | unsafe fn dealloc<T: Future, S: Schedule>(ptr: NonNull<Header>) {
  function try_read_output (line 354) | unsafe fn try_read_output<T: Future, S: Schedule>(
  function drop_join_handle_slow (line 365) | unsafe fn drop_join_handle_slow<T: Future, S: Schedule>(ptr: NonNull<Hea...
  function drop_abort_handle (line 370) | unsafe fn drop_abort_handle<T: Future, S: Schedule>(ptr: NonNull<Header>) {
  function shutdown (line 375) | unsafe fn shutdown<T: Future, S: Schedule>(ptr: NonNull<Header>) {

FILE: tokio/src/runtime/task/state.rs
  type State (line 6) | pub(super) struct State {
    method new (line 102) | pub(super) fn new() -> State {
    method load (line 111) | pub(super) fn load(&self) -> Snapshot {
    method transition_to_running (line 117) | pub(super) fn transition_to_running(&self) -> TransitionToRunning {
    method transition_to_idle (line 151) | pub(super) fn transition_to_idle(&self) -> TransitionToIdle {
    method transition_to_complete (line 184) | pub(super) fn transition_to_complete(&self) -> Snapshot {
    method transition_to_terminal (line 198) | pub(super) fn transition_to_terminal(&self, count: usize) -> bool {
    method transition_to_notified_by_val (line 215) | pub(super) fn transition_to_notified_by_val(&self) -> TransitionToNoti...
    method transition_to_notified_by_ref (line 253) | pub(super) fn transition_to_notified_by_ref(&self) -> TransitionToNoti...
    method transition_to_notified_for_tracing (line 292) | pub(super) fn transition_to_notified_for_tracing(&self) -> bool {
    method transition_to_notified_and_cancel (line 308) | pub(super) fn transition_to_notified_and_cancel(&self) -> bool {
    method transition_to_shutdown (line 343) | pub(super) fn transition_to_shutdown(&self) -> bool {
    method drop_join_handle_fast (line 365) | pub(super) fn drop_join_handle_fast(&self) -> Result<(), ()> {
    method transition_to_join_handle_dropped (line 390) | pub(super) fn transition_to_join_handle_dropped(&self) -> TransitionTo...
    method set_join_waker (line 432) | pub(super) fn set_join_waker(&self) -> UpdateResult {
    method unset_waker (line 452) | pub(super) fn unset_waker(&self) -> UpdateResult {
    method unset_waker_after_complete (line 474) | pub(super) fn unset_waker_after_complete(&self) -> Snapshot {
    method ref_inc (line 481) | pub(super) fn ref_inc(&self) {
    method ref_dec (line 505) | pub(super) fn ref_dec(&self) -> bool {
    method ref_dec_twice (line 512) | pub(super) fn ref_dec_twice(&self) -> bool {
    method fetch_update_action (line 518) | fn fetch_update_action<F, T>(&self, mut f: F) -> T
    method fetch_update (line 540) | fn fetch_update<F>(&self, mut f: F) -> Result<Snapshot, Snapshot>
    method fmt (line 644) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Snapshot (line 12) | pub(super) struct Snapshot(usize);
    method is_idle (line 566) | pub(super) fn is_idle(self) -> bool {
    method is_notified (line 571) | pub(super) fn is_notified(self) -> bool {
    method unset_notified (line 575) | fn unset_notified(&mut self) {
    method set_notified (line 579) | fn set_notified(&mut self) {
    method is_running (line 583) | pub(super) fn is_running(self) -> bool {
    method set_running (line 587) | fn set_running(&mut self) {
    method unset_running (line 591) | fn unset_running(&mut self) {
    method is_cancelled (line 595) | pub(super) fn is_cancelled(self) -> bool {
    method set_cancelled (line 599) | fn set_cancelled(&mut self) {
    method is_complete (line 604) | pub(super) fn is_complete(self) -> bool {
    method is_join_interested (line 608) | pub(super) fn is_join_interested(self) -> bool {
    method unset_join_interested (line 612) | fn unset_join_interested(&mut self) {
    method is_join_waker_set (line 616) | pub(super) fn is_join_waker_set(self) -> bool {
    method set_join_waker (line 620) | fn set_join_waker(&mut self) {
    method unset_join_waker (line 624) | fn unset_join_waker(&mut self) {
    method ref_count (line 628) | pub(super) fn ref_count(self) -> usize {
    method ref_inc (line 632) | fn ref_inc(&mut self) {
    method ref_dec (line 637) | pub(super) fn ref_dec(&mut self) {
    method fmt (line 651) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type UpdateResult (line 14) | type UpdateResult = Result<Snapshot, Snapshot>;
  constant RUNNING (line 17) | const RUNNING: usize = 0b0001;
  constant COMPLETE (line 22) | const COMPLETE: usize = 0b0010;
  constant LIFECYCLE_MASK (line 25) | const LIFECYCLE_MASK: usize = 0b11;
  constant NOTIFIED (line 28) | const NOTIFIED: usize = 0b100;
  constant JOIN_INTEREST (line 31) | const JOIN_INTEREST: usize = 0b1_000;
  constant JOIN_WAKER (line 34) | const JOIN_WAKER: usize = 0b10_000;
  constant CANCELLED (line 37) | const CANCELLED: usize = 0b100_000;
  constant STATE_MASK (line 40) | const STATE_MASK: usize = LIFECYCLE_MASK | NOTIFIED | JOIN_INTEREST | JO...
  constant REF_COUNT_MASK (line 43) | const REF_COUNT_MASK: usize = !STATE_MASK;
  constant REF_COUNT_SHIFT (line 46) | const REF_COUNT_SHIFT: usize = REF_COUNT_MASK.count_zeros() as usize;
  constant REF_ONE (line 49) | const REF_ONE: usize = 1 << REF_COUNT_SHIFT;
  constant INITIAL_STATE (line 61) | const INITIAL_STATE: usize = (REF_ONE * 3) | JOIN_INTEREST | NOTIFIED;
  type TransitionToRunning (line 64) | pub(super) enum TransitionToRunning {
  type TransitionToIdle (line 72) | pub(super) enum TransitionToIdle {
  type TransitionToNotifiedByVal (line 80) | pub(super) enum TransitionToNotifiedByVal {
  type TransitionToNotifiedByRef (line 87) | pub(crate) enum TransitionToNotifiedByRef {
  type TransitionToJoinHandleDrop (line 93) | pub(super) struct TransitionToJoinHandleDrop {

FILE: tokio/src/runtime/task/trace/mod.rs
  type Backtrace (line 24) | type Backtrace = Vec<BacktraceFrame>;
  type SymbolTrace (line 25) | type SymbolTrace = Vec<Symbol>;
  type Context (line 28) | pub(crate) struct Context {
    method new (line 72) | pub(crate) const fn new() -> Self {
    method try_with_current (line 81) | unsafe fn try_with_current<F, R>(f: F) -> Option<R>
    method with_current_frame (line 90) | unsafe fn with_current_frame<F, R>(f: F) -> R
    method with_current_collector (line 99) | fn with_current_collector<F, R>(f: F) -> R
    method is_tracing (line 111) | pub(crate) fn is_tracing() -> bool {
  type Frame (line 37) | struct Frame {
  type Trace (line 50) | pub(crate) struct Trace {
    method capture (line 125) | pub(crate) fn capture<F, R>(f: F) -> (R, Trace)
    method root (line 143) | pub(crate) fn root<F>(future: F) -> Root<F> {
    method backtraces (line 147) | pub(crate) fn backtraces(&self) -> &[Backtrace] {
    method fmt (line 220) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant FAIL_NO_THREAD_LOCAL (line 66) | const FAIL_NO_THREAD_LOCAL: &str = "The Tokio thread-local has been dest...
  function trace_leaf (line 162) | pub(crate) fn trace_leaf(cx: &mut task::Context<'_>) -> Poll<()> {
  function defer (line 225) | fn defer<F: FnOnce() -> R, R>(f: F) -> impl Drop {
  type Output (line 243) | type Output = T::Output;
  method poll (line 246) | fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::...
  function trace_current_thread (line 273) | pub(in crate::runtime) fn trace_current_thread(
  function trace_owned (line 339) | fn trace_owned<S: Schedule>(owned: &OwnedTasks<S>, dequeued: Vec<Notifie...

FILE: tokio/src/runtime/task/trace/symbol.rs
  type Symbol (line 19) | pub(super) struct Symbol {
    method fmt (line 66) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method hash (line 25) | fn hash<H>(&self, state: &mut H)
  method eq (line 45) | fn eq(&self, other: &Self) -> bool {

FILE: tokio/src/runtime/task/trace/tree.rs
  type Tree (line 11) | pub(super) struct Tree {
    method from_trace (line 23) | pub(super) fn from_trace(trace: Trace) -> Self {
    method consequences (line 47) | fn consequences(&self, frame: &Symbol) -> Option<impl ExactSizeIterato...
    method display (line 52) | fn display<W: fmt::Write>(
    method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function to_symboltrace (line 103) | fn to_symboltrace(backtrace: Backtrace) -> SymbolTrace {

FILE: tokio/src/runtime/task/waker.rs
  type WakerRef (line 9) | pub(super) struct WakerRef<'a, S: 'static> {
  function waker_ref (line 16) | pub(super) fn waker_ref<S>(header: &NonNull<Header>) -> WakerRef<'_, S>
  type Target (line 37) | type Target = Waker;
  function deref (line 39) | fn deref(&self) -> &Waker {
  function clone_waker (line 70) | unsafe fn clone_waker(ptr: *const ()) -> RawWaker {
  function drop_waker (line 81) | unsafe fn drop_waker(ptr: *const ()) {
  function wake_by_val (line 93) | unsafe fn wake_by_val(ptr: *const ()) {
  function wake_by_ref (line 106) | unsafe fn wake_by_ref(ptr: *const ()) {
  function raw_waker (line 121) | fn raw_waker(header: NonNull<Header>) -> RawWaker {

FILE: tokio/src/runtime/task_hooks.rs
  type TaskHooks (line 41) | pub(crate) struct TaskHooks {
    method spawn (line 5) | pub(crate) fn spawn(&self, meta: &TaskMeta<'_>) {
    method from_config (line 12) | pub(crate) fn from_config(config: &Config) -> Self {
    method poll_start_callback (line 25) | pub(crate) fn poll_start_callback(&self, meta: &TaskMeta<'_>) {
    method poll_stop_callback (line 33) | pub(crate) fn poll_stop_callback(&self, meta: &TaskMeta<'_>) {
  type TaskMeta (line 59) | pub struct TaskMeta<'a> {
  function id (line 71) | pub fn id(&self) -> super::task::Id {
  function spawned_at (line 77) | pub fn spawned_at(&self) -> &'static std::panic::Location<'static> {
  type TaskCallback (line 83) | pub(crate) type TaskCallback = std::sync::Arc<dyn Fn(&TaskMeta<'_>) + Se...

FILE: tokio/src/runtime/tests/inject.rs
  function push_and_pop (line 4) | fn push_and_pop() {
  function push_batch_and_pop (line 26) | fn push_batch_and_pop() {
  function pop_n_drains_on_drop (line 42) | fn pop_n_drains_on_drop() {

FILE: tokio/src/runtime/tests/loom_blocking.rs
  function blocking_shutdown (line 7) | fn blocking_shutdown() {
  function spawn_mandatory_blocking_should_always_run (line 28) | fn spawn_mandatory_blocking_should_always_run() {
  function spawn_mandatory_blocking_should_run_even_when_shutting_down_from_other_thread (line 49) | fn spawn_mandatory_blocking_should_run_even_when_shutting_down_from_othe...
  function spawn_blocking_when_paused (line 78) | fn spawn_blocking_when_paused() {
  function spawn_blocking_then_shutdown (line 99) | fn spawn_blocking_then_shutdown() {
  function mk_runtime (line 135) | fn mk_runtime(num_threads: usize) -> Runtime {

FILE: tokio/src/runtime/tests/loom_current_thread.rs
  function assert_at_most_num_polls (line 14) | fn assert_at_most_num_polls(rt: Arc<Runtime>, at_most_polls: usize) {
  function block_on_num_polls (line 37) | fn block_on_num_polls() {
  function assert_no_unnecessary_polls (line 71) | fn assert_no_unnecessary_polls() {
  function drop_jh_during_schedule (line 110) | fn drop_jh_during_schedule() {
  type BlockedFuture (line 163) | struct BlockedFuture {
  type Output (line 169) | type Output = ();
  method poll (line 171) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type ResetFuture (line 181) | struct ResetFuture {
  type Output (line 187) | type Output = ();
  method poll (line 189) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: tokio/src/runtime/tests/loom_current_thread/yield_now.rs
  function yield_calls_park_before_scheduling_again (line 5) | fn yield_calls_park_before_scheduling_again() {
  function mk_runtime (line 28) | fn mk_runtime() -> Runtime {

FILE: tokio/src/runtime/tests/loom_join_set.rs
  function test_join_set (line 5) | fn test_join_set() {
  function abort_all_during_completion (line 37) | fn abort_all_during_completion() {

FILE: tokio/src/runtime/tests/loom_local.rs
  function wake_during_shutdown (line 16) | fn wake_during_shutdown() {

FILE: tokio/src/runtime/tests/loom_multi_thread.rs
  type AtomicTake (line 30) | pub(super) struct AtomicTake<T> {
  function new (line 36) | pub(super) fn new(value: T) -> Self {
  function take (line 43) | pub(super) fn take(&self) -> Option<T> {
  method drop (line 54) | fn drop(&mut self) {
  type AtomicOneshot (line 61) | struct AtomicOneshot<T> {
  function new (line 65) | fn new(sender: oneshot::Sender<T>) -> Self {
  function assert_send (line 71) | fn assert_send(&self, value: T) {
  function racy_shutdown (line 81) | fn racy_shutdown() {
  function pool_multi_spawn (line 103) | fn pool_multi_spawn() {
  function only_blocking_inner (line 135) | fn only_blocking_inner(first_pending: bool) {
  function only_blocking_without_pending (line 155) | fn only_blocking_without_pending() {
  function only_blocking_with_pending (line 160) | fn only_blocking_with_pending() {
  function blocking_and_regular_inner (line 168) | fn blocking_and_regular_inner(first_pending: bool) {
  function blocking_and_regular (line 206) | fn blocking_and_regular() {
  function blocking_and_regular_with_pending (line 211) | fn blocking_and_regular_with_pending() {
  function join_output (line 216) | fn join_output() {
  function poll_drop_handle_then_drop (line 230) | fn poll_drop_handle_then_drop() {
  function complete_block_on_under_load (line 247) | fn complete_block_on_under_load() {
  function shutdown_with_notification (line 265) | fn shutdown_with_notification() {
  function pool_shutdown (line 295) | fn pool_shutdown() {
  function pool_multi_notify (line 316) | fn pool_multi_notify() {
  function mk_pool (line 350) | fn mk_pool(num_threads: usize) -> Runtime {
  function gated2 (line 359) | fn gated2(thread: bool) -> impl Future<Output = &'static str> {
  function multi_gated (line 396) | async fn multi_gated() {
  function track (line 428) | fn track<T: Future>(f: T) -> Track<T> {
  function into_inner (line 445) | fn into_inner(self) -> T {
  type Output (line 451) | type Output = Track<T::Output>;
  method poll (line 453) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tokio/src/runtime/tests/loom_multi_thread/queue.rs
  function new_stats (line 7) | fn new_stats() -> Stats {
  function basic (line 12) | fn basic() {
  function steal_overflow (line 66) | fn steal_overflow() {
  function multi_stealer (line 116) | fn multi_stealer() {
  function chained_steal (line 170) | fn chained_steal() {

FILE: tokio/src/runtime/tests/loom_multi_thread/shutdown.rs
  function join_handle_cancel_on_shutdown (line 4) | fn join_handle_cancel_on_shutdown() {

FILE: tokio/src/runtime/tests/loom_multi_thread/yield_now.rs
  function yield_calls_park_before_scheduling_again (line 6) | fn yield_calls_park_before_scheduling_again() {
  function mk_runtime (line 32) | fn mk_runtime(num_threads: usize) -> Runtime {

FILE: tokio/src/runtime/tests/loom_oneshot.rs
  function channel (line 4) | pub(crate) fn channel<T>() -> (Sender<T>, Receiver<T>) {
  type Sender (line 18) | pub(crate) struct Sender<T> {
  type Receiver (line 22) | pub(crate) struct Receiver<T> {
  type Inner (line 26) | struct Inner<T> {
  function send (line 32) | pub(crate) fn send(self, value: T) {
  function recv (line 39) | pub(crate) fn recv(self) -> T {

FILE: tokio/src/runtime/tests/mod.rs
  type NoopSchedule (line 12) | pub(crate) struct NoopSchedule;
    method release (line 15) | fn release(&self, _task: &Task<Self>) -> Option<Task<Self>> {
    method schedule (line 19) | fn schedule(&self, _task: task::Notified<Self>) {
    method hooks (line 23) | fn hooks(&self) -> TaskHarnessScheduleHooks {
  function unowned (line 37) | pub(crate) fn unowned<T>(task: T) -> (Notified<NoopSchedule>, JoinHandle...
  function unowned (line 52) | pub(crate) fn unowned<T>(task: T) -> (Notified<NoopSchedule>, JoinHandle...

FILE: tokio/src/runtime/tests/queue.rs
  function new_stats (line 26) | fn new_stats() -> Stats {
  function fits_256_one_at_a_time (line 32) | fn fits_256_one_at_a_time() {
  function fits_256_all_at_once (line 52) | fn fits_256_all_at_once() {
  function fits_256_all_in_chunks (line 69) | fn fits_256_all_in_chunks() {
  function overflow (line 90) | fn overflow() {
  function steal_batch (line 116) | fn steal_batch() {
  function normal_or_miri (line 147) | const fn normal_or_miri(normal: usize, miri: usize) -> usize {
  function stress1 (line 156) | fn stress1() {
  function stress2 (line 219) | fn stress2() {

FILE: tokio/src/runtime/tests/task.rs
  type AssertDropHandle (line 14) | struct AssertDropHandle {
    method assert_dropped (line 19) | fn assert_dropped(&self) {
    method assert_not_dropped (line 24) | fn assert_not_dropped(&self) {
  type AssertDrop (line 29) | struct AssertDrop {
    method new (line 33) | fn new() -> (Self, AssertDropHandle) {
  method drop (line 46) | fn drop(&mut self) {
  function create_drop1 (line 54) | fn create_drop1() {
  function create_drop2 (line 72) | fn create_drop2() {
  function drop_abort_handle1 (line 90) | fn drop_abort_handle1() {
  function drop_abort_handle2 (line 111) | fn drop_abort_handle2() {
  function drop_abort_handle_clone (line 132) | fn drop_abort_handle_clone() {
  function create_shutdown1 (line 157) | fn create_shutdown1() {
  function create_shutdown2 (line 175) | fn create_shutdown2() {
  function unowned_poll (line 193) | fn unowned_poll() {
  function schedule (line 199) | fn schedule() {
  function shutdown (line 211) | fn shutdown() {
  function shutdown_immediately (line 226) | fn shutdown_immediately() {
  function spawn_niche_in_task (line 240) | fn spawn_niche_in_task() {
  function spawn_during_shutdown (line 333) | fn spawn_during_shutdown() {
  function with (line 361) | fn with(f: impl FnOnce(Runtime)) {
  type Runtime (line 384) | struct Runtime(Arc<Inner>);
    method spawn (line 399) | fn spawn<T>(&self, future: T) -> JoinHandle<T::Output>
    method tick (line 416) | fn tick(&self) -> usize {
    method tick_max (line 420) | fn tick_max(&self, max: usize) -> usize {
    method is_empty (line 433) | fn is_empty(&self) -> bool {
    method next_task (line 437) | fn next_task(&self) -> task::Notified<Runtime> {
    method shutdown (line 441) | fn shutdown(&self) {
  type Inner (line 386) | struct Inner {
  type Core (line 391) | struct Core {
  method release (line 456) | fn release(&self, task: &Task<Self>) -> Option<Task<Self>> {
  method schedule (line 460) | fn schedule(&self, task: task::Notified<Self>) {
  method hooks (line 464) | fn hooks(&self) -> TaskHarnessScheduleHooks {

FILE: tokio/src/runtime/tests/task_combinations.rs
  type CombiRuntime (line 17) | enum CombiRuntime {
  type CombiLocalSet (line 23) | enum CombiLocalSet {
  type CombiTask (line 28) | enum CombiTask {
  type CombiOutput (line 35) | enum CombiOutput {
  type CombiJoinInterest (line 40) | enum CombiJoinInterest {
  type CombiJoinHandle (line 46) | enum CombiJoinHandle {
  type CombiAbort (line 53) | enum CombiAbort {
  type CombiAbortSource (line 62) | enum CombiAbortSource {
  function test_combinations (line 69) | fn test_combinations() {
  function is_debug (line 154) | fn is_debug<T: fmt::Debug>(_: &T) {}
  function test_combination (line 157) | fn test_combination(

FILE: tokio/src/runtime/thread_id.rs
  type ThreadId (line 4) | pub(crate) struct ThreadId(NonZeroU64);
    method next (line 7) | pub(crate) fn next() -> Self {
  function exhausted (line 35) | fn exhausted() -> ! {

FILE: tokio/src/runtime/time/entry.rs
  type TimerResult (line 70) | type TimerResult = Result<(), crate::time::error::Error>;
  constant STATE_DEREGISTERED (line 72) | pub(in crate::runtime::time) const STATE_DEREGISTERED: u64 = u64::MAX;
  constant STATE_PENDING_FIRE (line 73) | const STATE_PENDING_FIRE: u64 = STATE_DEREGISTERED - 1;
  constant STATE_MIN_VALUE (line 74) | const STATE_MIN_VALUE: u64 = STATE_PENDING_FIRE;
  constant MAX_SAFE_MILLIS_DURATION (line 78) | pub(super) const MAX_SAFE_MILLIS_DURATION: u64 = STATE_MIN_VALUE - 1;
  type StateCell (line 91) | pub(super) struct StateCell {
    method fmt (line 111) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 117) | fn new() -> Self {
    method is_pending (line 125) | fn is_pending(&self) -> bool {
    method when (line 130) | fn when(&self) -> Option<u64> {
    method poll (line 142) | fn poll(&self, waker: &Waker) -> Poll<TimerResult> {
    method read_state (line 151) | fn read_state(&self) -> Poll<TimerResult> {
    method mark_pending (line 171) | unsafe fn mark_pending(&self, not_after: u64) -> Result<(), u64> {
    method fire (line 211) | unsafe fn fire(&self, result: TimerResult) -> Option<Waker> {
    method set_expiration (line 238) | fn set_expiration(&self, timestamp: u64) {
    method extend_expiration (line 252) | fn extend_expiration(&self, new_timestamp: u64) -> Result<(), ()> {
    method might_be_registered (line 275) | pub(super) fn might_be_registered(&self) -> bool {
  method default (line 105) | fn default() -> Self {
  type TimerHandle (line 326) | pub(crate) struct TimerHandle {
    method registered_when (line 630) | pub(super) unsafe fn registered_when(&self) -> u64 {
    method sync_when (line 634) | pub(super) unsafe fn sync_when(&self) -> u64 {
    method is_pending (line 638) | pub(super) unsafe fn is_pending(&self) -> bool {
    method set_expiration (line 646) | pub(super) unsafe fn set_expiration(&self, tick: u64) {
    method mark_pending (line 661) | pub(super) unsafe fn mark_pending(&self, not_after: u64) -> Result<(),...
    method fire (line 690) | pub(super) unsafe fn fire(self, completed_state: TimerResult) -> Optio...
  type EntryList (line 330) | pub(super) type EntryList = crate::util::linked_list::LinkedList<TimerSh...
  type TimerShared (line 336) | pub(crate) struct TimerShared {
    method fmt (line 366) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 386) | pub(super) fn new() -> Self {
    method registered_when (line 396) | pub(super) fn registered_when(&self) -> u64 {
    method sync_when (line 406) | pub(super) unsafe fn sync_when(&self) -> u64 {
    method set_registered_when (line 418) | unsafe fn set_registered_when(&self, when: u64) {
    method true_when (line 423) | pub(super) fn true_when(&self) -> u64 {
    method set_expiration (line 432) | pub(super) unsafe fn set_expiration(&self, t: u64) {
    method extend_expiration (line 438) | pub(super) fn extend_expiration(&self, t: u64) -> Result<(), ()> {
    method handle (line 443) | pub(super) fn handle(&self) -> TimerHandle {
    method might_be_registered (line 453) | pub(super) fn might_be_registered(&self) -> bool {
    type Handle (line 459) | type Handle = TimerHandle;
    type Target (line 461) | type Target = TimerShared;
    method as_raw (line 463) | fn as_raw(handle: &Self::Handle) -> NonNull<Self::Target> {
    method from_raw (line 467) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
    method pointers (line 471) | unsafe fn pointers(
  method new (line 482) | pub(crate) fn new(handle: scheduler::Handle, deadline: Instant) -> Self {
  method inner (line 494) | fn inner(&self) -> Option<&TimerShared> {
  method init_inner (line 498) | fn init_inner(self: Pin<&mut Self>) {
  method deadline (line 505) | pub(crate) fn deadline(&self) -> Instant {
  method is_elapsed (line 509) | pub(crate) fn is_elapsed(&self) -> bool {
  method cancel (line 540) | pub(crate) fn cancel(self: Pin<&mut Self>) {
  method reset (line 571) | pub(crate) fn reset(mut self: Pin<&mut Self>, new_time: Instant, reregis...
  method poll_elapsed (line 598) | pub(crate) fn poll_elapsed(
  method driver (line 619) | pub(crate) fn driver(&self) -> &super::Handle {
  method clock (line 624) | pub(crate) fn clock(&self) -> &super::Clock {

FILE: tokio/src/runtime/time/handle.rs
  type Handle (line 5) | pub(crate) struct Handle {
    method time_source (line 12) | pub(crate) fn time_source(&self) -> &TimeSource {
    method is_shutdown (line 17) | pub(super) fn is_shutdown(&self) -> bool {
    method unpark (line 22) | pub(crate) fn unpark(&self) {
    method fmt (line 65) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/runtime/time/mod.rs
  type Driver (line 90) | pub(crate) struct Driver {
    method new (line 145) | pub(crate) fn new(park: IoStack, clock: &Clock) -> (Driver, Handle) {
    method new_alt (line 168) | pub(crate) fn new_alt(clock: &Clock) -> Handle {
    method park (line 181) | pub(crate) fn park(&mut self, handle: &driver::Handle) {
    method park_timeout (line 185) | pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duratio...
    method shutdown (line 189) | pub(crate) fn shutdown(&mut self, rt_handle: &driver::Handle) {
    method park_internal (line 213) | fn park_internal(&mut self, rt_handle: &driver::Handle, limit: Option<...
  type Inner (line 95) | enum Inner {
    method lock (line 468) | pub(super) fn lock(&self) -> crate::loom::sync::MutexGuard<'_, InnerSt...
    method is_shutdown (line 477) | pub(super) fn is_shutdown(&self) -> bool {
    method fmt (line 487) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InnerState (line 130) | struct InnerState {
  method process (line 290) | pub(self) fn process(&self, clock: &Clock) {
  method process_at_time (line 296) | pub(self) fn process_at_time(&self, mut now: u64) {
  method process_at_time_alt (line 340) | pub(crate) fn process_at_time_alt(
  method shutdown_alt (line 360) | pub(crate) fn shutdown_alt(&self, wheel: &mut time_alt::Wheel) {
  method clear_entry (line 380) | pub(self) unsafe fn clear_entry(&self, entry: NonNull<TimerShared>) {
  method reregister (line 398) | pub(self) unsafe fn reregister(

FILE: tokio/src/runtime/time/source.rs
  type TimeSource (line 6) | pub(crate) struct TimeSource {
    method new (line 11) | pub(crate) fn new(clock: &Clock) -> Self {
    method deadline_to_tick (line 17) | pub(crate) fn deadline_to_tick(&self, t: Instant) -> u64 {
    method instant_to_tick (line 22) | pub(crate) fn instant_to_tick(&self, t: Instant) -> u64 {
    method tick_to_duration (line 32) | pub(crate) fn tick_to_duration(&self, t: u64) -> Duration {
    method now (line 36) | pub(crate) fn now(&self, clock: &Clock) -> u64 {
    method start_time (line 42) | pub(super) fn start_time(&self) -> Instant {

FILE: tokio/src/runtime/time/tests/mod.rs
  function block_on (line 14) | fn block_on<T>(f: impl std::future::Future<Output = T>) -> T {
  function model (line 27) | fn model(f: impl Fn() + Send + Sync + 'static) {
  function rt (line 35) | fn rt(start_paused: bool) -> crate::runtime::Runtime {
  function single_timer (line 44) | fn single_timer() {
  function drop_timer (line 73) | fn drop_timer() {
  function change_waker (line 107) | fn change_waker() {
  function reset_future (line 140) | fn reset_future() {
  function normal_or_miri (line 192) | fn normal_or_miri<T>(normal: T, miri: T) -> T {
  function poll_process_levels (line 202) | fn poll_process_levels() {
  function poll_process_levels_targeted (line 237) | fn poll_process_levels_targeted() {
  function instant_to_tick_max (line 259) | fn instant_to_tick_max() {

FILE: tokio/src/runtime/time/wheel/level.rs
  type Level (line 6) | pub(crate) struct Level {
    method new (line 41) | pub(crate) fn new(level: usize) -> Level {
    method next_expiration (line 51) | pub(crate) fn next_expiration(&self, now: u64) -> Option<Expiration> {
    method next_occupied_slot (line 108) | fn next_occupied_slot(&self, now: u64) -> Option<usize> {
    method add_entry (line 122) | pub(crate) unsafe fn add_entry(&mut self, item: TimerHandle) {
    method remove_entry (line 130) | pub(crate) unsafe fn remove_entry(&mut self, item: NonNull<TimerShared...
    method take_slot (line 143) | pub(crate) fn take_slot(&mut self, slot: usize) -> EntryList {
    method fmt (line 151) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Expiration (line 24) | pub(crate) struct Expiration {
  constant LEVEL_MULT (line 38) | const LEVEL_MULT: usize = 64;
  function occupied_bit (line 158) | fn occupied_bit(slot: usize) -> u64 {
  function slot_range (line 162) | fn slot_range(level: usize) -> u64 {
  function level_range (line 166) | fn level_range(level: usize) -> u64 {
  function slot_for (line 171) | fn slot_for(duration: u64, level: usize) -> usize {
  function test_slot_for (line 180) | fn test_slot_for() {

FILE: tokio/src/runtime/time/wheel/mod.rs
  type Wheel (line 22) | pub(crate) struct Wheel {
    method new (line 52) | pub(crate) fn new() -> Wheel {
    method elapsed (line 62) | pub(crate) fn elapsed(&self) -> u64 {
    method insert (line 87) | pub(crate) unsafe fn insert(
    method remove (line 115) | pub(crate) unsafe fn remove(&mut self, item: NonNull<TimerShared>) {
    method poll_at (line 135) | pub(crate) fn poll_at(&self) -> Option<u64> {
    method poll (line 140) | pub(crate) fn poll(&mut self, now: u64) -> Option<TimerHandle> {
    method next_expiration (line 167) | fn next_expiration(&self) -> Option<Expiration> {
    method next_expiration_time (line 193) | pub(super) fn next_expiration_time(&self) -> Option<u64> {
    method no_expirations_before (line 198) | fn no_expirations_before(&self, start_level: usize, before: u64) -> bo...
    method process_expiration (line 216) | pub(crate) fn process_expiration(&mut self, expiration: &Expiration) {
    method set_elapsed (line 251) | fn set_elapsed(&mut self, when: u64) {
    method take_entries (line 265) | fn take_entries(&mut self, expiration: &Expiration) -> EntryList {
    method level_for (line 269) | fn level_for(&self, when: u64) -> usize {
  constant NUM_LEVELS (line 45) | const NUM_LEVELS: usize = 6;
  constant MAX_DURATION (line 48) | pub(super) const MAX_DURATION: u64 = (1 << (6 * NUM_LEVELS)) - 1;
  function level_for (line 274) | fn level_for(elapsed: u64, when: u64) -> usize {
  function test_level_for (line 297) | fn test_level_for() {

FILE: tokio/src/runtime/time_alt/cancellation_queue.rs
  type EntryList (line 5) | type EntryList = linked_list::LinkedList<CancellationQueueEntry, Entry>;
  type Inner (line 8) | struct Inner {
    method new (line 22) | fn new() -> Self {
    method push_front (line 33) | unsafe fn push_front(&mut self, hdl: EntryHandle) {
    method into_iter (line 37) | fn into_iter(self) -> impl Iterator<Item = EntryHandle> {
  method drop (line 13) | fn drop(&mut self) {
  type Sender (line 53) | pub(crate) struct Sender {
    method send (line 63) | pub(crate) unsafe fn send(&self, hdl: EntryHandle) {
  type Receiver (line 71) | pub(crate) struct Receiver {
    method recv_all (line 76) | pub(crate) fn recv_all(&mut self) -> impl Iterator<Item = EntryHandle> {
  function new (line 81) | pub(crate) fn new() -> (Sender, Receiver) {

FILE: tokio/src/runtime/time_alt/cancellation_queue/tests.rs
  constant NUM_ITEMS (line 6) | const NUM_ITEMS: usize = 16;
  constant NUM_ITEMS (line 9) | const NUM_ITEMS: usize = 64;
  function new_handle (line 11) | fn new_handle() -> EntryHandle {
  function model (line 15) | fn model<F: Fn() + Send + Sync + 'static>(f: F) {
  function single_thread (line 24) | fn single_thread() {
  function multi_thread (line 40) | fn multi_thread() {
  function drop_iter_should_not_leak_memory (line 84) | fn drop_iter_should_not_leak_memory() {

FILE: tokio/src/runtime/time_alt/context.rs
  type LocalContext (line 5) | pub(crate) struct LocalContext {
    method new (line 13) | pub(crate) fn new() -> Self {
  type TempLocalContext (line 24) | pub(crate) enum TempLocalContext<'a> {
  function new_running (line 36) | pub(crate) fn new_running(cx: &'a mut LocalContext) -> Self {
  function new_shutdown (line 44) | pub(crate) fn new_shutdown() -> Self {

FILE: tokio/src/runtime/time_alt/entry.rs
  type EntryList (line 9) | pub(super) type EntryList = linked_list::LinkedList<Entry, Entry>;
  type State (line 12) | struct State {
  type Entry (line 20) | pub(crate) struct Entry {
    type Handle (line 61) | type Handle = Handle;
    type Target (line 62) | type Target = Entry;
    method as_raw (line 64) | fn as_raw(hdl: &Self::Handle) -> NonNull<Self::Target> {
    method from_raw (line 68) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
    method pointers (line 74) | unsafe fn pointers(
  type RegistrationQueueEntry (line 88) | pub(super) struct RegistrationQueueEntry;
    type Handle (line 92) | type Handle = Handle;
    type Target (line 93) | type Target = Entry;
    method as_raw (line 95) | fn as_raw(hdl: &Self::Handle) -> NonNull<Self::Target> {
    method from_raw (line 99) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
    method pointers (line 105) | unsafe fn pointers(
  type CancellationQueueEntry (line 119) | pub(super) struct CancellationQueueEntry;
    type Handle (line 123) | type Handle = Handle;
    type Target (line 124) | type Target = Entry;
    method as_raw (line 126) | fn as_raw(hdl: &Self::Handle) -> NonNull<Self::Target> {
    method from_raw (line 130) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
    method pointers (line 136) | unsafe fn pointers(
  type WakeQueueEntry (line 150) | pub(super) struct WakeQueueEntry;
    type Handle (line 154) | type Handle = Handle;
    type Target (line 155) | type Target = Entry;
    method as_raw (line 157) | fn as_raw(hdl: &Self::Handle) -> NonNull<Self::Target> {
    method from_raw (line 161) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
    method pointers (line 167) | unsafe fn pointers(
  type Handle (line 177) | pub(crate) struct Handle {
    method new (line 189) | pub(crate) fn new(deadline: u64, waker: Waker) -> Self {
    method wake (line 209) | pub(crate) fn wake(&self) {
    method register_cancel_tx (line 222) | pub(crate) fn register_cancel_tx(&self, cancel_tx: Sender) {
    method register_waker (line 231) | pub(crate) fn register_waker(&self, waker: Waker) {
    method cancel (line 241) | pub(crate) fn cancel(&self) {
    method deadline (line 257) | pub(crate) fn deadline(&self) -> u64 {
    method is_woken_up (line 261) | pub(crate) fn is_woken_up(&self) -> bool {
    method is_cancelled (line 266) | pub(crate) fn is_cancelled(&self) -> bool {
    method inner_strong_count (line 273) | pub(crate) fn inner_strong_count(&self) -> usize {
  function from (line 182) | fn from(hdl: &Handle) -> Self {

FILE: tokio/src/runtime/time_alt/registration_queue.rs
  type EntryList (line 4) | type EntryList = linked_list::LinkedList<RegistrationQueueEntry, Entry>;
  type RegistrationQueue (line 8) | pub(crate) struct RegistrationQueue {
    method new (line 22) | pub(crate) fn new() -> Self {
    method push_front (line 33) | pub(crate) unsafe fn push_front(&mut self, hdl: EntryHandle) {
    method pop_front (line 37) | pub(crate) fn pop_front(&mut self) -> Option<EntryHandle> {
  method drop (line 13) | fn drop(&mut self) {

FILE: tokio/src/runtime/time_alt/registration_queue/tests.rs
  constant NUM_ITEMS (line 6) | const NUM_ITEMS: usize = 16;
  constant NUM_ITEMS (line 9) | const NUM_ITEMS: usize = 64;
  function new_handle (line 11) | fn new_handle() -> EntryHandle {
  function model (line 15) | fn model<F: Fn() + Send + Sync + 'static>(f: F) {
  function sanity (line 24) | fn sanity() {
  function drop_should_not_leak_memory (line 40) | fn drop_should_not_leak_memory() {

FILE: tokio/src/runtime/time_alt/tests.rs
  constant NUM_ITEMS (line 7) | const NUM_ITEMS: usize = 16;
  constant NUM_ITEMS (line 10) | const NUM_ITEMS: usize = 64;
  function new_handle (line 12) | fn new_handle() -> (EntryHandle, AwokenCount) {
  function model (line 17) | fn model<F: Fn() + Send + Sync + 'static>(f: F) {
  function wake_up_in_the_same_thread (line 26) | fn wake_up_in_the_same_thread() {
  function cancel_in_the_same_thread (line 56) | fn cancel_in_the_same_thread() {
  function wake_up_in_the_different_thread (line 91) | fn wake_up_in_the_different_thread() {
  function cancel_in_the_different_thread (line 127) | fn cancel_in_the_different_thread() {

FILE: tokio/src/runtime/time_alt/timer.rs
  type Timer (line 11) | pub(crate) struct Timer {
    method fmt (line 25) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 42) | pub(crate) fn new(sched_hdl: SchedulerHandle, deadline: Instant) -> Se...
    method deadline (line 52) | pub(crate) fn deadline(&self) -> Instant {
    method is_elapsed (line 56) | pub(crate) fn is_elapsed(&self) -> bool {
    method register (line 60) | fn register(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
    method poll_elapsed (line 96) | pub(crate) fn poll_elapsed(self: Pin<&mut Self>, cx: &mut Context<'_>)...
    method scheduler_handle (line 107) | pub(crate) fn scheduler_handle(&self) -> &SchedulerHandle {
    method driver (line 112) | pub(crate) fn driver(&self) -> &crate::runtime::time::Handle {
    method clock (line 117) | pub(crate) fn clock(&self) -> &crate::time::Clock {
  method drop (line 33) | fn drop(&mut self) {
  function with_current_temp_local_context (line 122) | fn with_current_temp_local_context<F, R>(hdl: &SchedulerHandle, f: F) -> R
  function push_from_remote (line 152) | fn push_from_remote(sched_hdl: &SchedulerHandle, entry_hdl: EntryHandle) {
  function deadline_to_tick (line 166) | fn deadline_to_tick(sched_hdl: &SchedulerHandle, deadline: Instant) -> u...

FILE: tokio/src/runtime/time_alt/wake_queue.rs
  type EntryList (line 4) | type EntryList = linked_list::LinkedList<WakeQueueEntry, Entry>;
  type WakeQueue (line 8) | pub(crate) struct WakeQueue {
    method new (line 22) | pub(crate) fn new() -> Self {
    method is_empty (line 28) | pub(crate) fn is_empty(&self) -> bool {
    method push_front (line 37) | pub(crate) unsafe fn push_front(&mut self, hdl: EntryHandle) {
    method wake_all (line 42) | pub(crate) fn wake_all(mut self) {
  method drop (line 13) | fn drop(&mut self) {

FILE: tokio/src/runtime/time_alt/wake_queue/tests.rs
  constant NUM_ITEMS (line 6) | const NUM_ITEMS: usize = 16;
  constant NUM_ITEMS (line 9) | const NUM_ITEMS: usize = 64;
  function new_handle (line 11) | fn new_handle() -> (EntryHandle, AwokenCount) {
  function model (line 16) | fn model<F: Fn() + Send + Sync + 'static>(f: F) {
  function sanity (line 25) | fn sanity() {
  function drop_should_not_leak_memory (line 44) | fn drop_should_not_leak_memory() {

FILE: tokio/src/runtime/time_alt/wheel/level.rs
  type Level (line 6) | pub(crate) struct Level {
    method new (line 41) | pub(crate) fn new(level: usize) -> Level {
    method next_expiration (line 51) | pub(crate) fn next_expiration(&self, now: u64) -> Option<Expiration> {
    method next_occupied_slot (line 108) | fn next_occupied_slot(&self, now: u64) -> Option<usize> {
    method add_entry (line 122) | pub(crate) unsafe fn add_entry(&mut self, hdl: EntryHandle) {
    method remove_entry (line 132) | pub(crate) unsafe fn remove_entry(&mut self, hdl: EntryHandle) {
    method take_slot (line 145) | pub(crate) fn take_slot(&mut self, slot: usize) -> EntryList {
    method fmt (line 153) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Expiration (line 24) | pub(crate) struct Expiration {
  constant LEVEL_MULT (line 38) | const LEVEL_MULT: usize = 64;
  function occupied_bit (line 160) | fn occupied_bit(slot: usize) -> u64 {
  function slot_range (line 164) | fn slot_range(level: usize) -> u64 {
  function level_range (line 168) | fn level_range(level: usize) -> u64 {
  function slot_for (line 173) | fn slot_for(duration: u64, level: usize) -> usize {
  function test_slot_for (line 182) | fn test_slot_for() {

FILE: tokio/src/runtime/time_alt/wheel/mod.rs
  type Wheel (line 16) | pub(crate) struct Wheel {
    method new (line 43) | pub(crate) fn new() -> Wheel {
    method elapsed (line 52) | pub(crate) fn elapsed(&self) -> u64 {
    method insert (line 67) | pub(crate) unsafe fn insert(&mut self, hdl: EntryHandle, cancel_tx: Se...
    method remove (line 95) | pub(crate) unsafe fn remove(&mut self, hdl: EntryHandle) {
    method take_expired (line 109) | pub(crate) fn take_expired(&mut self, now: u64, wake_queue: &mut WakeQ...
    method next_expiration (line 122) | fn next_expiration(&self) -> Option<Expiration> {
    method next_expiration_time (line 139) | pub(crate) fn next_expiration_time(&self) -> Option<u64> {
    method no_expirations_before (line 144) | fn no_expirations_before(&self, start_level: usize, before: u64) -> bo...
    method process_expiration (line 155) | pub(crate) fn process_expiration(
    method set_elapsed (line 192) | fn set_elapsed(&mut self, when: u64) {
    method take_entries (line 206) | fn take_entries(&mut self, expiration: &Expiration) -> EntryList {
    method level_for (line 210) | fn level_for(&self, when: u64) -> usize {
  constant NUM_LEVELS (line 36) | const NUM_LEVELS: usize = 6;
  constant MAX_DURATION (line 39) | pub(super) const MAX_DURATION: u64 = (1 << (6 * NUM_LEVELS)) - 1;
  function level_for (line 215) | fn level_for(elapsed: u64, when: u64) -> usize {
  function test_level_for (line 238) | fn test_level_for() {

FILE: tokio/src/signal/ctrl_c.rs
  function ctrl_c (line 59) | pub async fn ctrl_c() -> io::Result<()> {

FILE: tokio/src/signal/mod.rs
  type RxFuture (line 63) | struct RxFuture {
    method new (line 73) | fn new(rx: Receiver<()>) -> Self {
    method recv (line 79) | async fn recv(&mut self) {
    method poll_recv (line 84) | fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function make_future (line 67) | async fn make_future(mut rx: Receiver<()>) -> Receiver<()> {

FILE: tokio/src/signal/registry.rs
  type EventId (line 8) | pub(crate) type EventId = usize;
  type EventInfo (line 13) | pub(crate) struct EventInfo {
  method default (line 19) | fn default() -> Self {
  type Storage (line 30) | pub(crate) trait Storage {
    method event_info (line 32) | fn event_info(&self, id: EventId) -> Option<&EventInfo>;
    method for_each (line 35) | fn for_each<'a, F>(&'a self, f: F)
    method event_info (line 41) | fn event_info(&self, id: EventId) -> Option<&EventInfo> {
    method for_each (line 45) | fn for_each<'a, F>(&'a self, f: F)
  type Registry (line 58) | pub(crate) struct Registry<S> {
  function new (line 63) | fn new(storage: S) -> Self {
  function register_listener (line 70) | fn register_listener(&self, event_id: EventId) -> watch::Receiver<()> {
  function record_event (line 80) | fn record_event(&self, event_id: EventId) {
  function broadcast (line 89) | fn broadcast(&self) -> bool {
  type Globals (line 107) | pub(crate) struct Globals {
    type Target (line 113) | type Target = OsExtraData;
    method deref (line 115) | fn deref(&self) -> &Self::Target {
    method register_listener (line 122) | pub(crate) fn register_listener(&self, event_id: EventId) -> watch::Re...
    method record_event (line 128) | pub(crate) fn record_event(&self, event_id: EventId) {
    method broadcast (line 135) | pub(crate) fn broadcast(&self) -> bool {
    method storage (line 140) | pub(crate) fn storage(&self) -> &OsStorage {
  function globals_init (line 145) | fn globals_init() -> Globals
  function globals (line 156) | pub(crate) fn globals() -> &'static Globals
  function smoke (line 175) | fn smoke() {
  function register_panics_on_invalid_input (line 227) | fn register_panics_on_invalid_input() {
  function record_invalid_event_does_nothing (line 234) | fn record_invalid_event_does_nothing() {
  function broadcast_returns_if_at_least_one_event_fired (line 240) | fn broadcast_returns_if_at_least_one_event_fired() {
  function rt (line 259) | fn rt() -> Runtime {
  function collect (line 266) | async fn collect(mut rx: watch::Receiver<()>) -> Vec<()> {

FILE: tokio/src/signal/reusable_box.rs
  type ReusableBoxFuture (line 13) | pub(crate) struct ReusableBoxFuture<T> {
  function new (line 19) | pub(crate) fn new<F>(future: F) -> Self
  function set (line 37) | pub(crate) fn set<F>(&mut self, future: F)
  function try_set (line 51) | pub(crate) fn try_set<F>(&mut self, future: F) -> Result<(), F>
  function set_same_layout (line 79) | unsafe fn set_same_layout<F>(&mut self, future: F)
  function get_pin (line 110) | pub(crate) fn get_pin(&mut self) -> Pin<&mut (dyn Future<Output = T> + S...
  function poll (line 117) | pub(crate) fn poll(&mut self, cx: &mut Context<'_>) -> Poll<T> {
  type Output (line 123) | type Output = T;
  method poll (line 126) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
  method drop (line 143) | fn drop(&mut self) {
  function fmt (line 151) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_different_futures (line 166) | fn test_different_futures() {
  function test_different_sizes (line 187) | fn test_different_sizes() {
  type ZeroSizedFuture (line 205) | struct ZeroSizedFuture {}
  type Output (line 207) | type Output = u32;
  method poll (line 208) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<u32> {
  function test_zero_sized (line 214) | fn test_zero_sized() {

FILE: tokio/src/signal/unix.rs
  type OsStorage (line 21) | pub(crate) struct OsStorage([SignalInfo; 33]);
    method get (line 27) | fn get(&self, id: EventId) -> Option<&SignalInfo> {
  type OsStorage (line 24) | pub(crate) struct OsStorage(Box<[SignalInfo]>);
    method get (line 27) | fn get(&self, id: EventId) -> Option<&SignalInfo> {
  method default (line 33) | fn default() -> Self {
  method event_info (line 51) | fn event_info(&self, id: EventId) -> Option<&EventInfo> {
  method for_each (line 55) | fn for_each<'a, F>(&'a self, f: F)
  type OsExtraData (line 64) | pub(crate) struct OsExtraData {
  method default (line 70) | fn default() -> Self {
  type SignalKind (line 79) | pub struct SignalKind(libc::c_int);
    method from_raw (line 98) | pub const fn from_raw(signum: std::os::raw::c_int) -> Self {
    method as_raw_value (line 109) | pub const fn as_raw_value(&self) -> std::os::raw::c_int {
    method alarm (line 117) | pub const fn alarm() -> Self {
    method child (line 125) | pub const fn child() -> Self {
    method hangup (line 133) | pub const fn hangup() -> Self {
    method info (line 149) | pub const fn info() -> Self {
    method interrupt (line 157) | pub const fn interrupt() -> Self {
    method io (line 166) | pub const fn io() -> Self {
    method io (line 174) | pub const fn io() -> Self {
    method pipe (line 183) | pub const fn pipe() -> Self {
    method quit (line 192) | pub const fn quit() -> Self {
    method terminate (line 200) | pub const fn terminate() -> Self {
    method user_defined1 (line 208) | pub const fn user_defined1() -> Self {
    method user_defined2 (line 216) | pub const fn user_defined2() -> Self {
    method window_change (line 224) | pub const fn window_change() -> Self {
    method from (line 230) | fn from(signum: std::os::raw::c_int) -> Self {
  function from (line 236) | fn from(kind: SignalKind) -> Self {
  type SignalInfo (line 242) | pub(crate) struct SignalInfo {
  function action (line 255) | fn action(globals: &'static Globals, signal: libc::c_int) {
  function signal_enable (line 269) | fn signal_enable(signal: SignalKind, handle: &Handle) -> io::Result<()> {
  type Signal (line 370) | pub struct Signal {
    method recv (line 452) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 486) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  function signal (line 402) | pub fn signal(kind: SignalKind) -> io::Result<Signal> {
  function signal_with_handle (line 411) | pub(crate) fn signal_with_handle(
  type InternalStream (line 493) | pub(crate) trait InternalStream {
    method poll_recv (line 494) | fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>>;
    method poll_recv (line 499) | fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  function ctrl_c (line 504) | pub(crate) fn ctrl_c() -> io::Result<Signal> {
  function signal_enable_error_on_invalid_input (line 513) | fn signal_enable_error_on_invalid_input() {
  function signal_enable_error_on_forbidden_input (line 527) | fn signal_enable_error_on_forbidden_input() {
  function from_c_int (line 541) | fn from_c_int() {
  function into_c_int (line 546) | fn into_c_int() {

FILE: tokio/src/signal/windows.rs
  function ctrl_c (line 46) | pub fn ctrl_c() -> io::Result<CtrlC> {
  type CtrlC (line 65) | pub struct CtrlC {
    method recv (line 93) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 127) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  type CtrlBreak (line 145) | pub struct CtrlBreak {
    method recv (line 172) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 206) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  function ctrl_break (line 231) | pub fn ctrl_break() -> io::Result<CtrlBreak> {
  function ctrl_close (line 259) | pub fn ctrl_close() -> io::Result<CtrlClose> {
  type CtrlClose (line 274) | pub struct CtrlClose {
    method recv (line 301) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 335) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  function ctrl_shutdown (line 359) | pub fn ctrl_shutdown() -> io::Result<CtrlShutdown> {
  type CtrlShutdown (line 374) | pub struct CtrlShutdown {
    method recv (line 401) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 435) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
  function ctrl_logoff (line 459) | pub fn ctrl_logoff() -> io::Result<CtrlLogoff> {
  type CtrlLogoff (line 474) | pub struct CtrlLogoff {
    method recv (line 501) | pub async fn recv(&mut self) -> Option<()> {
    method poll_recv (line 535) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {

FILE: tokio/src/signal/windows/stub.rs
  function ctrl_break (line 7) | pub(super) fn ctrl_break() -> io::Result<RxFuture> {
  function ctrl_close (line 11) | pub(super) fn ctrl_close() -> io::Result<RxFuture> {
  function ctrl_c (line 15) | pub(super) fn ctrl_c() -> io::Result<RxFuture> {
  function ctrl_logoff (line 19) | pub(super) fn ctrl_logoff() -> io::Result<RxFuture> {
  function ctrl_shutdown (line 23) | pub(super) fn ctrl_shutdown() -> io::Result<RxFuture> {

FILE: tokio/src/signal/windows/sys.rs
  type EventInfo (line 10) | type EventInfo = watch::Sender<()>;
  function ctrl_break (line 12) | pub(super) fn ctrl_break() -> io::Result<RxFuture> {
  function ctrl_close (line 16) | pub(super) fn ctrl_close() -> io::Result<RxFuture> {
  function ctrl_c (line 20) | pub(super) fn ctrl_c() -> io::Result<RxFuture> {
  function ctrl_logoff (line 24) | pub(super) fn ctrl_logoff() -> io::Result<RxFuture> {
  function ctrl_shutdown (line 28) | pub(super) fn ctrl_shutdown() -> io::Result<RxFuture> {
  function new (line 32) | fn new(event_info: &EventInfo) -> io::Result<RxFuture> {
  function event_requires_infinite_sleep_in_handler (line 38) | fn event_requires_infinite_sleep_in_handler(signum: u32) -> bool {
  type Registry (line 52) | struct Registry {
    method event_info (line 61) | fn event_info(&self, signum: u32) -> Option<&EventInfo> {
  function registry (line 73) | fn registry() -> &'static Registry {
  function global_init (line 79) | fn global_init() -> io::Result<()> {
  function handler (line 98) | unsafe extern "system" fn handler(ty: u32) -> BOOL {
  function raise_event (line 126) | unsafe fn raise_event(signum: u32) {
  function ctrl_c (line 137) | fn ctrl_c() {
  function ctrl_break (line 156) | fn ctrl_break() {
  function ctrl_close (line 174) | fn ctrl_close() {
  function ctrl_shutdown (line 192) | fn ctrl_shutdown() {
  function ctrl_logoff (line 210) | fn ctrl_logoff() {
  function rt (line 227) | fn rt() -> Runtime {

FILE: tokio/src/sync/barrier.rs
  type Barrier (line 42) | pub struct Barrier {
    method new (line 63) | pub fn new(mut n: usize) -> Barrier {
    method wait (line 125) | pub async fn wait(&self) -> BarrierWaitResult {
    method wait_internal (line 139) | async fn wait_internal(&self) -> BarrierWaitResult {
  type BarrierState (line 51) | struct BarrierState {
  type BarrierWaitResult (line 203) | pub struct BarrierWaitResult(bool);
    method is_leader (line 210) | pub fn is_leader(&self) -> bool {

FILE: tokio/src/sync/batch_semaphore.rs
  type Semaphore (line 35) | pub(crate) struct Semaphore {
    constant MAX_PERMITS (line 130) | pub(crate) const MAX_PERMITS: usize = usize::MAX >> 3;
    constant CLOSED (line 131) | const CLOSED: usize = 1;
    constant PERMIT_SHIFT (line 135) | const PERMIT_SHIFT: usize = 1;
    method new (line 140) | pub(crate) fn new(permits: usize) -> Self {
    method const_new (line 182) | pub(crate) const fn const_new(permits: usize) -> Self {
    method new_closed (line 197) | pub(crate) fn new_closed() -> Self {
    method const_new_closed (line 211) | pub(crate) const fn const_new_closed() -> Self {
    method available_permits (line 224) | pub(crate) fn available_permits(&self) -> usize {
    method release (line 231) | pub(crate) fn release(&self, added: usize) {
    method close (line 242) | pub(crate) fn close(&self) {
    method is_closed (line 262) | pub(crate) fn is_closed(&self) -> bool {
    method try_acquire (line 266) | pub(crate) fn try_acquire(&self, num_permits: usize) -> Result<(), Try...
    method acquire (line 297) | pub(crate) fn acquire(&self, num_permits: usize) -> Acquire<'_> {
    method add_permits_locked (line 306) | fn add_permits_locked(&self, mut rem: usize, waiters: MutexGuard<'_, W...
    method forget_permits (line 376) | pub(crate) fn forget_permits(&self, n: usize) -> usize {
    method poll_acquire (line 397) | fn poll_acquire(
    method fmt (line 526) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Waitlist (line 43) | struct Waitlist {
  type TryAcquireError (line 52) | pub enum TryAcquireError {
    method is_closed (line 739) | pub(crate) fn is_closed(&self) -> bool {
    method is_no_permits (line 746) | pub(crate) fn is_no_permits(&self) -> bool {
    method fmt (line 752) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AcquireError (line 69) | pub struct AcquireError(());
    method closed (line 721) | fn closed() -> AcquireError {
    method fmt (line 727) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Acquire (line 71) | pub(crate) struct Acquire<'a> {
  type Waiter (line 79) | struct Waiter {
    method new (line 534) | fn new(
    method assign_permits (line 551) | fn assign_permits(&self, n: &mut usize) -> bool {
    type Handle (line 766) | type Handle = NonNull<Waiter>;
    type Target (line 767) | type Target = Waiter;
    method as_raw (line 769) | fn as_raw(handle: &Self::Handle) -> NonNull<Waiter> {
    method from_raw (line 773) | unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter> {
    method pointers (line 777) | unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<linked_list::Po...
  type Output (line 576) | type Output = Result<(), AcquireError>;
  method poll (line 578) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function new (line 622) | fn new(semaphore: &'a Semaphore, num_permits: usize) -> Self {
  function project (line 666) | fn project(self: Pin<&mut Self>) -> (Pin<&mut Waiter>, &Semaphore, usize...
  method drop (line 687) | fn drop(&mut self) {

FILE: tokio/src/sync/broadcast.rs
  type Sender (line 165) | pub struct Sender<T> {
  type WeakSender (line 199) | pub struct WeakSender<T> {
  type Receiver (line 239) | pub struct Receiver<T> {
  type SendError (line 261) | pub struct SendError<T>(pub T);
  function fmt (line 264) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type RecvError (line 276) | pub enum RecvError {
    method fmt (line 289) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TryRecvError (line 304) | pub enum TryRecvError {
    method fmt (line 324) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Shared (line 341) | struct Shared<T> {
  type Tail (line 362) | struct Tail {
  type Slot (line 377) | struct Slot<T> {
  type Waiter (line 397) | struct Waiter {
    method new (line 412) | fn new() -> Self {
    type Handle (line 1669) | type Handle = NonNull<Waiter>;
    type Target (line 1670) | type Target = Waiter;
    method as_raw (line 1672) | fn as_raw(handle: &NonNull<Waiter>) -> NonNull<Waiter> {
    method from_raw (line 1676) | unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter> {
    method pointers (line 1680) | unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<linked_list::Po...
  type RecvGuard (line 430) | struct RecvGuard<'a, T> {
  type Recv (line 435) | struct Recv<'a, T> {
  type WaiterCell (line 445) | struct WaiterCell(UnsafeCell<Waiter>);
  constant MAX_RECEIVERS (line 451) | const MAX_RECEIVERS: usize = usize::MAX >> 2;
  function channel (line 508) | pub fn channel<T: Clone>(capacity: usize) -> (Sender<T>, Receiver<T>) {
  function new (line 526) | pub fn new(capacity: usize) -> Self {
  function new_with_receiver_count (line 543) | unsafe fn new_with_receiver_count(receiver_count: usize, mut capacity: u...
  function send (line 631) | pub fn send(&self, value: T) -> Result<usize, SendError<T>> {
  function subscribe (line 692) | pub fn subscribe(&self) -> Receiver<T> {
  function downgrade (line 702) | pub fn downgrade(&self) -> WeakSender<T> {
  function len (line 746) | pub fn len(&self) -> usize {
  function is_empty (line 793) | pub fn is_empty(&self) -> bool {
  function receiver_count (line 836) | pub fn receiver_count(&self) -> usize {
  function same_channel (line 860) | pub fn same_channel(&self, other: &Self) -> bool {
  function closed (line 889) | pub async fn closed(&self) {
  function close_channel (line 905) | fn close_channel(&self) {
  function strong_count (line 913) | pub fn strong_count(&self) -> usize {
  function weak_count (line 918) | pub fn weak_count(&self) -> usize {
  function new_receiver (line 924) | fn new_receiver<T>(shared: Arc<Shared<T>>) -> Receiver<T> {
  type WaitersList (line 947) | struct WaitersList<'a, T> {
  method drop (line 954) | fn drop(&mut self) {
  function new (line 965) | fn new(
  function pop_back_locked (line 981) | fn pop_back_locked(&mut self, _tail: &mut Tail) -> Option<NonNull<Waiter...
  function notify_rx (line 993) | fn notify_rx<'a, 'b: 'a>(&'b self, mut tail: MutexGuard<'a, Tail>) {
  method clone (line 1059) | fn clone(&self) -> Sender<T> {
  method drop (line 1068) | fn drop(&mut self) {
  function upgrade (line 1081) | pub fn upgrade(&self) -> Option<Sender<T>> {
  function strong_count (line 1106) | pub fn strong_count(&self) -> usize {
  function weak_count (line 1111) | pub fn weak_count(&self) -> usize {
  method clone (line 1117) | fn clone(&self) -> WeakSender<T> {
  method drop (line 1126) | fn drop(&mut self) {
  function len (line 1165) | pub fn len(&self) -> usize {
  function is_empty (line 1195) | pub fn is_empty(&self) -> bool {
  function same_channel (line 1218) | pub fn same_channel(&self, other: &Self) -> bool {
  function recv_ref (line 1223) | fn recv_ref(
  function sender_strong_count (line 1331) | pub fn sender_strong_count(&self) -> usize {
  function sender_weak_count (line 1336) | pub fn sender_weak_count(&self) -> usize {
  function is_closed (line 1361) | pub fn is_closed(&self) -> bool {
  function resubscribe (line 1391) | pub fn resubscribe(&self) -> Self {
  function recv (line 1467) | pub async fn recv(&mut self) -> Result<T, RecvError> {
  function try_recv (line 1511) | pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
  function blocking_recv (line 1543) | pub fn blocking_recv(&mut self) -> Result<T, RecvError> {
  method drop (line 1549) | fn drop(&mut self) {
  function new (line 1578) | fn new(receiver: &'a mut Receiver<T>) -> Recv<'a, T> {
  function project (line 1592) | fn project(self: Pin<&mut Self>) -> (&mut Receiver<T>, &UnsafeCell<Waite...
  type Output (line 1607) | type Output = Result<T, RecvError>;
  method poll (line 1609) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<T, Re...
  method drop (line 1626) | fn drop(&mut self) {
  function fmt (line 1686) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1692) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1698) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function clone_value (line 1704) | fn clone_value(&self) -> Option<T>
  method drop (line 1713) | fn drop(&mut self) {
  function is_unpin (line 1721) | fn is_unpin<T: Unpin>() {}
  function receiver_count_on_sender_constructor (line 1729) | fn receiver_count_on_sender_constructor() {
  function receiver_count_on_channel_constructor (line 1752) | fn receiver_count_on_channel_constructor() {

FILE: tokio/src/sync/mpsc/block.rs
  type Block (line 13) | pub(crate) struct Block<T> {
  type BlockHeader (line 24) | struct BlockHeader<T> {
  type Read (line 41) | pub(crate) enum Read<T> {
  type Values (line 47) | struct Values<T>([UnsafeCell<MaybeUninit<T>>; BLOCK_CAP]);
  constant BLOCK_MASK (line 52) | const BLOCK_MASK: usize = !(BLOCK_CAP - 1);
  constant SLOT_MASK (line 55) | const SLOT_MASK: usize = BLOCK_CAP - 1;
  constant RELEASED (line 60) | const RELEASED: usize = 1 << BLOCK_CAP;
  constant TX_CLOSED (line 65) | const TX_CLOSED: usize = RELEASED << 1;
  constant READY_MASK (line 68) | const READY_MASK: usize = RELEASED - 1;
  function start_index (line 72) | pub(crate) fn start_index(slot_index: usize) -> usize {
  function offset (line 78) | pub(crate) fn offset(slot_index: usize) -> usize {
  function new (line 95) | pub(crate) fn new(start_index: usize) -> Box<Block<T>> {
  function is_at_index (line 129) | pub(crate) fn is_at_index(&self, index: usize) -> bool {
  function distance (line 138) | pub(crate) fn distance(&self, other_index: usize) -> usize {
  function read (line 152) | pub(crate) unsafe fn read(&self, slot_index: usize) -> Option<Read<T>> {
  function has_value (line 180) | pub(crate) fn has_value(&self, slot_index: usize) -> bool {
  function write (line 201) | pub(crate) unsafe fn write(&self, slot_index: usize, value: T) {
  function tx_close (line 219) | pub(crate) unsafe fn tx_close(&self) {
  function is_closed (line 223) | pub(crate) unsafe fn is_closed(&self) -> bool {
  function reclaim (line 237) | pub(crate) unsafe fn reclaim(&mut self) {
  function tx_release (line 253) | pub(crate) unsafe fn tx_release(&self, tail_position: usize) {
  function set_ready (line 271) | fn set_ready(&self, slot: usize) {
  function is_final (line 280) | pub(crate) fn is_final(&self) -> bool {
  function observed_tail_position (line 285) | pub(crate) fn observed_tail_position(&self) -> Option<usize> {
  function load_next (line 298) | pub(crate) fn load_next(&self, ordering: Ordering) -> Option<NonNull<Blo...
  function try_push (line 326) | pub(crate) unsafe fn try_push(
  function grow (line 362) | pub(crate) fn grow(&self) -> NonNull<Block<T>> {
  function is_ready (line 425) | fn is_ready(bits: usize, slot: usize) -> bool {
  function is_tx_closed (line 431) | fn is_tx_closed(bits: usize) -> bool {
  function initialize (line 441) | unsafe fn initialize(_value: NonNull<Values<T>>) {
  type Output (line 455) | type Output = UnsafeCell<MaybeUninit<T>>;
  function index (line 457) | fn index(&self, index: usize) -> &Self::Output {
  function assert_no_stack_overflow (line 464) | fn assert_no_stack_overflow() {

FILE: tokio/src/sync/mpsc/bounded.rs
  type Sender (line 22) | pub struct Sender<T> {
  type WeakSender (line 56) | pub struct WeakSender<T> {
  type Permit (line 67) | pub struct Permit<'a, T> {
  type PermitIterator (line 78) | pub struct PermitIterator<'a, T> {
  type OwnedPermit (line 95) | pub struct OwnedPermit<T> {
  type Receiver (line 106) | pub struct Receiver<T> {
  function channel (line 159) | pub fn channel<T>(buffer: usize) -> (Sender<T>, Receiver<T>) {
  type Semaphore (line 176) | pub(crate) struct Semaphore {
  function new (line 182) | pub(crate) fn new(chan: chan::Rx<T, Semaphore>) -> Receiver<T> {
  function recv (line 243) | pub async fn recv(&mut self) -> Option<T> {
  function recv_many (line 319) | pub async fn recv_many(&mut self, buffer: &mut Vec<T>, limit: usize) -> ...
  function try_recv (line 364) | pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
  function blocking_recv (line 424) | pub fn blocking_recv(&mut self) -> Option<T> {
  function blocking_recv_many (line 434) | pub fn blocking_recv_many(&mut self, buffer: &mut Vec<T>, limit: usize) ...
  function close (line 478) | pub fn close(&mut self) {
  function is_closed (line 504) | pub fn is_closed(&self) -> bool {
  function is_empty (line 526) | pub fn is_empty(&self) -> bool {
  function len (line 545) | pub fn len(&self) -> usize {
  function capacity (line 591) | pub fn capacity(&self) -> usize {
  function max_capacity (line 625) | pub fn max_capacity(&self) -> usize {
  function poll_recv (line 650) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
  function poll_recv_many (line 722) | pub fn poll_recv_many(
  function sender_strong_count (line 732) | pub fn sender_strong_count(&self) -> usize {
  function sender_weak_count (line 737) | pub fn sender_weak_count(&self) -> usize {
  function fmt (line 743) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 753) | pub(crate) fn new(chan: chan::Tx<T, Semaphore>) -> Sender<T> {
  function send (line 816) | pub async fn send(&self, value: T) -> Result<(), SendError<T>> {
  function closed (line 862) | pub async fn closed(&self) {
  function try_send (line 924) | pub fn try_send(&self, message: T) -> Result<(), TrySendError<T>> {
  function send_timeout (line 988) | pub async fn send_timeout(
  function blocking_send (line 1046) | pub fn blocking_send(&self, value: T) -> Result<(), SendError<T>> {
  function is_closed (line 1068) | pub fn is_closed(&self) -> bool {
  function reserve (line 1116) | pub async fn reserve(&self) -> Result<Permit<'_, T>, SendError<()>> {
  function reserve_many (line 1177) | pub async fn reserve_many(&self, n: usize) -> Result<PermitIterator<'_, ...
  function reserve_owned (line 1265) | pub async fn reserve_owned(self) -> Result<OwnedPermit<T>, SendError<()>> {
  function reserve_inner (line 1272) | async fn reserve_inner(&self, n: usize) -> Result<(), SendError<()>> {
  function try_reserve (line 1327) | pub fn try_reserve(&self) -> Result<Permit<'_, T>, TrySendError<()>> {
  function try_reserve_many (line 1405) | pub fn try_reserve_many(&self, n: usize) -> Result<PermitIterator<'_, T>...
  function try_reserve_owned (line 1477) | pub fn try_reserve_owned(self) -> Result<OwnedPermit<T>, TrySendError<Se...
  function same_channel (line 1501) | pub fn same_channel(&self, other: &Self) -> bool {
  function capacity (line 1538) | pub fn capacity(&self) -> usize {
  function downgrade (line 1547) | pub fn downgrade(&self) -> WeakSender<T> {
  function max_capacity (line 1585) | pub fn max_capacity(&self) -> usize {
  function strong_count (line 1590) | pub fn strong_count(&self) -> usize {
  function weak_count (line 1595) | pub fn weak_count(&self) -> usize {
  method clone (line 1601) | fn clone(&self) -> Self {
  function fmt (line 1609) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 1617) | fn clone(&self) -> Self {
  method drop (line 1627) | fn drop(&mut self) {
  function upgrade (line 1636) | pub fn upgrade(&self) -> Option<Sender<T>> {
  function strong_count (line 1641) | pub fn strong_count(&self) -> usize {
  function weak_count (line 1646) | pub fn weak_count(&self) -> usize {
  function fmt (line 1652) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function send (line 1692) | pub fn send(self, value: T) {
  method drop (line 1703) | fn drop(&mut self) {
  function fmt (line 1720) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 1730) | type Item = Permit<'a, T>;
  method next (line 1732) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1741) | fn size_hint(&self) -> (usize, Option<usize>) {
  method drop (line 1750) | fn drop(&mut self) {
  function fmt (line 1771) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function send (line 1816) | pub fn send(mut self, value: T) -> Sender<T> {
  function release (line 1855) | pub fn release(mut self) -> Sender<T> {
  function same_channel (line 1888) | pub fn same_channel(&self, other: &Self) -> bool {
  function same_channel_as_sender (line 1913) | pub fn same_channel_as_sender(&self, sender: &Sender<T>) -> bool {
  method drop (line 1921) | fn drop(&mut self) {
  function fmt (line 1944) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/mpsc/chan.rs
  type Tx (line 19) | pub(crate) struct Tx<T, S> {
  function fmt (line 24) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Rx (line 30) | pub(crate) struct Rx<T, S: Semaphore> {
  function fmt (line 35) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Semaphore (line 40) | pub(crate) trait Semaphore {
    method is_idle (line 41) | fn is_idle(&self) -> bool;
    method add_permit (line 43) | fn add_permit(&self);
    method add_permits (line 45) | fn add_permits(&self, n: usize);
    method close (line 47) | fn close(&self);
    method is_closed (line 49) | fn is_closed(&self) -> bool;
    method add_permit (line 575) | fn add_permit(&self) {
    method add_permits (line 579) | fn add_permits(&self, n: usize) {
    method is_idle (line 583) | fn is_idle(&self) -> bool {
    method close (line 587) | fn close(&self) {
    method is_closed (line 591) | fn is_closed(&self) -> bool {
    method add_permit (line 599) | fn add_permit(&self) {
    method add_permits (line 608) | fn add_permits(&self, n: usize) {
    method is_idle (line 617) | fn is_idle(&self) -> bool {
    method close (line 621) | fn close(&self) {
    method is_closed (line 625) | fn is_closed(&self) -> bool {
  type Chan (line 52) | pub(super) struct Chan<T, S> {
  function fmt (line 81) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type RxFields (line 93) | struct RxFields<T> {
  function fmt (line 102) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function channel (line 115) | pub(crate) fn channel<T, S: Semaphore>(semaphore: S) -> (Tx<T, S>, Rx<T,...
  function new (line 137) | fn new(chan: Arc<Chan<T, S>>) -> Tx<T, S> {
  function strong_count (line 141) | pub(super) fn strong_count(&self) -> usize {
  function weak_count (line 145) | pub(super) fn weak_count(&self) -> usize {
  function downgrade (line 149) | pub(super) fn downgrade(&self) -> Arc<Chan<T, S>> {
  function upgrade (line 156) | pub(super) fn upgrade(chan: Arc<Chan<T, S>>) -> Option<Self> {
  function semaphore (line 175) | pub(super) fn semaphore(&self) -> &S {
  function send (line 180) | pub(crate) fn send(&self, value: T) {
  function wake_rx (line 185) | pub(crate) fn wake_rx(&self) {
  function same_channel (line 190) | pub(crate) fn same_channel(&self, other: &Self) -> bool {
  function is_closed (line 196) | pub(crate) fn is_closed(&self) -> bool {
  function closed (line 200) | pub(crate) async fn closed(&self) {
  method clone (line 214) | fn clone(&self) -> Tx<T, S> {
  method drop (line 226) | fn drop(&mut self) {
  function new (line 242) | fn new(chan: Arc<Chan<T, S>>) -> Rx<T, S> {
  function close (line 246) | pub(crate) fn close(&mut self) {
  function is_closed (line 261) | pub(crate) fn is_closed(&self) -> bool {
  function is_empty (line 274) | pub(crate) fn is_empty(&self) -> bool {
  function len (line 281) | pub(crate) fn len(&self) -> usize {
  function recv (line 289) | pub(crate) fn recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
  function recv_many (line 346) | pub(crate) fn recv_many(
  function try_recv (line 428) | pub(crate) fn try_recv(&mut self) -> Result<T, TryRecvError> {
  function semaphore (line 476) | pub(super) fn semaphore(&self) -> &S {
  function sender_strong_count (line 480) | pub(super) fn sender_strong_count(&self) -> usize {
  function sender_weak_count (line 484) | pub(super) fn sender_weak_count(&self) -> usize {
  method drop (line 490) | fn drop(&mut self) {
  function send (line 532) | fn send(&self, value: T) {
  function decrement_weak_count (line 540) | pub(super) fn decrement_weak_count(&self) {
  function increment_weak_count (line 544) | pub(super) fn increment_weak_count(&self) {
  function strong_count (line 548) | pub(super) fn strong_count(&self) -> usize {
  function weak_count (line 552) | pub(super) fn weak_count(&self) -> usize {
  method drop (line 558) | fn drop(&mut self) {

FILE: tokio/src/sync/mpsc/error.rs
  type SendError (line 8) | pub struct SendError<T>(pub T);
  function fmt (line 11) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 17) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TrySendError (line 28) | pub enum TrySendError<T> {
  function into_inner (line 40) | pub fn into_inner(self) -> T {
  function fmt (line 49) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 58) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 73) | fn from(src: SendError<T>) -> TrySendError<T> {
  type TryRecvError (line 82) | pub enum TryRecvError {
    method fmt (line 92) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type RecvError (line 108) | pub struct RecvError(());
    method fmt (line 112) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/mpsc/list.rs
  type Tx (line 12) | pub(crate) struct Tx<T> {
  type Rx (line 22) | pub(crate) struct Rx<T> {
  type TryPopResult (line 34) | pub(crate) enum TryPopResult<T> {
  function channel (line 51) | pub(crate) fn channel<T>() -> (Tx<T>, Rx<T>) {
  function push (line 74) | pub(crate) fn push(&self, value: T) {
  function close (line 92) | pub(crate) fn close(&self) {
  function find_block (line 102) | fn find_block(&self, slot_index: usize) -> NonNull<Block<T>> {
  function reclaim_block (line 194) | pub(crate) unsafe fn reclaim_block(&self, mut block: NonNull<Block<T>>) {
  function is_closed (line 243) | pub(crate) fn is_closed(&self) -> bool {
  function fmt (line 254) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function is_empty (line 263) | pub(crate) fn is_empty(&self, tx: &Tx<T>) -> bool {
  function len (line 274) | pub(crate) fn len(&self, tx: &Tx<T>) -> usize {
  function pop (line 282) | pub(crate) fn pop(&mut self, tx: &Tx<T>) -> Option<block::Read<T>> {
  function try_pop (line 311) | pub(crate) fn try_pop(&mut self, tx: &Tx<T>) -> TryPopResult<T> {
  function try_advancing_head (line 326) | fn try_advancing_head(&mut self) -> bool {
  function reclaim_blocks (line 353) | fn reclaim_blocks(&mut self, tx: &Tx<T>) {
  function free_blocks (line 391) | pub(super) unsafe fn free_blocks(&mut self) {
  function fmt (line 412) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/mpsc/mod.rs
  constant BLOCK_CAP (line 140) | const BLOCK_CAP: usize = 32;
  constant BLOCK_CAP (line 143) | const BLOCK_CAP: usize = 16;
  constant BLOCK_CAP (line 146) | const BLOCK_CAP: usize = 2;

FILE: tokio/src/sync/mpsc/unbounded.rs
  type UnboundedSender (line 11) | pub struct UnboundedSender<T> {
  type WeakUnboundedSender (line 45) | pub struct WeakUnboundedSender<T> {
  method clone (line 50) | fn clone(&self) -> Self {
  function fmt (line 58) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type UnboundedReceiver (line 72) | pub struct UnboundedReceiver<T> {
  function fmt (line 78) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function unbounded_channel (line 95) | pub fn unbounded_channel<T>() -> (UnboundedSender<T>, UnboundedReceiver<...
  type Semaphore (line 106) | pub(crate) struct Semaphore(pub(crate) AtomicUsize);
  function new (line 109) | pub(crate) fn new(chan: chan::Rx<T, Semaphore>) -> UnboundedReceiver<T> {
  function recv (line 167) | pub async fn recv(&mut self) -> Option<T> {
  function recv_many (line 241) | pub async fn recv_many(&mut self, buffer: &mut Vec<T>, limit: usize) -> ...
  function try_recv (line 286) | pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
  function blocking_recv (line 321) | pub fn blocking_recv(&mut self) -> Option<T> {
  function blocking_recv_many (line 331) | pub fn blocking_recv_many(&mut self, buffer: &mut Vec<T>, limit: usize) ...
  function close (line 342) | pub fn close(&mut self) {
  function is_closed (line 368) | pub fn is_closed(&self) -> bool {
  function is_empty (line 390) | pub fn is_empty(&self) -> bool {
  function len (line 409) | pub fn len(&self) -> usize {
  function poll_recv (line 434) | pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
  function poll_recv_many (line 509) | pub fn poll_recv_many(
  function sender_strong_count (line 519) | pub fn sender_strong_count(&self) -> usize {
  function sender_weak_count (line 524) | pub fn sender_weak_count(&self) -> usize {
  function new (line 530) | pub(crate) fn new(chan: chan::Tx<T, Semaphore>) -> UnboundedSender<T> {
  function send (line 547) | pub fn send(&self, message: T) -> Result<(), SendError<T>> {
  function inc_num_messages (line 556) | fn inc_num_messages(&self) -> bool {
  function closed (line 623) | pub async fn closed(&self) {
  function is_closed (line 645) | pub fn is_closed(&self) -> bool {
  function same_channel (line 661) | pub fn same_channel(&self, other: &Self) -> bool {
  function downgrade (line 670) | pub fn downgrade(&self) -> WeakUnboundedSender<T> {
  function strong_count (line 677) | pub fn strong_count(&self) -> usize {
  function weak_count (line 682) | pub fn weak_count(&self) -> usize {
  method clone (line 688) | fn clone(&self) -> Self {
  method drop (line 698) | fn drop(&mut self) {
  function upgrade (line 707) | pub fn upgrade(&self) -> Option<UnboundedSender<T>> {
  function strong_count (line 712) | pub fn strong_count(&self) -> usize {
  function weak_count (line 717) | pub fn weak_count(&self) -> usize {
  function fmt (line 723) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/mutex.rs
  type Mutex (line 133) | pub struct Mutex<T: ?Sized> {
  type MutexGuard (line 151) | pub struct MutexGuard<'a, T: ?Sized> {
  type OwnedMutexGuard (line 175) | pub struct OwnedMutexGuard<T: ?Sized> {
  type MappedMutexGuard (line 190) | pub struct MappedMutexGuard<'a, T: ?Sized> {
  type OwnedMappedMutexGuard (line 209) | pub struct OwnedMappedMutexGuard<T: ?Sized, U: ?Sized = T> {
  type MutexGuardInner (line 221) | struct MutexGuardInner<'a, T: ?Sized> {
  type OwnedMutexGuardInner (line 229) | struct OwnedMutexGuardInner<T: ?Sized> {
  type MappedMutexGuardInner (line 238) | struct MappedMutexGuardInner<'a, T: ?Sized> {
  type OwnedMappedMutexGuardInner (line 248) | struct OwnedMappedMutexGuardInner<T: ?Sized, U: ?Sized> {
  type TryLockError (line 293) | pub struct TryLockError(pub(super) ());
    method fmt (line 296) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function bounds (line 305) | fn bounds() {
  function new (line 338) | pub fn new(t: T) -> Self
  function const_new (line 395) | pub const fn const_new(t: T) -> Self
  function lock (line 434) | pub async fn lock(&self) -> MutexGuard<'_, T> {
  function blocking_lock (line 520) | pub fn blocking_lock(&self) -> MutexGuard<'_, T> {
  function blocking_lock_owned (line 578) | pub fn blocking_lock_owned(self: Arc<Self>) -> OwnedMutexGuard<T> {
  function lock_owned (line 618) | pub async fn lock_owned(self: Arc<Self>) -> OwnedMutexGuard<T> {
  function acquire (line 655) | async fn acquire(&self) {
  function try_lock (line 682) | pub fn try_lock(&self) -> Result<MutexGuard<'_, T>, TryLockError> {
  function get_mut (line 722) | pub fn get_mut(&mut self) -> &mut T {
  function try_lock_owned (line 750) | pub fn try_lock_owned(self: Arc<Self>) -> Result<OwnedMutexGuard<T>, Try...
  function into_inner (line 787) | pub fn into_inner(self) -> T
  function from (line 796) | fn from(s: T) -> Self {
  method default (line 805) | fn default() -> Self {
  function fmt (line 814) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function skip_drop (line 827) | fn skip_drop(self) -> MutexGuardInner<'a, T> {
  function map (line 869) | pub fn map<U, F>(mut this: Self, f: F) -> MappedMutexGuard<'a, U>
  function try_map (line 918) | pub fn try_map<U, F>(mut this: Self, f: F) -> Result<MappedMutexGuard<'a...
  function mutex (line 959) | pub fn mutex(this: &Self) -> &'a Mutex<T> {
  method drop (line 965) | fn drop(&mut self) {
  type Target (line 979) | type Target = T;
  method deref (line 980) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 986) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 992) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 998) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function skip_drop (line 1006) | fn skip_drop(self) -> OwnedMutexGuardInner<T> {
  function map (line 1051) | pub fn map<U, F>(mut this: Self, f: F) -> OwnedMappedMutexGuard<T, U>
  function try_map (line 1100) | pub fn try_map<U, F>(mut this: Self, f: F) -> Result<OwnedMappedMutexGua...
  function mutex (line 1141) | pub fn mutex(this: &Self) -> &Arc<Mutex<T>> {
  method drop (line 1147) | fn drop(&mut self) {
  type Target (line 1161) | type Target = T;
  method deref (line 1162) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1168) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 1174) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1180) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function skip_drop (line 1188) | fn skip_drop(self) -> MappedMutexGuardInner<'a, T> {
  function map (line 1207) | pub fn map<U, F>(mut this: Self, f: F) -> MappedMutexGuard<'a, U>
  function try_map (line 1232) | pub fn try_map<U, F>(mut this: Self, f: F) -> Result<MappedMutexGuard<'a...
  method drop (line 1252) | fn drop(&mut self) {
  type Target (line 1266) | type Target = T;
  method deref (line 1267) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1273) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 1279) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1285) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function skip_drop (line 1293) | fn skip_drop(self) -> OwnedMappedMutexGuardInner<T, U> {
  function map (line 1316) | pub fn map<S, F>(mut this: Self, f: F) -> OwnedMappedMutexGuard<T, S>
  function try_map (line 1341) | pub fn try_map<S, F>(mut this: Self, f: F) -> Result<OwnedMappedMutexGua...
  method drop (line 1360) | fn drop(&mut self) {
  type Target (line 1374) | type Target = U;
  method deref (line 1375) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1381) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 1387) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1393) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/notify.rs
  type WaitList (line 23) | type WaitList = LinkedList<Waiter, <Waiter as linked_list::Link>::Target>;
  type GuardedWaitList (line 24) | type GuardedWaitList = GuardedLinkedList<Waiter, <Waiter as linked_list:...
  type Notify (line 202) | pub struct Notify {
    method new (line 483) | pub fn new() -> Notify {
    method const_new (line 508) | pub const fn const_new() -> Notify {
    method notified (line 565) | pub fn notified(&self) -> Notified<'_> {
    method notified_owned (line 613) | pub fn notified_owned(self: Arc<Self>) -> OwnedNotified {
    method notify_one (line 660) | pub fn notify_one(&self) {
    method notify_last (line 673) | pub fn notify_last(&self) {
    method notify_with_strategy (line 677) | fn notify_with_strategy(&self, strategy: NotifyOneStrategy) {
    method notify_waiters (line 743) | pub fn notify_waiters(&self) {
    method inner_notify_waiters (line 747) | fn inner_notify_waiters<'a>(
    method lock_waiter_list (line 820) | pub(crate) fn lock_waiter_list(&self) -> NotifyGuard<'_> {
  type Waiter (line 218) | struct Waiter {
    method new (line 240) | fn new() -> Waiter {
    type Handle (line 1376) | type Handle = NonNull<Waiter>;
    type Target (line 1377) | type Target = Waiter;
    method as_raw (line 1379) | fn as_raw(handle: &NonNull<Waiter>) -> NonNull<Waiter> {
    method from_raw (line 1383) | unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter> {
    method pointers (line 1387) | unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<linked_list::Po...
  constant NOTIFICATION_NONE (line 259) | const NOTIFICATION_NONE: usize = 0b000;
  constant NOTIFICATION_ONE (line 262) | const NOTIFICATION_ONE: usize = 0b001;
  constant NOTIFICATION_LAST (line 265) | const NOTIFICATION_LAST: usize = 0b101;
  constant NOTIFICATION_ALL (line 268) | const NOTIFICATION_ALL: usize = 0b010;
  type AtomicNotification (line 274) | struct AtomicNotification(AtomicUsize);
    method none (line 277) | fn none() -> Self {
    method store_release (line 283) | fn store_release(&self, notification: Notification) {
    method load (line 292) | fn load(&self, ordering: Ordering) -> Option<Notification> {
    method clear (line 307) | fn clear(&self) {
  type NotifyOneStrategy (line 314) | enum NotifyOneStrategy {
  type Notification (line 321) | enum Notification {
  type NotifyWaitersList (line 329) | struct NotifyWaitersList<'a> {
  function new (line 336) | fn new(
  function pop_back_locked (line 352) | fn pop_back_locked(&mut self, _waiters: &mut WaitList) -> Option<NonNull...
  method drop (line 364) | fn drop(&mut self) {
  type Notified (line 384) | pub struct Notified<'a> {
  type OwnedNotified (line 407) | pub struct OwnedNotified {
    method enable (line 1059) | pub fn enable(self: Pin<&mut Self>) -> bool {
    method project (line 1065) | fn project(self: Pin<&mut Self>) -> NotifiedProject<'_> {
    method poll_notified (line 1083) | fn poll_notified(self: Pin<&mut Self>, waker: Option<&Waker>) -> Poll<...
  type NotifiedProject (line 426) | struct NotifiedProject<'a> {
  type State (line 434) | enum State {
  constant NOTIFY_WAITERS_SHIFT (line 440) | const NOTIFY_WAITERS_SHIFT: usize = 2;
  constant STATE_MASK (line 441) | const STATE_MASK: usize = (1 << NOTIFY_WAITERS_SHIFT) - 1;
  constant NOTIFY_WAITERS_CALLS_MASK (line 442) | const NOTIFY_WAITERS_CALLS_MASK: usize = !STATE_MASK;
  constant EMPTY (line 445) | const EMPTY: usize = 0;
  constant WAITING (line 448) | const WAITING: usize = 1;
  constant NOTIFIED (line 451) | const NOTIFIED: usize = 2;
  function set_state (line 453) | fn set_state(data: usize, state: usize) -> usize {
  function get_state (line 457) | fn get_state(data: usize) -> usize {
  function get_num_notify_waiters_calls (line 461) | fn get_num_notify_waiters_calls(data: usize) -> usize {
  function inc_num_notify_waiters_calls (line 465) | fn inc_num_notify_waiters_calls(data: usize) -> usize {
  function atomic_inc_num_notify_waiters_calls (line 469) | fn atomic_inc_num_notify_waiters_calls(data: &AtomicUsize) {
  method default (line 836) | fn default() -> Notify {
  function notify_locked (line 844) | fn notify_locked(
  function enable (line 1006) | pub fn enable(self: Pin<&mut Self>) -> bool {
  function project (line 1010) | fn project(self: Pin<&mut Self>) -> NotifiedProject<'_> {
  function poll_notified (line 1028) | fn poll_notified(self: Pin<&mut Self>, waker: Option<&Waker>) -> Poll<()> {
  type Output (line 1034) | type Output = ();
  method poll (line 1036) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  method drop (line 1042) | fn drop(&mut self) {
  type Output (line 1089) | type Output = ();
  method poll (line 1091) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  method drop (line 1097) | fn drop(&mut self) {
  function poll_notified (line 1108) | fn poll_notified(self, waker: Option<&Waker>) -> Poll<()> {
  function drop_notified (line 1326) | fn drop_notified(self) {
  function is_unpin (line 1392) | fn is_unpin<T: Unpin>() {}
  type NotifyGuard (line 1398) | pub(crate) struct NotifyGuard<'a> {
  function notify_waiters (line 1405) | pub(crate) fn notify_waiters(self) {

FILE: tokio/src/sync/once_cell.rs
  type OnceCell (line 70) | pub struct OnceCell<T> {
  method default (line 77) | fn default() -> OnceCell<T> {
  function fmt (line 83) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 91) | fn clone(&self) -> OnceCell<T> {
  method eq (line 97) | fn eq(&self, other: &OnceCell<T>) -> bool {
  method drop (line 105) | fn drop(&mut self) {
  function from (line 116) | fn from(value: T) -> Self {
  function new (line 127) | pub fn new() -> Self {
  function const_new (line 168) | pub const fn const_new() -> Self {
  function new_with (line 185) | pub fn new_with(value: Option<T>) -> Self {
  function const_new_with (line 223) | pub const fn const_new_with(value: T) -> Self {
  function initialized (line 233) | pub fn initialized(&self) -> bool {
  function initialized_mut (line 241) | fn initialized_mut(&mut self) -> bool {
  function get_unchecked (line 246) | unsafe fn get_unchecked(&self) -> &T {
  function get_unchecked_mut (line 251) | unsafe fn get_unchecked_mut(&mut self) -> &mut T {
  function set_value (line 259) | fn set_value(&self, value: T, permit: SemaphorePermit<'_>) -> &T {
  function get (line 277) | pub fn get(&self) -> Option<&T> {
  function get_mut (line 291) | pub fn get_mut(&mut self) -> Option<&mut T> {
  function set (line 310) | pub fn set(&self, value: T) -> Result<(), SetError<T>> {
  function get_or_init (line 350) | pub async fn get_or_init<F, Fut>(&self, f: F) -> &T
  function get_or_try_init (line 400) | pub async fn get_or_try_init<E, F, Fut>(&self, f: F) -> Result<&T, E>
  function into_inner (line 442) | pub fn into_inner(mut self) -> Option<T> {
  function take (line 454) | pub fn take(&mut self) -> Option<T> {
  type SetError (line 475) | pub enum SetError<T> {
  function fmt (line 486) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function is_already_init_err (line 498) | pub fn is_already_init_err(&self) -> bool {
  function is_initializing_err (line 506) | pub fn is_initializing_err(&self) -> bool {

FILE: tokio/src/sync/oneshot.rs
  type Sender (line 222) | pub struct Sender<T> {
  type Receiver (line 329) | pub struct Receiver<T> {
  type RecvError (line 348) | pub struct RecvError(pub(super) ());
    method fmt (line 363) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TryRecvError (line 352) | pub enum TryRecvError {
    method fmt (line 373) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Inner (line 386) | struct Inner<T> {
  type Task (line 411) | struct Task(UnsafeCell<MaybeUninit<Waker>>);
    method will_wake (line 418) | unsafe fn will_wake(&self, cx: &mut Context<'_>) -> bool {
    method with_task (line 426) | unsafe fn with_task<F, R>(&self, f: F) -> R
    method drop_task (line 440) | unsafe fn drop_task(&self) {
    method set_task (line 453) | unsafe fn set_task(&self, cx: &mut Context<'_>) {
  type State (line 464) | struct State(usize);
    method new (line 1506) | fn new() -> State {
    method is_complete (line 1510) | fn is_complete(self) -> bool {
    method set_complete (line 1514) | fn set_complete(cell: &AtomicUsize) -> State {
    method is_rx_task_set (line 1549) | fn is_rx_task_set(self) -> bool {
    method set_rx_task (line 1553) | fn set_rx_task(cell: &AtomicUsize) -> State {
    method unset_rx_task (line 1558) | fn unset_rx_task(cell: &AtomicUsize) -> State {
    method is_closed (line 1563) | fn is_closed(self) -> bool {
    method set_closed (line 1567) | fn set_closed(cell: &AtomicUsize) -> State {
    method set_tx_task (line 1574) | fn set_tx_task(cell: &AtomicUsize) -> State {
    method unset_tx_task (line 1579) | fn unset_tx_task(cell: &AtomicUsize) -> State {
    method is_tx_task_set (line 1584) | fn is_tx_task_set(self) -> bool {
    method as_usize (line 1588) | fn as_usize(self) -> usize {
    method load (line 1592) | fn load(cell: &AtomicUsize, order: Ordering) -> State {
    method fmt (line 1599) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function channel (line 497) | pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
  function send (line 622) | pub fn send(mut self, t: T) -> Result<(), T> {
  function closed (line 727) | pub async fn closed(&mut self) {
  function is_closed (line 773) | pub fn is_closed(&self) -> bool {
  function poll_closed (line 820) | pub fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  method drop (line 872) | fn drop(&mut self) {
  function close (line 947) | pub fn close(&mut self) {
  function is_terminated (line 1015) | pub fn is_terminated(&self) -> bool {
  function is_empty (line 1082) | pub fn is_empty(&self) -> bool {
  function try_recv (line 1171) | pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
  function blocking_recv (line 1240) | pub fn blocking_recv(self) -> Result<T, RecvError> {
  method drop (line 1246) | fn drop(&mut self) {
  type Output (line 1269) | type Output = Result<T, RecvError>;
  method poll (line 1271) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function complete (line 1298) | fn complete(&self) -> bool {
  function poll_recv (line 1315) | fn poll_recv(&self, cx: &mut Context<'_>) -> Poll<Result<T, RecvError>> {
  function close (line 1385) | fn close(&self) -> State {
  function consume_value (line 1419) | unsafe fn consume_value(&self) -> Option<T> {
  function has_value (line 1432) | unsafe fn has_value(&self) -> bool {
  function mut_load (line 1440) | fn mut_load(this: &mut AtomicUsize) -> usize {
  method drop (line 1445) | fn drop(&mut self) {
  function fmt (line 1472) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant RX_TASK_SET (line 1486) | const RX_TASK_SET: usize = 0b00001;
  constant VALUE_SENT (line 1495) | const VALUE_SENT: usize = 0b00010;
  constant CLOSED (line 1496) | const CLOSED: usize = 0b00100;
  constant TX_TASK_SET (line 1503) | const TX_TASK_SET: usize = 0b01000;

FILE: tokio/src/sync/rwlock.rs
  constant MAX_READS (line 24) | const MAX_READS: u32 = u32::MAX >> 3;
  constant MAX_READS (line 27) | const MAX_READS: u32 = 10;
  type RwLock (line 87) | pub struct RwLock<T: ?Sized> {
  function bounds (line 103) | fn bounds() {
  function new (line 203) | pub fn new(value: T) -> RwLock<T>
  function with_max_readers (line 270) | pub fn with_max_readers(value: T, max_reads: u32) -> RwLock<T>
  function const_new (line 346) | pub const fn const_new(value: T) -> RwLock<T>
  function const_with_max_readers (line 370) | pub const fn const_with_max_readers(value: T, max_reads: u32) -> RwLock<T>
  function read (line 430) | pub async fn read(&self) -> RwLockReadGuard<'_, T> {
  function blocking_read (line 523) | pub fn blocking_read(&self) -> RwLockReadGuard<'_, T> {
  function read_owned (line 578) | pub async fn read_owned(self: Arc<Self>) -> OwnedRwLockReadGuard<T> {
  function try_read (line 654) | pub fn try_read(&self) -> Result<RwLockReadGuard<'_, T>, TryLockError> {
  function try_read_owned (line 719) | pub fn try_read_owned(self: Arc<Self>) -> Result<OwnedRwLockReadGuard<T>...
  function write (line 774) | pub async fn write(&self) -> RwLockWriteGuard<'_, T> {
  function blocking_write (line 870) | pub fn blocking_write(&self) -> RwLockWriteGuard<'_, T> {
  function write_owned (line 909) | pub async fn write_owned(self: Arc<Self>) -> OwnedRwLockWriteGuard<T> {
  function try_write (line 977) | pub fn try_write(&self) -> Result<RwLockWriteGuard<'_, T>, TryLockError> {
  function try_write_owned (line 1035) | pub fn try_write_owned(self: Arc<Self>) -> Result<OwnedRwLockWriteGuard<...
  function get_mut (line 1080) | pub fn get_mut(&mut self) -> &mut T {
  function into_inner (line 1085) | pub fn into_inner(self) -> T
  function from (line 1094) | fn from(s: T) -> Self {
  method default (line 1103) | fn default() -> Self {
  function fmt (line 1112) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: tokio/src/sync/rwlock/owned_read_guard.rs
  type OwnedRwLockReadGuard (line 15) | pub struct OwnedRwLockReadGuard<T: ?Sized, U: ?Sized = T> {
  type Inner (line 26) | struct Inner<T: ?Sized, U: ?Sized> {
  function skip_drop (line 34) | fn skip_drop(self) -> Inner<T, U> {
  function map (line 76) | pub fn map<F, V: ?Sized>(this: Self, f: F) -> OwnedRwLockReadGuard<T, V>
  function try_map (line 123) | pub fn try_map<F, V: ?Sized>(this: Self, f: F) -> Result<OwnedRwLockRead...
  function rwlock (line 164) | pub fn rwlock(this: &Self) -> &Arc<RwLock<T>> {
  type Target (line 170) | type Target = U;
  function deref (line 172) | fn deref(&self) -> &U {
  function fmt (line 181) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 190) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 196) | fn drop(&mut self) {

FILE: tokio/src/sync/rwlock/owned_write_guard.rs
  type OwnedRwLockWriteGuard (line 17) | pub struct OwnedRwLockWriteGuard<T: ?Sized> {
  type Inner (line 29) | struct Inner<T: ?Sized> {
  function skip_drop (line 38) | fn skip_drop(self) -> Inner<T> {
  function map (line 86) | pub fn map<F, U: ?Sized>(mut this: Self, f: F) -> OwnedRwLockMappedWrite...
  function downgrade_map (line 135) | pub fn downgrade_map<F, U: ?Sized>(this: Self, f: F) -> OwnedRwLockReadG...
  function try_map (line 210) | pub fn try_map<F, U: ?Sized>(
  function try_downgrade_map (line 269) | pub fn try_downgrade_map<F, U: ?Sized>(
  function into_mapped (line 320) | pub fn into_mapped(this: Self) -> OwnedRwLockMappedWriteGuard<T> {
  function downgrade (line 359) | pub fn downgrade(self) -> OwnedRwLockReadGuard<T> {
  function rwlock (line 410) | pub fn rwlock(this: &Self) -> &Arc<RwLock<T>> {
  type Target (line 416) | type Target = T;
  function deref (line 418) | fn deref(&self) -> &T {
  function deref_mut (line 424) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 433) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 442) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 448) | fn drop(&mut self) {

FILE: tokio/src/sync/rwlock/owned_write_guard_mapped.rs
  type OwnedRwLockMappedWriteGuard (line 16) | pub struct OwnedRwLockMappedWriteGuard<T: ?Sized, U: ?Sized = T> {
  type Inner (line 28) | struct Inner<T: ?Sized, U: ?Sized> {
  function skip_drop (line 37) | fn skip_drop(self) -> Inner<T, U> {
  function map (line 85) | pub fn map<F, V: ?Sized>(mut this: Self, f: F) -> OwnedRwLockMappedWrite...
  function try_map (line 136) | pub fn try_map<F, V: ?Sized>(
  function rwlock (line 180) | pub fn rwlock(this: &Self) -> &Arc<RwLock<T>> {
  type Target (line 186) | type Target = U;
  function deref (line 188) | fn deref(&self) -> &U {
  function deref_mut (line 194) | fn deref_mut(&mut self) -> &mut U {
  function fmt (line 203) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 212) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 218) | fn drop(&mut self) {

FILE: tokio/src/sync/rwlock/read_guard.rs
  type RwLockReadGuard (line 15) | pub struct RwLockReadGuard<'a, T: ?Sized> {
  type Inner (line 26) | struct Inner<'a, T: ?Sized> {
  function skip_drop (line 34) | fn skip_drop(self) -> Inner<'a, T> {
  function map (line 80) | pub fn map<F, U: ?Sized>(this: Self, f: F) -> RwLockReadGuard<'a, U>
  function try_map (line 132) | pub fn try_map<F, U: ?Sized>(this: Self, f: F) -> Result<RwLockReadGuard...
  type Target (line 153) | type Target = T;
  function deref (line 155) | fn deref(&self) -> &T {
  function fmt (line 164) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 173) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 179) | fn drop(&mut self) {

FILE: tokio/src/sync/rwlock/write_guard.rs
  type RwLockWriteGuard (line 17) | pub struct RwLockWriteGuard<'a, T: ?Sized> {
  type Inner (line 29) | struct Inner<'a, T: ?Sized> {
  function skip_drop (line 38) | fn skip_drop(self) -> Inner<'a, T> {
  function map (line 88) | pub fn map<F, U: ?Sized>(mut this: Self, f: F) -> RwLockMappedWriteGuard...
  function downgrade_map (line 143) | pub fn downgrade_map<F, U: ?Sized>(this: Self, f: F) -> RwLockReadGuard<...
  function try_map (line 222) | pub fn try_map<F, U: ?Sized>(
  function try_downgrade_map (line 287) | pub fn try_downgrade_map<F, U: ?Sized>(this: Self, f: F) -> Result<RwLoc...
  function into_mapped (line 335) | pub fn into_mapped(this: Self) -> RwLockMappedWriteGuard<'a, T> {
  function downgrade (line 376) | pub fn downgrade(self) -> RwLockReadGuard<'a, T> {
  type Target (line 413) | type Target = T;
  function deref (line 415) | fn deref(&self) -> &T {
  function deref_mut (line 421) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 430) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 439) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 445) | fn drop(&mut self) {

FILE: tokio/src/sync/rwlock/write_guard_mapped.rs
  type RwLockMappedWriteGuard (line 15) | pub struct RwLockMappedWriteGuard<'a, T: ?Sized> {
  type Inner (line 27) | struct Inner<'a, T: ?Sized> {
  function skip_drop (line 36) | fn skip_drop(self) -> Inner<'a, T> {
  function map (line 85) | pub fn map<F, U: ?Sized>(mut this: Self, f: F) -> RwLockMappedWriteGuard...
  function try_map (line 141) | pub fn try_map<F, U: ?Sized>(
  type Target (line 169) | type Target = T;
  function deref (line 171) | fn deref(&self) -> &T {
  function deref_mut (line 177) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 186) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 195) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 201) | fn drop(&mut self) {

FILE: tokio/src/sync/semaphore.rs
  type Semaphore (line 398) | pub struct Semaphore {
    constant MAX_PERMITS (line 450) | pub const MAX_PERMITS: usize = super::batch_semaphore::Semaphore::MAX_...
    method new (line 456) | pub fn new(permits: usize) -> Self {
    method const_new (line 504) | pub const fn const_new(permits: usize) -> Self {
    method new_closed (line 513) | pub(crate) fn new_closed() -> Self {
    method const_new_closed (line 523) | pub(crate) const fn const_new_closed() -> Self {
    method available_permits (line 532) | pub fn available_permits(&self) -> usize {
    method add_permits (line 539) | pub fn add_permits(&self, n: usize) {
    method forget_permits (line 547) | pub fn forget_permits(&self, n: usize) -> usize {
    method acquire (line 585) | pub async fn acquire(&self) -> Result<SemaphorePermit<'_>, AcquireErro...
    method acquire_many (line 632) | pub async fn acquire_many(&self, n: u32) -> Result<SemaphorePermit<'_>...
    method try_acquire (line 680) | pub fn try_acquire(&self) -> Result<SemaphorePermit<'_>, TryAcquireErr...
    method try_acquire_many (line 715) | pub fn try_acquire_many(&self, n: u32) -> Result<SemaphorePermit<'_>, ...
    method acquire_owned (line 767) | pub async fn acquire_owned(self: Arc<Self>) -> Result<OwnedSemaphorePe...
    method acquire_many_owned (line 828) | pub async fn acquire_many_owned(
    method try_acquire_owned (line 882) | pub fn try_acquire_owned(self: Arc<Self>) -> Result<OwnedSemaphorePerm...
    method try_acquire_many_owned (line 921) | pub fn try_acquire_many_owned(
    method close (line 963) | pub fn close(&self) {
    method is_closed (line 968) | pub fn is_closed(&self) -> bool {
  type SemaphorePermit (line 413) | pub struct SemaphorePermit<'a> {
  type OwnedSemaphorePermit (line 426) | pub struct OwnedSemaphorePermit {
    method forget (line 1102) | pub fn forget(mut self) {
    method merge (line 1139) | pub fn merge(&mut self, mut other: Self) {
    method split (line 1170) | pub fn split(&mut self, n: usize) -> Option<Self> {
    method semaphore (line 1186) | pub fn semaphore(&self) -> &Arc<Semaphore> {
    method num_permits (line 1191) | pub fn num_permits(&self) -> usize {
  function bounds (line 433) | fn bounds() {
  function forget (line 995) | pub fn forget(mut self) {
  function merge (line 1032) | pub fn merge(&mut self, mut other: Self) {
  function split (line 1059) | pub fn split(&mut self, n: usize) -> Option<Self> {
  function num_permits (line 1075) | pub fn num_permits(&self) -> usize {
  method drop (line 1197) | fn drop(&mut self) {
  method drop (line 1203) | fn drop(&mut self) {

FILE: tokio/src/sync/set_once.rs
  type SetOnce (line 91) | pub struct SetOnce<T> {
  method default (line 98) | fn default() -> SetOnce<T> {
  function fmt (line 104) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 112) | fn clone(&self) -> SetOnce<T> {
  method eq (line 118) | fn eq(&self, other: &SetOnce<T>) -> bool {
  method drop (line 126) | fn drop(&mut self) {
  function from (line 137) | fn from(value: T) -> Self {
  function new (line 148) | pub fn new() -> Self {
  function const_new (line 190) | pub const fn const_new() -> Self {
  function new_with (line 203) | pub fn new_with(value: Option<T>) -> Self {
  function const_new_with (line 240) | pub const fn const_new_with(value: T) -> Self {
  function initialized (line 250) | pub fn initialized(&self) -> bool {
  function get_unchecked (line 257) | unsafe fn get_unchecked(&self) -> &T {
  function get (line 263) | pub fn get(&self) -> Option<&T> {
  function set (line 280) | pub fn set(&self, value: T) -> Result<(), SetOnceError<T>> {
  function into_inner (line 311) | pub fn into_inner(self) -> Option<T> {
  function wait (line 339) | pub async fn wait(&self) -> &T {
  type SetOnceError (line 380) | pub struct SetOnceError<T>(pub T);
  function fmt (line 383) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/sync/task/atomic_waker.rs
  type AtomicWaker (line 27) | pub(crate) struct AtomicWaker {
    method new (line 142) | pub(crate) fn new() -> AtomicWaker {
    method register_by_ref (line 171) | pub(crate) fn register_by_ref(&self, waker: &Waker) {
    method do_register (line 175) | fn do_register<W>(&self, waker: W)
    method wake (line 303) | pub(crate) fn wake(&self) {
    method take_waker (line 313) | pub(crate) fn take_waker(&self) -> Option<Waker> {
    method fmt (line 352) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant WAITING (line 132) | const WAITING: usize = 0;
  constant REGISTERING (line 135) | const REGISTERING: usize = 0b01;
  constant WAKING (line 138) | const WAKING: usize = 0b10;
  method default (line 346) | fn default() -> Self {
  type WakerRef (line 360) | trait WakerRef {
    method wake (line 361) | fn wake(self);
    method into_waker (line 362) | fn into_waker(self) -> Waker;
    method wake (line 366) | fn wake(self) {
    method into_waker (line 370) | fn into_waker(self) -> Waker {
    method wake (line 376) | fn wake(self) {
    method into_waker (line 380) | fn into_waker(self) -> Waker {

FILE: tokio/src/sync/tests/atomic_waker.rs
  type AssertSend (line 7) | trait AssertSend: Send {}
  type AssertSync (line 10) | trait AssertSync: Sync {}
  function basic_usage (line 22) | fn basic_usage() {
  function wake_without_register (line 32) | fn wake_without_register() {
  function failed_wake_synchronizes (line 44) | fn failed_wake_synchronizes() {
  function failed_wake_synchronizes_inner (line 50) | fn failed_wake_synchronizes_inner() {
  function atomic_waker_panic_safe (line 77) | fn atomic_waker_panic_safe() {

FILE: tokio/src/sync/tests/loom_atomic_waker.rs
  type Chan (line 11) | struct Chan {
  function basic_notification (line 17) | fn basic_notification() {
  function test_panicky_waker (line 48) | fn test_panicky_waker() {

FILE: tokio/src/sync/tests/loom_broadcast.rs
  function broadcast_send (line 10) | fn broadcast_send() {
  function broadcast_two (line 51) | fn broadcast_two() {
  function broadcast_wrap (line 96) | fn broadcast_wrap() {
  function drop_rx (line 145) | fn drop_rx() {
  function drop_multiple_rx_with_overflow (line 183) | fn drop_multiple_rx_with_overflow() {

FILE: tokio/src/sync/tests/loom_list.rs
  function smoke (line 7) | fn smoke() {

FILE: tokio/src/sync/tests/loom_mpsc.rs
  function closing_tx (line 10) | fn closing_tx() {
  function closing_unbounded_tx (line 28) | fn closing_unbounded_tx() {
  function closing_bounded_rx (line 46) | fn closing_bounded_rx() {
  function closing_and_sending (line 60) | fn closing_and_sending() {
  function closing_unbounded_rx (line 87) | fn closing_unbounded_rx() {
  function dropping_tx (line 101) | fn dropping_tx() {
  function dropping_unbounded_tx (line 119) | fn dropping_unbounded_tx() {
  function try_recv (line 137) | fn try_recv() {
  function len_nonzero_after_send (line 193) | fn len_nonzero_after_send() {
  function nonempty_after_send (line 210) | fn nonempty_after_send() {

FILE: tokio/src/sync/tests/loom_notify.rs
  constant WAKE_LIST_SIZE (line 10) | const WAKE_LIST_SIZE: usize = 32;
  function notify_one (line 13) | fn notify_one() {
  function notify_waiters (line 30) | fn notify_waiters() {
  function notify_waiters_and_one (line 51) | fn notify_waiters_and_one() {
  function notify_multi (line 80) | fn notify_multi() {
  function notify_drop (line 110) | fn notify_drop() {
  function notify_waiters_poll_consistency (line 150) | fn notify_waiters_poll_consistency() {
  function notify_waiters_poll_consistency_many (line 192) | fn notify_waiters_poll_consistency_many() {
  function notify_waiters_is_atomic (line 228) | fn notify_waiters_is_atomic() {
  function notify_waiters_sequential_notified_await (line 277) | fn notify_waiters_sequential_notified_await() {

FILE: tokio/src/sync/tests/loom_oneshot.rs
  function smoke (line 10) | fn smoke() {
  function changing_rx_task (line 24) | fn changing_rx_task() {
  function try_recv_close (line 60) | fn try_recv_close() {
  function recv_closed (line 74) | fn recv_closed() {
  type OnClose (line 93) | struct OnClose<'a> {
  function new (line 98) | fn new(tx: &'a mut oneshot::Sender<i32>) -> Self {
  type Output (line 104) | type Output = bool;
  method poll (line 106) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<bool> {
  function changing_tx_task (line 115) | fn changing_tx_task() {
  function checking_tx_send_ok_not_drop (line 143) | fn checking_tx_send_ok_not_drop() {
  function drop_rx_after_poll (line 190) | fn drop_rx_after_poll() {

FILE: tokio/src/sync/tests/loom_rwlock.rs
  function concurrent_write (line 8) | fn concurrent_write() {
  function concurrent_read_write (line 39) | fn concurrent_read_write() {
  function downgrade (line 86) | fn downgrade() {

FILE: tokio/src/sync/tests/loom_semaphore_batch.rs
  function basic_usage (line 14) | fn basic_usage() {
  function release (line 51) | fn release() {
  function basic_closing (line 70) | fn basic_closing() {
  function concurrent_close (line 95) | fn concurrent_close() {
  function concurrent_cancel (line 116) | fn concurrent_cancel() {
  function batch (line 160) | fn batch() {
  function release_during_acquire (line 200) | fn release_during_acquire() {
  function concurrent_permit_updates (line 217) | fn concurrent_permit_updates() {

FILE: tokio/src/sync/tests/loom_set_once.rs
  type DropCounter (line 10) | struct DropCounter {
    method new (line 15) | pub fn new() -> Self {
    method assert_num_drops (line 21) | fn assert_num_drops(&self, value: u32) {
  method drop (line 27) | fn drop(&mut self) {
  function set_once_drop_test (line 33) | fn set_once_drop_test() {
  function set_once_wait_test (line 56) | fn set_once_wait_test() {

FILE: tokio/src/sync/tests/loom_watch.rs
  function smoke (line 8) | fn smoke() {
  function wait_for_test (line 40) | fn wait_for_test() {
  function wait_for_returns_correct_value (line 66) | fn wait_for_returns_correct_value() {
  function multiple_sender_drop_concurrently (line 93) | fn multiple_sender_drop_concurrently() {

FILE: tokio/src/sync/tests/notify.rs
  function notify_clones_waker_before_lock (line 10) | fn notify_clones_waker_before_lock() {
  function notify_waiters_handles_panicking_waker (line 52) | fn notify_waiters_handles_panicking_waker() {
  function notify_simple (line 90) | fn notify_simple() {
  function watch_test (line 107) | fn watch_test() {

FILE: tokio/src/sync/tests/semaphore_batch.rs
  constant MAX_PERMITS (line 4) | const MAX_PERMITS: usize = crate::sync::Semaphore::MAX_PERMITS;
  function poll_acquire_one_available (line 10) | fn poll_acquire_one_available() {
  function poll_acquire_many_available (line 20) | fn poll_acquire_many_available() {
  function try_acquire_one_available (line 33) | fn try_acquire_one_available() {
  function try_acquire_many_available (line 45) | fn try_acquire_many_available() {
  function poll_acquire_one_unavailable (line 57) | fn poll_acquire_one_unavailable() {
  function poll_acquire_many_unavailable (line 81) | fn poll_acquire_many_unavailable() {
  function try_acquire_one_unavailable (line 118) | fn try_acquire_one_unavailable() {
  function try_acquire_many_unavailable (line 137) | fn try_acquire_many_unavailable() {
  function poll_acquire_one_zero_permits (line 159) | fn poll_acquire_one_zero_permits() {
  function max_permits_doesnt_panic (line 174) | fn max_permits_doesnt_panic() {
  function validates_max_permits (line 181) | fn validates_max_permits() {
  function close_semaphore_prevents_acquire (line 186) | fn close_semaphore_prevents_acquire() {
  function close_semaphore_notifies_permit1 (line 200) | fn close_semaphore_notifies_permit1() {
  function close_semaphore_notifies_permit2 (line 213) | fn close_semaphore_notifies_permit2() {
  function cancel_acquire_releases_permits (line 247) | fn cancel_acquire_releases_permits() {
  function release_permits_at_drop (line 263) | fn release_permits_at_drop() {
  function forget_permits_basic (line 292) | fn forget_permits_basic() {
  function update_permits_many_times (line 301) | fn update_permits_many_times() {

FILE: tokio/src/sync/watch.rs
  type Receiver (line 185) | pub struct Receiver<T> {
  type Sender (line 197) | pub struct Sender<T> {
  method clone (line 202) | fn clone(&self) -> Self {
  method default (line 212) | fn default() -> Self {
  type Ref (line 243) | pub struct Ref<'a, T> {
  function has_changed (line 291) | pub fn has_changed(&self) -> bool {
  type Shared (line 296) | struct Shared<T> {
  function fmt (line 320) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SendError (line 339) | pub struct SendError<T>(pub T);
  function fmt (line 344) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 350) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type RecvError (line 359) | pub struct RecvError(pub(super) ());
    method fmt (line 364) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type BigNotify (line 387) | pub(super) struct BigNotify {
    method new (line 394) | pub(super) fn new() -> Self {
    method notify_waiters (line 406) | pub(super) fn notify_waiters(&self) {
    method notified (line 414) | pub(super) fn notified(&self) -> Notified<'_> {
    method notified (line 421) | pub(super) fn notified(&self) -> Notified<'_> {
  constant CLOSED_BIT (line 433) | const CLOSED_BIT: usize = 1;
  constant STEP_SIZE (line 436) | const STEP_SIZE: usize = 2;
  type Version (line 440) | pub(super) struct Version(usize);
    method decrement (line 461) | pub(super) fn decrement(&mut self) {
    constant INITIAL (line 468) | pub(super) const INITIAL: Self = Version(0);
  type StateSnapshot (line 448) | pub(super) struct StateSnapshot(usize);
    method version (line 473) | pub(super) fn version(self) -> Version {
    method is_closed (line 478) | pub(super) fn is_closed(self) -> bool {
  type AtomicState (line 457) | pub(super) struct AtomicState(AtomicUsize);
    method new (line 486) | pub(super) fn new() -> Self {
    method load (line 498) | pub(super) fn load(&self) -> StateSnapshot {
    method increment_version_while_locked (line 503) | pub(super) fn increment_version_while_locked(&self) {
    method set_closed (line 512) | pub(super) fn set_closed(&self) {
  function channel (line 554) | pub fn channel<T>(init: T) -> (Sender<T>, Receiver<T>) {
  function from_shared (line 577) | fn from_shared(version: Version, shared: Arc<Shared<T>>) -> Self {
  function borrow (line 629) | pub fn borrow(&self) -> Ref<'_, T> {
  function borrow_and_update (line 676) | pub fn borrow_and_update(&mut self) -> Ref<'_, T> {
  function has_changed (line 738) | pub fn has_changed(&self) -> Result<bool, error::RecvError> {
  function mark_changed (line 758) | pub fn mark_changed(&mut self) {
  function mark_unchanged (line 768) | pub fn mark_unchanged(&mut self) {
  function changed (line 818) | pub async fn changed(&mut self) -> Result<(), error::RecvError> {
  function wait_for (line 889) | pub async fn wait_for(
  function wait_for_inner (line 896) | async fn wait_for_inner(
  function same_channel (line 950) | pub fn same_channel(&self, other: &Self) -> bool {
  function maybe_changed (line 961) | fn maybe_changed<T>(
  function changed_impl (line 983) | async fn changed_impl<T>(
  method clone (line 1005) | fn clone(&self) -> Self {
  method drop (line 1014) | fn drop(&mut self) {
  function new (line 1041) | pub fn new(init: T) -> Self {
  function send (line 1064) | pub fn send(&self, value: T) -> Result<(), error::SendError<T>> {
  function send_modify (line 1104) | pub fn send_modify<F>(&self, modify: F)
  function send_if_modified (line 1171) | pub fn send_if_modified<F>(&self, modify: F) -> bool
  function send_replace (line 1229) | pub fn send_replace(&self, mut value: T) -> T {
  function borrow (line 1253) | pub fn borrow(&self) -> Ref<'_, T> {
  function is_closed (line 1274) | pub fn is_closed(&self) -> bool {
  function closed (line 1313) | pub async fn closed(&self) {
  function subscribe (line 1387) | pub fn subscribe(&self) -> Receiver<T> {
  function receiver_count (line 1414) | pub fn receiver_count(&self) -> usize {
  function sender_count (line 1437) | pub fn sender_count(&self) -> usize {
  function same_channel (line 1453) | pub fn same_channel(&self, other: &Self) -> bool {
  method drop (line 1459) | fn drop(&mut self) {
  type Target (line 1470) | type Target = T;
  function deref (line 1472) | fn deref(&self) -> &T {
  function watch_spurious_wakeup (line 1484) | fn watch_spurious_wakeup() {
  function watch_borrow (line 1518) | fn watch_borrow() {

FILE: tokio/src/task/builder.rs
  type Builder (line 63) | pub struct Builder<'a> {
  function new (line 69) | pub fn new() -> Self {
  function name (line 74) | pub fn name(&self, name: &'a str) -> Self {
  function spawn (line 87) | pub fn spawn<Fut>(self, future: Fut) -> io::Result<JoinHandle<Fut::Output>>
  function spawn_on (line 108) | pub fn spawn_on<Fut>(self, future: Fut, handle: &Handle) -> io::Result<J...
  function spawn_local (line 139) | pub fn spawn_local<Fut>(self, future: Fut) -> io::Result<JoinHandle<Fut:...
  function spawn_local_on (line 160) | pub fn spawn_local_on<Fut>(
  function spawn_blocking (line 186) | pub fn spawn_blocking<Function, Output>(
  function spawn_blocking_on (line 205) | pub fn spawn_blocking_on<Function, Output>(

FILE: tokio/src/task/coop/consume_budget.rs
  function consume_budget (line 25) | pub async fn consume_budget() {

FILE: tokio/src/task/coop/mod.rs
  type Budget (line 97) | pub(crate) struct Budget(Option<u8>);
    method initial (line 115) | const fn initial() -> Budget {
    method unconstrained (line 120) | pub(crate) const fn unconstrained() -> Budget {
    method has_remaining (line 124) | fn has_remaining(self) -> bool {
  type BudgetDecrement (line 99) | pub(crate) struct BudgetDecrement {
  function budget (line 132) | pub(crate) fn budget<R>(f: impl FnOnce() -> R) -> R {
  function with_unconstrained (line 139) | pub(crate) fn with_unconstrained<R>(f: impl FnOnce() -> R) -> R {
  function with_budget (line 144) | fn with_budget<R>(budget: Budget, f: impl FnOnce() -> R) -> R {
  function has_budget_remaining (line 223) | pub fn has_budget_remaining() -> bool {
  function get (line 502) | fn get() -> Budget {
  function budgeting (line 507) | fn budgeting() {

FILE: tokio/src/task/coop/unconstrained.rs
  type Output (line 20) | type Output = <F as Future>::Output;
  function unconstrained (line 43) | pub fn unconstrained<F>(inner: F) -> Unconstrained<F> {

FILE: tokio/src/task/join_set.rs
  type JoinSet (line 64) | pub struct JoinSet<T> {
  type Builder (line 75) | pub struct Builder<'a, T> {
  function new (line 82) | pub fn new() -> Self {
  function len (line 89) | pub fn len(&self) -> usize {
  function is_empty (line 94) | pub fn is_empty(&self) -> bool {
  function build_task (line 122) | pub fn build_task(&mut self) -> Builder<'_, T> {
  function spawn (line 142) | pub fn spawn<F>(&mut self, task: F) -> AbortHandle
  function spawn_on (line 161) | pub fn spawn_on<F>(&mut self, task: F, handle: &Handle) -> AbortHandle
  function spawn_local (line 186) | pub fn spawn_local<F>(&mut self, task: F) -> AbortHandle
  function spawn_local_on (line 206) | pub fn spawn_local_on<F>(&mut self, task: F, local_set: &LocalSet) -> Ab...
  function spawn_blocking (line 254) | pub fn spawn_blocking<F>(&mut self, f: F) -> AbortHandle
  function spawn_blocking_on (line 269) | pub fn spawn_blocking_on<F>(&mut self, f: F, handle: &Handle) -> AbortHa...
  function insert (line 278) | fn insert(&mut self, jh: JoinHandle<T>) -> AbortHandle {
  function join_next (line 296) | pub async fn join_next(&mut self) -> Option<Result<T, JoinError>> {
  function join_next_with_id (line 316) | pub async fn join_next_with_id(&mut self) -> Option<Result<(Id, T), Join...
  function try_join_next (line 323) | pub fn try_join_next(&mut self) -> Option<Result<T, JoinError>> {
  function try_join_next_with_id (line 352) | pub fn try_join_next_with_id(&mut self) -> Option<Result<(Id, T), JoinEr...
  function shutdown (line 381) | pub async fn shutdown(&mut self) {
  function join_all (line 446) | pub async fn join_all(mut self) -> Vec<T> {
  function abort_all (line 463) | pub fn abort_all(&mut self) {
  function detach_all (line 471) | pub fn detach_all(&mut self) {
  function poll_join_next (line 500) | pub fn poll_join_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Re...
  function poll_join_next_with_id (line 556) | pub fn poll_join_next_with_id(
  method drop (line 592) | fn drop(&mut self) {
  function fmt (line 598) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 604) | fn default() -> Self {
  function from_iter (line 643) | fn from_iter<I: IntoIterator<Item = F>>(iter: I) -> Self {
  function extend (line 687) | fn extend<I>(&mut self, iter: I)
  function name (line 703) | pub fn name(self, name: &'a str) -> Self {
  function spawn (line 722) | pub fn spawn<F>(self, future: F) -> std::io::Result<AbortHandle>
  function spawn_on (line 742) | pub fn spawn_on<F>(self, future: F, handle: &Handle) -> std::io::Result<...
  function spawn_blocking (line 765) | pub fn spawn_blocking<F>(self, f: F) -> std::io::Result<AbortHandle>
  function spawn_blocking_on (line 785) | pub fn spawn_blocking_on<F>(self, f: F, handle: &Handle) -> std::io::Res...
  function spawn_local (line 811) | pub fn spawn_local<F>(self, future: F) -> std::io::Result<AbortHandle>
  function spawn_local_on (line 829) | pub fn spawn_local_on<F>(self, future: F, local_set: &LocalSet) -> std::...
  function fmt (line 845) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tokio/src/task/local.rs
  type Context (line 237) | struct Context {
    method spawn (line 1031) | fn spawn<F>(&self, future: F, meta: SpawnMeta<'_>) -> JoinHandle<F::Ou...
  type Shared (line 247) | struct Shared {
    method schedule (line 1093) | fn schedule(&self, task: task::Notified<Arc<Self>>) {
    method ptr_eq (line 1136) | fn ptr_eq(&self, other: &Shared) -> bool {
  type LocalState (line 267) | struct LocalState {
    method task_pop_front (line 1193) | unsafe fn task_pop_front(&self) -> Option<task::Notified<Arc<Shared>>> {
    method task_push_back (line 1206) | unsafe fn task_push_back(&self, task: task::Notified<Arc<Shared>>) {
    method take_local_queue (line 1219) | unsafe fn take_local_queue(&self) -> VecDeque<task::Notified<Arc<Share...
    method task_remove (line 1228) | unsafe fn task_remove(&self, task: &Task<Arc<Shared>>) -> Option<Task<...
    method owned_is_empty (line 1237) | unsafe fn owned_is_empty(&self) -> bool {
    method assert_owner (line 1245) | unsafe fn assert_owner(
    method close_and_shutdown_all (line 1256) | unsafe fn close_and_shutdown_all(&self) {
    method assert_called_from_owner_thread (line 1265) | fn assert_called_from_owner_thread(&self) {
  type LocalData (line 292) | struct LocalData {
    method enter (line 301) | fn enter(&self, ctx: Rc<Context>) -> LocalDataEnterGuard<'_> {
  type LocalDataEnterGuard (line 313) | struct LocalDataEnterGuard<'a> {
  method drop (line 320) | fn drop(&mut self) {
  constant INITIAL_CAPACITY (line 467) | const INITIAL_CAPACITY: usize = 64;
  constant MAX_TASKS_PER_TICK (line 470) | const MAX_TASKS_PER_TICK: usize = 61;
  constant REMOTE_FIRST_INTERVAL (line 473) | const REMOTE_FIRST_INTERVAL: u8 = 31;
  type LocalEnterGuard (line 476) | pub struct LocalEnterGuard {
    method fmt (line 500) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 486) | fn drop(&mut self) {
  method new (line 507) | pub fn new() -> LocalSet {
  method enter (line 536) | pub fn enter(&self) -> LocalEnterGuard {
  method spawn_local (line 595) | pub fn spawn_local<F>(&self, future: F) -> JoinHandle<F::Output>
  method block_on (line 676) | pub fn block_on<F>(&self, rt: &crate::runtime::Runtime, future: F) -> F:...
  method run_until (line 715) | pub async fn run_until<F>(&self, future: F) -> F::Output
  method spawn_named (line 727) | pub(in crate::task) fn spawn_named<F>(
  method spawn_named_inner (line 740) | fn spawn_named_inner<F>(&self, future: F, meta: SpawnMeta<'_>) -> JoinHa...
  method tick (line 759) | fn tick(&self) -> bool {
  method next_task (line 784) | fn next_task(&self) -> Option<task::LocalNotified<Arc<Shared>>> {
  method pop_local (line 815) | fn pop_local(&self) -> Option<task::Notified<Arc<Shared>>> {
  method with (line 824) | fn with<T>(&self, f: impl FnOnce() -> T) -> T {
  method with_if_possible (line 833) | fn with_if_possible<T>(&self, f: impl FnOnce() -> T) -> T {
  method id (line 862) | pub fn id(&self) -> runtime::Id {
  method fmt (line 939) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 945) | type Output = ();
  method poll (line 947) | fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<S...
  method default (line 974) | fn default() -> LocalSet {
  method drop (line 980) | fn drop(&mut self) {
  type Output (line 1061) | type Output = T::Output;
  method poll (line 1063) | fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<S...
  function release (line 1146) | fn release(&self, task: &Task<Self>) -> Option<Task<Self>> {
  function schedule (line 1151) | fn schedule(&self, task: task::Notified<Self>) {
  function hooks (line 1156) | fn hooks(&self) -> TaskHarnessScheduleHooks {
  function local_current_thread_scheduler (line 1295) | fn local_current_thread_scheduler() {
  function wakes_to_local_queue (line 1317) | fn wakes_to_local_queue() {

FILE: tokio/src/task/task_local.rs
  type LocalKey (line 99) | pub struct LocalKey<T: 'static> {
  function scope (line 130) | pub fn scope<F>(&'static self, value: T, f: F) -> TaskLocalFuture<T, F>
  function sync_scope (line 168) | pub fn sync_scope<F, R>(&'static self, value: T, f: F) -> R
  function scope_inner (line 179) | fn scope_inner<F, R>(&'static self, slot: &mut Option<T>, f: F) -> Resul...
  function with (line 230) | pub fn with<F, R>(&'static self, f: F) -> R
  function try_with (line 245) | pub fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError>
  function get (line 275) | pub fn get(&'static self) -> T {
  function try_get (line 285) | pub fn try_get(&'static self) -> Result<T, AccessError> {
  function fmt (line 291) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function take_value (line 383) | pub fn take_value(self: Pin<&mut Self>) -> Option<T> {
  type Output (line 390) | type Output = F::Output;
  method poll (line 393) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function fmt (line 422) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AccessError (line 445) | pub struct AccessError {
    method fmt (line 450) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 456) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ScopeInnerErr (line 463) | enum ScopeInnerErr {
    method panic (line 470) | fn panic(&self) -> ! {
    method from (line 479) | fn from(_: std::cell::BorrowMutError) -> Self {
    method from (line 485) | fn from(_: std::thread::AccessError) -> Self {

FILE: tokio/src/task/yield_now.rs
  function yield_now (line 38) | pub async fn yield_now() {

FILE: tokio/src/time/error.rs
  type Error (line 26) | pub struct Error(Kind);
    method from (line 37) | fn from(k: Kind) -> Self {
    method shutdown (line 58) | pub fn shutdown() -> Error {
    method is_shutdown (line 63) | pub fn is_shutdown(&self) -> bool {
    method at_capacity (line 68) | pub fn at_capacity() -> Error {
    method is_at_capacity (line 73) | pub fn is_at_capacity(&self) -> bool {
    method invalid (line 78) | pub fn invalid() -> Error {
    method is_invalid (line 83) | pub fn is_invalid(&self) -> bool {
    method fmt (line 91) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 30) | pub(crate) enum Kind {
  type Elapsed (line 47) | pub struct Elapsed(());
    method new (line 106) | pub(crate) fn new() -> Self {
    method fmt (line 112) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InsertError (line 50) | pub(crate) enum InsertError {
  function from (line 120) | fn from(_err: Elapsed) -> std::io::Error {

FILE: tokio/src/time/instant.rs
  type Instant (line 34) | pub struct Instant {
    method now (line 48) | pub fn now() -> Instant {
    method from_std (line 53) | pub fn from_std(std: std::time::Instant) -> Instant {
    method far_future (line 57) | pub(crate) fn far_future() -> Instant {
    method into_std (line 66) | pub fn into_std(self) -> std::time::Instant {
    method duration_since (line 72) | pub fn duration_since(&self, earlier: Instant) -> Duration {
    method checked_duration_since (line 93) | pub fn checked_duration_since(&self, earlier: Instant) -> Option<Durat...
    method saturating_duration_since (line 114) | pub fn saturating_duration_since(&self, earlier: Instant) -> Duration {
    method elapsed (line 134) | pub fn elapsed(&self) -> Duration {
    method checked_add (line 141) | pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
    method checked_sub (line 148) | pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
    method from (line 154) | fn from(time: std::time::Instant) -> Instant {
    type Output (line 166) | type Output = Instant;
    method add (line 168) | fn add(self, other: Duration) -> Instant {
    method add_assign (line 174) | fn add_assign(&mut self, rhs: Duration) {
    type Output (line 180) | type Output = Duration;
    method sub (line 182) | fn sub(self, rhs: Instant) -> Duration {
    type Output (line 188) | type Output = Instant;
    method sub (line 190) | fn sub(self, rhs: Duration) -> Instant {
    method sub_assign (line 196) | fn sub_assign(&mut self, rhs: Duration) {
    method fmt (line 202) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 160) | fn from(time: Instant) -> std::time::Instant {
  function now (line 211) | pub(super) fn now() -> Instant {
  function now (line 220) | pub(super) fn now() -> Instant {

FILE: tokio/src/time/interval.rs
  function interval (line 73) | pub fn interval(period: Duration) -> Interval {
  function interval_at (line 108) | pub fn interval_at(start: Instant, period: Duration) -> Interval {
  function internal_interval_at (line 114) | fn internal_interval_at(
  type MissedTickBehavior (line 182) | pub enum MissedTickBehavior {
    method next_timeout (line 341) | fn next_timeout(&self, timeout: Instant, now: Instant, period: Duratio...
  method default (line 376) | fn default() -> Self {
  type Interval (line 392) | pub struct Interval {
    method tick (line 433) | pub async fn tick(&mut self) -> Instant {
    method poll_tick (line 462) | pub fn poll_tick(&mut self, cx: &mut Context<'_>) -> Poll<Instant> {
    method reset (line 524) | pub fn reset(&mut self) {
    method reset_immediately (line 556) | pub fn reset_immediately(&mut self) {
    method reset_after (line 589) | pub fn reset_after(&mut self, after: Duration) {
    method reset_at (line 625) | pub fn reset_at(&mut self, deadline: Instant) {
    method missed_tick_behavior (line 630) | pub fn missed_tick_behavior(&self) -> MissedTickBehavior {
    method set_missed_tick_behavior (line 635) | pub fn set_missed_tick_behavior(&mut self, behavior: MissedTickBehavio...
    method period (line 640) | pub fn period(&self) -> Duration {

FILE: tokio/src/time/sleep.rs
  function sleep_until (line 62) | pub fn sleep_until(deadline: Instant) -> Sleep {
  function sleep (line 123) | pub fn sleep(duration: Duration) -> Sleep {
  method new_timeout (line 250) | pub(crate) fn new_timeout(
  method far_future (line 306) | pub(crate) fn far_future(location: Option<&'static Location<'static>>) -...
  method deadline (line 311) | pub fn deadline(&self) -> Instant {
  method is_elapsed (line 318) | pub fn is_elapsed(&self) -> bool {
  method reset (line 351) | pub fn reset(self: Pin<&mut Self>, deadline: Instant) {
  method reset_without_reregister (line 363) | pub(crate) fn reset_without_reregister(self: Pin<&mut Self>, deadline: I...
  method reset_inner (line 377) | fn reset_inner(self: Pin<&mut Self>, deadline: Instant) {
  method poll_elapsed (line 417) | fn poll_elapsed(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Pol...
  type Output (line 446) | type Output = ();
  method poll (line 457) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Se...

FILE: tokio/src/time/timeout.rs
  function timeout (line 86) | pub fn timeout<F>(duration: Duration, future: F) -> Timeout<F::IntoFuture>
  function timeout_at (line 145) | pub fn timeout_at<F>(deadline: Instant, future: F) -> Timeout<F::IntoFut...
  function new_with_delay (line 170) | pub(crate) fn new_with_delay(value: T, delay: Sleep) -> Timeout<T> {
  function get_ref (line 175) | pub fn get_ref(&self) -> &T {
  function get_mut (line 180) | pub fn get_mut(&mut self) -> &mut T {
  function into_inner (line 185) | pub fn into_inner(self) -> T {
  type Output (line 194) | type Output = Result<T::Output, Elapsed>;
  method poll (line 196) | fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::...
  function poll_delay (line 212) | fn poll_delay(

FILE: tokio/src/util/as_ref.rs
  type OwnedBuf (line 4) | pub(crate) enum OwnedBuf {
    method as_ref (line 11) | fn as_ref(&self) -> &[u8] {
  function upgrade (line 20) | pub(crate) fn upgrade<B: AsRef<[u8]>>(buf: B) -> OwnedBuf {

FILE: tokio/src/util/atomic_cell.rs
  type AtomicCell (line 6) | pub(crate) struct AtomicCell<T> {
  function new (line 14) | pub(crate) fn new(data: Option<Box<T>>) -> AtomicCell<T> {
  function swap (line 20) | pub(crate) fn swap(&self, val: Option<Box<T>>) -> Option<Box<T>> {
  function set (line 25) | pub(crate) fn set(&self, val: Box<T>) {
  function take (line 29) | pub(crate) fn take(&self) -> Option<Box<T>> {
  function to_raw (line 34) | fn to_raw<T>(data: Option<Box<T>>) -> *mut T {
  function from_raw (line 38) | fn from_raw<T>(val: *mut T) -> Option<Box<T>> {
  method drop (line 47) | fn drop(&mut self) {

FILE: tokio/src/util/bit.rs
  type Pack (line 4) | pub(crate) struct Pack {
    method least_significant (line 11) | pub(crate) const fn least_significant(width: u32) -> Pack {
    method then (line 18) | pub(crate) const fn then(&self, width: u32) -> Pack {
    method width (line 26) | pub(crate) const fn width(&self) -> u32 {
    method max_value (line 31) | pub(crate) const fn max_value(&self) -> usize {
    method pack (line 35) | pub(crate) fn pack(&self, value: usize, base: usize) -> usize {
    method unpack (line 40) | pub(crate) fn unpack(&self, src: usize) -> usize {
    method fmt (line 46) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function mask_for (line 56) | pub(crate) const fn mask_for(n: u32) -> usize {
  function unpack (line 62) | pub(crate) const fn unpack(src: usize, mask: usize, shift: u32) -> usize {

FILE: tokio/src/util/blocking_check.rs
  function check_socket_for_blocking (line 7) | pub(crate) fn check_socket_for_blocking<S: AsFd>(s: &S) -> crate::io::Re...
  function check_socket_for_blocking (line 25) | pub(crate) fn check_socket_for_blocking<S>(s: &S) -> crate::io::Result<(...

FILE: tokio/src/util/cacheline.rs
  type CachePadded (line 66) | pub(crate) struct CachePadded<T> {
  function new (line 72) | pub(crate) fn new(value: T) -> CachePadded<T> {
  type Target (line 78) | type Target = T;
  method deref (line 80) | fn deref(&self) -> &T {
  method deref_mut (line 86) | fn deref_mut(&mut self) -> &mut T {

FILE: tokio/src/util/error.rs
  constant CONTEXT_MISSING_ERROR (line 5) | pub(crate) const CONTEXT_MISSING_ERROR: &str =
  constant RUNTIME_SHUTTING_DOWN_ERROR (line 9) | pub(crate) const RUNTIME_SHUTTING_DOWN_ERROR: &str =
  constant THREAD_LOCAL_DESTROYED_ERROR (line 15) | pub(crate) const THREAD_LOCAL_DESTROYED_ERROR: &str =

FILE: tokio/src/util/idle_notified_set.rs
  type LinkedList (line 19) | type LinkedList<T> =
  type IdleNotifiedSet (line 23) | pub(crate) struct IdleNotifiedSet<T> {
  type EntryInOneOfTheLists (line 38) | pub(crate) struct EntryInOneOfTheLists<'a, T> {
  type Lists (line 43) | type Lists<T> = Mutex<ListsInner<T>>;
  type ListsInner (line 49) | struct ListsInner<T> {
  type List (line 65) | enum List {
  type ListEntry (line 91) | struct ListEntry<T> {
  function new (line 128) | pub(crate) fn new() -> Self {
  function len (line 141) | pub(crate) fn len(&self) -> usize {
  function is_empty (line 145) | pub(crate) fn is_empty(&self) -> bool {
  function insert_idle (line 150) | pub(crate) fn insert_idle(&mut self, value: T) -> EntryInOneOfTheLists<'...
  function pop_notified (line 172) | pub(crate) fn pop_notified(&mut self, waker: &Waker) -> Option<EntryInOn...
  function try_pop_notified (line 208) | pub(crate) fn try_pop_notified(&mut self) -> Option<EntryInOneOfTheLists...
  function for_each (line 235) | pub(crate) fn for_each<F: FnMut(&mut T)>(&mut self, mut func: F) {
  function drain (line 281) | pub(crate) fn drain<F: FnMut(T)>(&mut self, func: F) {
  function move_to_new_list (line 349) | unsafe fn move_to_new_list<T>(from: &mut LinkedList<T>, to: &mut LinkedL...
  function remove (line 367) | pub(crate) fn remove(self) -> T {
  function with_value_and_context (line 406) | pub(crate) fn with_value_and_context<F, U>(&mut self, func: F) -> U
  method drop (line 424) | fn drop(&mut self) {
  method wake_by_ref (line 438) | fn wake_by_ref(me: &Arc<Self>) {
  method wake (line 466) | fn wake(me: Arc<Self>) {
  type Handle (line 475) | type Handle = Arc<ListEntry<T>>;
  type Target (line 476) | type Target = ListEntry<T>;
  function as_raw (line 478) | fn as_raw(handle: &Self::Handle) -> NonNull<ListEntry<T>> {
  function from_raw (line 484) | unsafe fn from_raw(ptr: NonNull<ListEntry<T>>) -> Arc<ListEntry<T>> {
  function pointers (line 488) | unsafe fn pointers(
  function join_set_test (line 504) | fn join_set_test() {

FILE: tokio/src/util/linked_list.rs
  type LinkedList (line 26) | pub(crate) struct LinkedList<L, T> {
  type Link (line 50) | pub(crate) unsafe trait Link {
    method as_raw (line 61) | fn as_raw(handle: &Self::Handle) -> NonNull<Self::Target>;
    method from_raw (line 64) | unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle;
    method pointers (line 76) | unsafe fn pointers(target: NonNull<Self::Target>) -> NonNull<Pointers<...
    type Handle (line 491) | type Handle = Pin<&'a Entry>;
    type Target (line 492) | type Target = Entry;
    method as_raw (line 494) | fn as_raw(handle: &Pin<&'_ Entry>) -> NonNull<Entry> {
    method from_raw (line 498) | unsafe fn from_raw(ptr: NonNull<Entry>) -> Pin<&'a Entry> {
    method pointers (line 502) | unsafe fn pointers(target: NonNull<Entry>) -> NonNull<Pointers<Entry>> {
  type Pointers (line 80) | pub(crate) struct Pointers<T> {
  type PointersInner (line 98) | struct PointersInner<T> {
  function new (line 117) | pub(crate) const fn new() -> LinkedList<L, T> {
  function push_front (line 128) | pub(crate) fn push_front(&mut self, val: L::Handle) {
  function pop_front (line 151) | pub(crate) fn pop_front(&mut self) -> Option<L::Handle> {
  function pop_back (line 171) | pub(crate) fn pop_back(&mut self) -> Option<L::Handle> {
  function is_empty (line 190) | pub(crate) fn is_empty(&self) -> bool {
  function remove (line 209) | pub(crate) unsafe fn remove(&mut self, node: NonNull<L::Target>) -> Opti...
  function fmt (line 245) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function last (line 261) | pub(crate) fn last(&self) -> Option<&L::Target> {
  method default (line 268) | fn default() -> Self {
  function new (line 432) | pub(crate) fn new() -> Pointers<T> {
  function get_prev (line 442) | pub(crate) fn get_prev(&self) -> Option<NonNull<T>> {
  function get_next (line 446) | pub(crate) fn get_next(&self) -> Option<NonNull<T>> {
  function set_prev (line 451) | fn set_prev(&mut self, value: Option<NonNull<T>>) {
  function set_next (line 457) | fn set_next(&mut self, value: Option<NonNull<T>>) {
  function fmt (line 466) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Entry (line 485) | struct Entry {
  function entry (line 507) | fn entry(val: i32) -> Pin<Box<Entry>> {
  function ptr (line 514) | fn ptr(r: &Pin<Box<Entry>>) -> NonNull<Entry> {
  function collect_list (line 518) | fn collect_list(list: &mut LinkedList<&'_ Entry, <&'_ Entry as Link>::Ta...
  function push_all (line 528) | fn push_all<'a>(
  function const_new (line 554) | fn const_new() {
  function push_and_drain (line 559) | fn push_and_drain() {
  function push_pop_push_pop (line 579) | fn push_pop_push_pop() {
  function remove_by_address (line 601) | fn remove_by_address() {
  function fuzz_linked_list (line 751) | pub fn fuzz_linked_list(ops: &[u8]) {

FILE: tokio/src/util/markers.rs
  type SyncNotSend (line 3) | pub(crate) struct SyncNotSend(#[allow(dead_code)] *mut ());

FILE: tokio/src/util/memchr.rs
  function memchr_inner (line 7) | fn memchr_inner(needle: u8, haystack: &[u8]) -> Option<usize> {
  function memchr_inner (line 12) | fn memchr_inner(needle: u8, haystack: &[u8]) -> Option<usize> {
  function memchr (line 36) | pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
  function memchr_test (line 58) | fn memchr_test() {
  function memchr_all (line 82) | fn memchr_all() {
  function memchr_empty (line 97) | fn memchr_empty() {

FILE: tokio/src/util/metric_atomics.rs
  type MetricAtomicU64 (line 12) | pub(crate) struct MetricAtomicU64 {
  type MetricAtomicUsize (line 54) | pub(crate) struct MetricAtomicUsize {
    method new (line 60) | pub(crate) fn new(value: usize) -> Self {
    method load (line 66) | pub(crate) fn load(&self, ordering: Ordering) -> usize {
    method store (line 70) | pub(crate) fn store(&self, val: usize, ordering: Ordering) {
    method increment (line 74) | pub(crate) fn increment(&self) -> usize {
    method decrement (line 78) | pub(crate) fn decrement(&self) -> usize {

FILE: tokio/src/util/mod.rs
  function pin_as_deref_mut (line 108) | pub(crate) fn pin_as_deref_mut<P: DerefMut>(ptr: Pin<&mut Pin<P>>) -> Pi...

FILE: tokio/src/util/ptr_expose.rs
  type PtrExposeDomain (line 11) | pub(crate) struct PtrExposeDomain<T> {
  function new (line 21) | pub(crate) const fn new() -> Self {
  function expose_provenance (line 30) | pub(crate) fn expose_provenance(&self, ptr: *const T) -> usize {
  function from_exposed_addr (line 46) | pub(crate) fn from_exposed_addr(&self, addr: usize) -> *const T {
  function unexpose_provenance (line 63) | pub(crate) fn unexpose_provenance(&self, _ptr: *const T) {

FILE: tokio/src/util/rand.rs
  type RngSeed (line 16) | pub struct RngSeed {
    method new (line 36) | pub(crate) fn new() -> Self {
    method from_u64 (line 40) | fn from_u64(seed: u64) -> Self {
    method from_pair (line 52) | fn from_pair(s: u32, r: u32) -> Self {
  type FastRand (line 29) | pub(crate) struct FastRand {
    method new (line 59) | pub(crate) fn new() -> FastRand {
    method from_seed (line 64) | pub(crate) fn from_seed(seed: RngSeed) -> FastRand {
    method fastrand_n (line 76) | pub(crate) fn fastrand_n(&mut self, n: u32) -> u32 {
    method fastrand (line 83) | fn fastrand(&mut self) -> u32 {

FILE: tokio/src/util/rand/rt.rs
  type RngSeedGenerator (line 14) | pub(crate) struct RngSeedGenerator {
    method new (line 22) | pub(crate) fn new(seed: RngSeed) -> Self {
    method next_seed (line 29) | pub(crate) fn next_seed(&self) -> RngSeed {
    method next_generator (line 42) | pub(crate) fn next_generator(&self) -> Self {
  method replace_seed (line 53) | pub(crate) fn replace_seed(&mut self, seed: RngSeed) -> RngSeed {

FILE: tokio/src/util/rand/rt_unstable.rs
  method from_bytes (line 15) | pub fn from_bytes(bytes: &[u8]) -> Self {

FILE: tokio/src/util/rc_cell.rs
  type RcCell (line 7) | pub(crate) struct RcCell<T> {
  function new (line 13) | pub(crate) const fn new() -> Self {
  function new (line 21) | pub(crate) fn new() -> Self {
  function with_inner (line 29) | unsafe fn with_inner<F, R>(&self, f: F) -> R
  function get (line 41) | pub(crate) fn get(&self) -> Option<Rc<T>> {
  function replace (line 47) | pub(crate) fn replace(&self, val: Option<Rc<T>>) -> Option<Rc<T>> {
  function set (line 53) | pub(crate) fn set(&self, val: Option<Rc<T>>) {

FILE: tokio/src/util/sharded_list.rs
  type ShardedList (line 15) | pub(crate) struct ShardedList<L, T> {
  type ShardedListItem (line 28) | pub(crate) unsafe trait ShardedListItem: Link {
    method get_shard_id (line 32) | unsafe fn get_shard_id(target: NonNull<Self::Target>) -> usize;
  function new (line 37) | pub(crate) fn new(sharded_size: usize) -> Self {
  type ShardGuard (line 55) | pub(crate) struct ShardGuard<'a, L, T> {
  function pop_back (line 65) | pub(crate) fn pop_back(&self, shard_id: usize) -> Option<L::Handle> {
  function remove (line 82) | pub(crate) unsafe fn remove(&self, node: NonNull<L::Target>) -> Option<L...
  function lock_shard (line 95) | pub(crate) fn lock_shard(&self, val: &L::Handle) -> ShardGuard<'_, L, L:...
  function len (line 106) | pub(crate) fn len(&self) -> usize {
  function is_empty (line 120) | pub(crate) fn is_empty(&self) -> bool {
  function shard_size (line 127) | pub(crate) fn shard_size(&self) -> usize {
  function shard_inner (line 132) | fn shard_inner(&self, id: usize) -> MutexGuard<'_, LinkedList<L, <L as L...
  function push (line 140) | pub(crate) fn push(mut self, val: L::Handle) {

FILE: tokio/src/util/sync_wrapper.rs
  type SyncWrapper (line 8) | pub(crate) struct SyncWrapper<T> {
  function new (line 21) | pub(crate) fn new(value: T) -> Self {
  function into_inner (line 25) | pub(crate) fn into_inner(self) -> T {
  function downcast_ref_sync (line 32) | pub(crate) fn downcast_ref_sync<T: Any + Sync>(&self) -> Option<&T> {

FILE: tokio/src/util/try_lock.rs
  type TryLock (line 8) | pub(crate) struct TryLock<T> {
  type LockGuard (line 13) | pub(crate) struct LockGuard<'a, T> {
  function new (line 35) | pub(crate) const fn new(data: T) -> TryLock<T> {
  function new (line 41) | pub(crate) fn new(data: T) -> TryLock<T> {
  function try_lock (line 46) | pub(crate) fn try_lock(&self) -> Option<LockGuard<'_, T>> {
  type Target (line 63) | type Target = T;
  method deref (line 65) | fn deref(&self) -> &T {
  method deref_mut (line 71) | fn deref_mut(&mut self) -> &mut T {
  method drop (line 77) | fn drop(&mut self) {

FILE: tokio/src/util/typeid.rs
  function try_transmute (line 9) | pub(super) unsafe fn try_transmute<Src, Target: 'static>(x: Src) -> Resu...
  function nonstatic_typeid (line 21) | fn nonstatic_typeid<T>() -> TypeId

FILE: tokio/src/util/wake.rs
  type Wake (line 9) | pub(crate) trait Wake: Send + Sync + Sized + 'static {
    method wake (line 11) | fn wake(arc_self: Arc<Self>);
    method wake_by_ref (line 14) | fn wake_by_ref(arc_self: &Arc<Self>);
  type WakerRef (line 19) | pub(crate) struct WakerRef<'a> {
  type Target (line 25) | type Target = Waker;
  method deref (line 27) | fn deref(&self) -> &Waker {
  function waker_ref (line 33) | pub(crate) fn waker_ref<W: Wake>(wake: &Arc<W>) -> WakerRef<'_> {
  function waker_vtable (line 44) | fn waker_vtable<W: Wake>() -> &'static RawWakerVTable {
  function clone_arc_raw (line 53) | unsafe fn clone_arc_raw<T: Wake>(data: *const ()) -> RawWaker {
  function wake_arc_raw (line 61) | unsafe fn wake_arc_raw<T: Wake>(data: *const ()) {
  function wake_by_ref_arc_raw (line 68) | unsafe fn wake_by_ref_arc_raw<T: Wake>(data: *const ()) {
  function drop_arc_raw (line 75) | unsafe fn drop_arc_raw<T: Wake>(data: *const ()) {

FILE: tokio/src/util/wake_list.rs
  constant NUM_WAKERS (line 5) | const NUM_WAKERS: usize = 32;
  type WakeList (line 12) | pub(crate) struct WakeList {
    method new (line 18) | pub(crate) fn new() -> Self {
    method can_push (line 28) | pub(crate) fn can_push(&self) -> bool {
    method push (line 32) | pub(crate) fn push(&mut self, val: Waker) {
    method wake_all (line 39) | pub(crate) fn wake_all(&mut self) {
  method drop (line 77) | fn drop(&mut self) {

FILE: tokio/tests/async_send_sync.rs
  type YY (line 18) | struct YY {}
  type YN (line 23) | struct YN {
  type NN (line 30) | struct NN {
  type BoxFutureSync (line 35) | type BoxFutureSync<T> = std::pin::Pin<Box<dyn std::future::Future<Output...
  type BoxFutureSend (line 37) | type BoxFutureSend<T> = std::pin::Pin<Box<dyn std::future::Future<Output...
  type BoxFuture (line 39) | type BoxFuture<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T...
  type BoxAsyncRead (line 42) | type BoxAsyncRead = std::pin::Pin<Box<dyn tokio::io::AsyncBufRead + Send...
  type BoxAsyncSeek (line 44) | type BoxAsyncSeek = std::pin::Pin<Box<dyn tokio::io::AsyncSeek + Send + ...
  type BoxAsyncWrite (line 46) | type BoxAsyncWrite = std::pin::Pin<Box<dyn tokio::io::AsyncWrite + Send ...
  function require_send (line 49) | fn require_send<T: Send>(_t: &T) {}
  function require_sync (line 51) | fn require_sync<T: Sync>(_t: &T) {}
  function require_unpin (line 53) | fn require_unpin<T: Unpin>(_t: &T) {}
  type Invalid (line 56) | struct Invalid;
  type AmbiguousIfSend (line 59) | trait AmbiguousIfSend<A> {
    method some_item (line 60) | fn some_item(&self) {}
  type AmbiguousIfSync (line 66) | trait AmbiguousIfSync<A> {
    method some_item (line 67) | fn some_item(&self) {}
  type AmbiguousIfUnpin (line 73) | trait AmbiguousIfUnpin<A> {
    method some_item (line 74) | fn some_item(&self) {}
  constant _ (line 148) | const _: fn() = || {
  type ImplsFd (line 739) | struct ImplsFd<T> {
  function as_raw_fd (line 743) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {

FILE: tokio/tests/buffered.rs
  function echo_server (line 13) | async fn echo_server() {

FILE: tokio/tests/coop_budget.rs
  constant BUDGET (line 9) | const BUDGET: usize = 128;
  function coop_budget_udp_send_recv (line 29) | async fn coop_budget_udp_send_recv() {
  function test_has_budget_remaining (line 83) | async fn test_has_budget_remaining() {

FILE: tokio/tests/dump.rs
  function a (line 12) | async fn a() {
  function b (line 17) | async fn b() {
  function c (line 22) | async fn c() {
  function current_thread (line 29) | fn current_thread() {
  function multi_thread (line 66) | fn multi_thread() {
  function complete_during_trace (line 113) | fn complete_during_trace() -> impl Future<Output = ()> + Send {
  function current_thread (line 126) | fn current_thread() {
  function multi_thread (line 143) | fn multi_thread() {
  function notified_during_tracing (line 167) | fn notified_during_tracing() {

FILE: tokio/tests/duplex_stream.rs
  constant HELLO (line 7) | const HELLO: &[u8] = b"hello world...";
  function write_vectored (line 10) | async fn write_vectored() {
  function write_vectored_and_shutdown (line 30) | async fn write_vectored_and_shutdown() {

FILE: tokio/tests/fs.rs
  function path_read_write (line 8) | async fn path_read_write() {
  function try_clone_should_preserve_max_buf_size (line 19) | async fn try_clone_should_preserve_max_buf_size() {
  function tempdir (line 34) | fn tempdir() -> tempfile::TempDir {

FILE: tokio/tests/fs_canonicalize_dir.rs
  function canonicalize_root_dir_unix (line 8) | async fn canonicalize_root_dir_unix() {
  function canonicalize_root_dir_windows (line 14) | async fn canonicalize_root_dir_windows() {

FILE: tokio/tests/fs_copy.rs
  function copy (line 9) | async fn copy() {
  function copy_permissions (line 26) | async fn copy_permissions() {

FILE: tokio/tests/fs_dir.rs
  function create_dir (line 11) | async fn create_dir() {
  function create_all (line 22) | async fn create_all() {
  function build_dir (line 32) | async fn build_dir() {
  function build_dir_mode_read_only (line 50) | async fn build_dir_mode_read_only() {
  function remove (line 70) | async fn remove() {
  function read_inherent (line 82) | async fn read_inherent() {
  function read_dir_entry_info (line 111) | async fn read_dir_entry_info() {

FILE: tokio/tests/fs_file.rs
  constant HELLO (line 12) | const HELLO: &[u8] = b"hello world...";
  function basic_read (line 15) | async fn basic_read() {
  function basic_write (line 29) | async fn basic_write() {
  function basic_write_and_shutdown (line 42) | async fn basic_write_and_shutdown() {
  function write_vectored (line 55) | async fn write_vectored() {
  function write_vectored_and_shutdown (line 72) | async fn write_vectored_and_shutdown() {
  function rewind_seek_position (line 89) | async fn rewind_seek_position() {
  function coop (line 102) | async fn coop() {
  function write_to_clone (line 127) | async fn write_to_clone() {
  function write_into_std (line 141) | async fn write_into_std() {
  function write_into_std_immediate (line 154) | async fn write_into_std_immediate() {
  function read_file_from_std (line 167) | async fn read_file_from_std() {
  function empty_read (line 181) | async fn empty_read() {
  function tempfile (line 198) | fn tempfile() -> NamedTempFile {
  function set_max_buf_size_read (line 203) | async fn set_max_buf_size_read() {
  function set_max_buf_size_write (line 215) | async fn set_max_buf_size_write() {
  function file_debug_fmt (line 227) | async fn file_debug_fmt() {
  function file_debug_fmt (line 240) | async fn file_debug_fmt() {
  function unix_fd_is_valid (line 253) | async fn unix_fd_is_valid() {
  function read_file_from_unix_fd (line 263) | async fn read_file_from_unix_fd() {
  function windows_handle (line 283) | async fn windows_handle() {

FILE: tokio/tests/fs_link.rs
  function test_hard_link (line 11) | async fn test_hard_link() {
  function test_symlink (line 37) | async fn test_symlink() {
  function test_hard_link_error_source_not_found (line 66) | async fn test_hard_link_error_source_not_found() {
  function test_hard_link_error_destination_already_exists (line 77) | async fn test_hard_link_error_destination_already_exists() {
  function test_hard_link_error_source_is_directory (line 95) | async fn test_hard_link_error_source_is_directory() {

FILE: tokio/tests/fs_open_options.rs
  constant HELLO (line 9) | const HELLO: &[u8] = b"hello world...";
  function open_with_open_options_and_read (line 12) | async fn open_with_open_options_and_read() {
  function open_options_write (line 26) | async fn open_options_write() {
  function open_options_append (line 32) | async fn open_options_append() {
  function open_options_truncate (line 38) | async fn open_options_truncate() {
  function open_options_create (line 44) | async fn open_options_create() {
  function open_options_create_new (line 50) | async fn open_options_create_new() {
  function open_options_mode (line 57) | async fn open_options_mode() {
  function open_options_custom_flags_linux (line 68) | async fn open_options_custom_flags_linux() {
  function open_options_custom_flags_bsd_family (line 78) | async fn open_options_custom_flags_bsd_family() {

FILE: tokio/tests/fs_open_options_windows.rs
  function open_options_windows_access_mode (line 10) | async fn open_options_windows_access_mode() {
  function open_options_windows_share_mode (line 17) | async fn open_options_windows_share_mode() {
  function open_options_windows_custom_flags (line 24) | async fn open_options_windows_custom_flags() {
  function open_options_windows_attributes (line 35) | async fn open_options_windows_attributes() {
  function open_options_windows_security_qos_flags (line 45) | async fn open_options_windows_security_qos_flags() {

FILE: tokio/tests/fs_remove_dir_all.rs
  function remove_dir_all (line 8) | async fn remove_dir_all() {

FILE: tokio/tests/fs_remove_file.rs
  function remove_file (line 8) | async fn remove_file() {

FILE: tokio/tests/fs_rename.rs
  function rename_file (line 8) | async fn rename_file() {

FILE: tokio/tests/fs_symlink_dir_windows.rs
  function symlink_file_windows (line 9) | async fn symlink_file_windows() {

FILE: tokio/tests/fs_symlink_file_windows.rs
  function symlink_file_windows (line 9) | async fn symlink_file_windows() {

FILE: tokio/tests/fs_try_exists.rs
  function try_exists (line 9) | async fn try_exists() {

FILE: tokio/tests/fs_uring.rs
  function multi_rt (line 23) | fn multi_rt(n: usize) -> Box<dyn Fn() -> Runtime> {
  function current_rt (line 33) | fn current_rt() -> Box<dyn Fn() -> Runtime> {
  function rt_combinations (line 37) | fn rt_combinations() -> Vec<Box<dyn Fn() -> Runtime>> {
  function shutdown_runtime_while_performing_io_uring_ops (line 49) | fn shutdown_runtime_while_performing_io_uring_ops() {
  function open_many_files (line 88) | fn open_many_files() {
  function cancel_op_future (line 114) | async fn cancel_op_future() {
  function create_tmp_files (line 148) | fn create_tmp_files(num_files: usize) -> (Vec<NamedTempFile>, Vec<PathBu...

FILE: tokio/tests/fs_uring_read.rs
  function multi_rt (line 24) | fn multi_rt(n: usize) -> Box<dyn Fn() -> Runtime> {
  function current_rt (line 34) | fn current_rt() -> Box<dyn Fn() -> Runtime> {
  function rt_combinations (line 38) | fn rt_combinations() -> Vec<Box<dyn Fn() -> Runtime>> {
  function shutdown_runtime_while_performing_io_uring_ops (line 50) | fn shutdown_runtime_while_performing_io_uring_ops() {
  function read_many_files (line 93) | fn read_many_files() {
  function read_small_large_files (line 120) | async fn read_small_large_files() {
  function cancel_op_future (line 135) | async fn cancel_op_future() {
  function create_tmp_files (line 167) | fn create_tmp_files(num_files: usize) -> (Vec<NamedTempFile>, Vec<PathBu...
  function create_large_temp_file (line 180) | fn create_large_temp_file() -> (NamedTempFile, PathBuf) {
  function create_small_temp_file (line 190) | fn create_small_temp_file() -> (NamedTempFile, PathBuf) {
  function create_buf (line 200) | fn create_buf(length: usize) -> Vec<u8> {

FILE: tokio/tests/fs_write.rs
  function write (line 8) | async fn write() {

FILE: tokio/tests/io_async_fd.rs
  type TestWaker (line 24) | struct TestWaker {
    method new (line 41) | fn new() -> Self {
    method awoken (line 50) | fn awoken(&self) -> bool {
    method context (line 54) | fn context(&self) -> Context<'_> {
  type TestWakerInner (line 30) | struct TestWakerInner {
    method wake_by_ref (line 35) | fn wake_by_ref(arc_self: &Arc<Self>) {
  type FileDescriptor (line 60) | struct FileDescriptor {
  method as_raw_fd (line 65) | fn as_raw_fd(&self) -> RawFd {
  method read (line 71) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method read (line 77) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method write (line 83) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 87) | fn flush(&mut self) -> io::Result<()> {
  method write (line 93) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 97) | fn flush(&mut self) -> io::Result<()> {
  function set_nonblocking (line 102) | fn set_nonblocking(fd: RawFd) {
  function socketpair (line 120) | fn socketpair() -> (FileDescriptor, FileDescriptor) {
  function drain (line 138) | fn drain(mut fd: &FileDescriptor, mut amt: usize) {
  function initially_writable (line 151) | async fn initially_writable() {
  function reset_readable (line 169) | async fn reset_readable() {
  function reset_writable (line 213) | async fn reset_writable() {
  type ArcFd (line 242) | struct ArcFd<T>(Arc<T>);
  method as_raw_fd (line 244) | fn as_raw_fd(&self) -> RawFd {
  function drop_closes (line 250) | async fn drop_closes() {
  function reregister (line 290) | async fn reregister() {
  function guard_try_io (line 299) | async fn guard_try_io() {
  function try_io_readable (line 334) | async fn try_io_readable() {
  function try_io_writable (line 393) | async fn try_io_writable() {
  function multiple_waiters (line 434) | async fn multiple_waiters() {
  function poll_fns (line 482) | async fn poll_fns() {
  function assert_pending (line 557) | fn assert_pending<T: std::fmt::Debug, F: Future<Output = T>>(f: F) -> st...
  function rt (line 567) | fn rt() -> tokio::runtime::Runtime {
  function driver_shutdown_wakes_currently_pending (line 575) | fn driver_shutdown_wakes_currently_pending() {
  function driver_shutdown_wakes_future_pending (line 596) | fn driver_shutdown_wakes_future_pending() {
  function driver_shutdown_wakes_pending_race (line 611) | fn driver_shutdown_wakes_pending_race() {
  function poll_readable (line 632) | async fn poll_readable<T: AsRawFd>(fd: &AsyncFd<T>) -> std::io::Result<A...
  function poll_writable (line 636) | async fn poll_writable<T: AsRawFd>(fd: &AsyncFd<T>) -> std::io::Result<A...
  function driver_shutdown_wakes_currently_pending_polls (line 641) | fn driver_shutdown_wakes_currently_pending_polls() {
  function driver_shutdown_wakes_poll (line 663) | fn driver_shutdown_wakes_poll() {
  function driver_shutdown_then_clear_readiness (line 679) | fn driver_shutdown_then_clear_readiness() {
  function driver_shutdown_wakes_poll_race (line 696) | fn driver_shutdown_wakes_poll_race() {
  function priority_event_on_oob_data (line 720) | async fn priority_event_on_oob_data() {
  function send_oob_data (line 742) | fn send_oob_data<S: AsRawFd>(stream: &S, data: &[u8]) -> io::Result<usiz...
  function clear_ready_matching_clears_ready (line 759) | async fn clear_ready_matching_clears_ready() {
  function clear_ready_matching_clears_ready_mut (line 782) | async fn clear_ready_matching_clears_ready_mut() {
  function await_error_readiness_timestamping (line 807) | async fn await_error_readiness_timestamping() {
  function configure_timestamping_socket (line 840) | fn configure_timestamping_socket(udp_socket: &std::net::UdpSocket) -> st...
  function await_error_readiness_invalid_address (line 864) | async fn await_error_readiness_invalid_address() {
  type InvalidSource (line 932) | struct InvalidSource;
  method as_raw_fd (line 935) | fn as_raw_fd(&self) -> RawFd {
  function try_new (line 941) | async fn try_new() {
  function try_with_interest (line 951) | async fn try_with_interest() {

FILE: tokio/tests/io_async_fd_memory_leak.rs
  type TrackingAllocator (line 12) | struct TrackingAllocator {
    method new (line 17) | const fn new() -> Self {
  method alloc (line 25) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
  method dealloc (line 33) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  method realloc (line 38) | unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) ...
  function allocated_bytes (line 57) | fn allocated_bytes() -> usize {
  function memory_leak_when_fd_closed_before_drop (line 62) | async fn memory_leak_when_fd_closed_before_drop() {

FILE: tokio/tests/io_async_read.rs
  function assert_obj_safe (line 7) | fn assert_obj_safe() {

FILE: tokio/tests/io_buf_reader.rs
  type MaybePending (line 28) | struct MaybePending<'a> {
  function new (line 35) | fn new(inner: &'a [u8]) -> Self {
  method poll_read (line 45) | fn poll_read(
  method poll_fill_buf (line 62) | fn poll_fill_buf(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<...
  method consume (line 76) | fn consume(mut self: Pin<&mut Self>, amt: usize) {
  function test_buffered_reader (line 82) | async fn test_buffered_reader() {
  function test_buffered_reader_seek (line 119) | async fn test_buffered_reader_seek() {
  function test_buffered_reader_seek_underflow (line 134) | async fn test_buffered_reader_seek_underflow() {
  function test_short_reads (line 192) | async fn test_short_reads() {
  function maybe_pending (line 226) | async fn maybe_pending() {
  function maybe_pending_buf_read (line 263) | async fn maybe_pending_buf_read() {
  function maybe_pending_seek (line 282) | async fn maybe_pending_seek() {
  function test_fill_buf_wrapper (line 356) | async fn test_fill_buf_wrapper() {

FILE: tokio/tests/io_buf_writer.rs
  type MaybePending (line 22) | struct MaybePending {
    method new (line 28) | fn new(inner: Vec<u8>) -> Self {
  method poll_write (line 37) | fn poll_write(
  method poll_flush (line 52) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 56) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  function write_vectored (line 61) | async fn write_vectored<W>(writer: &mut W, bufs: &[IoSlice<'_>]) -> io::...
  function buf_writer (line 70) | async fn buf_writer() {
  function buf_writer_inner_flushes (line 112) | async fn buf_writer_inner_flushes() {
  function buf_writer_seek (line 122) | async fn buf_writer_seek() {
  function maybe_pending_buf_writer (line 135) | async fn maybe_pending_buf_writer() {
  function maybe_pending_buf_writer_inner_flushes (line 183) | async fn maybe_pending_buf_writer_inner_flushes() {
  function maybe_pending_buf_writer_seek (line 193) | async fn maybe_pending_buf_writer_seek() {
  type MockWriter (line 272) | struct MockWriter {
    method new (line 279) | fn new(write_len: usize) -> Self {
    method vectored (line 287) | fn vectored(write_len: usize) -> Self {
    method write_up_to (line 295) | fn write_up_to(&mut self, buf: &[u8], limit: usize) -> usize {
  method poll_write (line 303) | fn poll_write(
  method poll_write_vectored (line 313) | fn poll_write_vectored(
  method is_write_vectored (line 330) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 334) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<...
  method poll_shutdown (line 338) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Resu...
  function write_vectored_empty_on_non_vectored (line 344) | async fn write_vectored_empty_on_non_vectored() {
  function write_vectored_empty_on_vectored (line 358) | async fn write_vectored_empty_on_vectored() {
  function write_vectored_basic_on_non_vectored (line 372) | async fn write_vectored_basic_on_non_vectored() {
  function write_vectored_basic_on_vectored (line 388) | async fn write_vectored_basic_on_vectored() {
  function write_vectored_large_total_on_non_vectored (line 404) | async fn write_vectored_large_total_on_non_vectored() {
  function write_vectored_large_total_on_vectored (line 424) | async fn write_vectored_large_total_on_vectored() {
  type VectoredWriteHarness (line 443) | struct VectoredWriteHarness {
    method new (line 449) | fn new(buf_capacity: usize) -> Self {
    method with_vectored_backend (line 456) | fn with_vectored_backend(buf_capacity: usize) -> Self {
    method write_all (line 463) | async fn write_all<'a, 'b>(&mut self, mut io_vec: IoBufs<'a, 'b>) -> u...
    method flush (line 475) | async fn flush(&mut self) -> &[u8] {
  function write_vectored_odd_on_non_vectored (line 482) | async fn write_vectored_odd_on_non_vectored() {
  function write_vectored_odd_on_vectored (line 497) | async fn write_vectored_odd_on_vectored() {
  function write_vectored_large_slice_on_non_vectored (line 512) | async fn write_vectored_large_slice_on_non_vectored() {
  function write_vectored_large_slice_on_vectored (line 526) | async fn write_vectored_large_slice_on_vectored() {

FILE: tokio/tests/io_chain.rs
  function chain (line 8) | async fn chain() {

FILE: tokio/tests/io_copy.rs
  function copy (line 12) | async fn copy() {
  function proxy (line 40) | async fn proxy() {
  function copy_is_cooperative (line 89) | async fn copy_is_cooperative() {

FILE: tokio/tests/io_copy_bidirectional.rs
  function make_socketpair (line 9) | async fn make_socketpair() -> (TcpStream, TcpStream) {
  function block_write (line 20) | async fn block_write(s: &mut TcpStream) -> usize {
  function symmetric (line 38) | async fn symmetric<F, Fut>(mut cb: F)
  function test_basic_transfer (line 63) | async fn test_basic_transfer() {
  function test_transfer_after_close (line 75) | async fn test_transfer_after_close() {
  function blocking_one_side_does_not_block_other (line 95) | async fn blocking_one_side_does_not_block_other() {
  function immediate_exit_on_write_error (line 117) | async fn immediate_exit_on_write_error() {
  function immediate_exit_on_read_error (line 135) | async fn immediate_exit_on_read_error() {
  function copy_bidirectional_is_cooperative (line 146) | async fn copy_bidirectional_is_cooperative() {

FILE: tokio/tests/io_driver.rs
  type Task (line 16) | struct Task<T> {
  method wake_by_ref (line 21) | fn wake_by_ref(_: &Arc<Self>) {
  function new (line 27) | fn new(future: T) -> Task<T> {
  function test_drop_on_notify (line 36) | fn test_drop_on_notify() {
  function panics_when_io_disabled (line 95) | fn panics_when_io_disabled() {

FILE: tokio/tests/io_driver_drop.rs
  function tcp_doesnt_block (line 10) | fn tcp_doesnt_block() {
  function drop_wakes (line 33) | fn drop_wakes() {
  function rt (line 57) | fn rt() -> runtime::Runtime {

FILE: tokio/tests/io_fill_buf.rs
  function fill_buf_file (line 10) | async fn fill_buf_file() {

FILE: tokio/tests/io_join.rs
  type R (line 10) | struct R;
  method poll_read (line 13) | fn poll_read(
  type W (line 23) | struct W;
  method poll_write (line 26) | fn poll_write(
  method poll_flush (line 34) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 38) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...
  method poll_write_vectored (line 42) | fn poll_write_vectored(
  method is_write_vectored (line 50) | fn is_write_vectored(&self) -> bool {
  function is_send_and_sync (line 56) | fn is_send_and_sync() {
  function method_delegation (line 63) | fn method_delegation() {

FILE: tokio/tests/io_lines.rs
  function lines_inherent (line 8) | async fn lines_inherent() {

FILE: tokio/tests/io_mem_stream.rs
  function ping_pong (line 7) | async fn ping_pong() {
  function across_tasks (line 22) | async fn across_tasks() {
  function disconnect (line 44) | async fn disconnect() {
  function disconnect_reader (line 66) | async fn disconnect_reader() {
  function max_write_size (line 85) | async fn max_write_size() {
  function duplex_is_cooperative (line 105) | async fn duplex_is_cooperative() {

FILE: tokio/tests/io_panic.rs
  type RW (line 14) | struct RW;
  method poll_read (line 17) | fn poll_read(
  method poll_write (line 28) | fn poll_write(
  method poll_flush (line 36) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 40) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...
  type MockFd (line 49) | pub struct MockFd;
  method as_raw_fd (line 52) | fn as_raw_fd(&self) -> RawFd {
  function read_buf_initialize_unfilled_to_panic_caller (line 59) | fn read_buf_initialize_unfilled_to_panic_caller() -> Result<(), Box<dyn ...
  function read_buf_advance_panic_caller (line 74) | fn read_buf_advance_panic_caller() -> Result<(), Box<dyn Error>> {
  function read_buf_set_filled_panic_caller (line 89) | fn read_buf_set_filled_panic_caller() -> Result<(), Box<dyn Error>> {
  function read_buf_put_slice_panic_caller (line 104) | fn read_buf_put_slice_panic_caller() -> Result<(), Box<dyn Error>> {
  function unsplit_panic_caller (line 121) | fn unsplit_panic_caller() -> Result<(), Box<dyn Error>> {
  function async_fd_new_panic_caller (line 136) | fn async_fd_new_panic_caller() -> Result<(), Box<dyn Error>> {
  function async_fd_with_interest_panic_caller (line 158) | fn async_fd_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
  function async_fd_try_new_panic_caller (line 181) | fn async_fd_try_new_panic_caller() -> Result<(), Box<dyn Error>> {
  function async_fd_try_with_interest_panic_caller (line 203) | fn async_fd_try_with_interest_panic_caller() -> Result<(), Box<dyn Error...

FILE: tokio/tests/io_poll_aio.rs
  type TokioSource (line 21) | struct TokioSource<'fd>(mio_aio::Source<nix::sys::aio::AioFsync<'fd>>);
  method register (line 24) | fn register(&mut self, kq: RawFd, token: usize) {
  method deregister (line 27) | fn deregister(&mut self) {
  type FsyncFut (line 33) | struct FsyncFut<'fd>(Aio<TokioSource<'fd>>);
  function submit (line 36) | pub fn submit(self: Pin<&mut Self>) -> io::Result<()> {
  type Output (line 46) | type Output = io::Result<()>;
  method poll (line 48) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type LlSource (line 71) | struct LlSource(Pin<Box<libc::aiocb>>);
    method fsync (line 74) | fn fsync(mut self: Pin<&mut Self>) {
  method register (line 84) | fn register(&mut self, kq: RawFd, token: usize) {
  method deregister (line 94) | fn deregister(&mut self) {
  type LlFut (line 101) | struct LlFut(Aio<LlSource>);
    method fsync (line 104) | pub fn fsync(self: Pin<&mut Self>) {
  type Output (line 111) | type Output = std::io::Result<usize>;
  method poll (line 113) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function fsync (line 136) | async fn fsync() {
  function ll_fsync (line 148) | async fn ll_fsync() {
  function reuse (line 166) | async fn reuse() {
  type LioSource (line 203) | struct LioSource<'a> {
  function new (line 209) | fn new(aiocb: Pin<&'a mut [&'a mut libc::aiocb; 1]>) -> Self {
  function submit (line 216) | fn submit(mut self: Pin<&mut Self>) {
  method register (line 225) | fn register(&mut self, kq: RawFd, token: usize) {
  method deregister (line 235) | fn deregister(&mut self) {
  type LioFut (line 242) | struct LioFut<'a>(Aio<LioSource<'a>>);
  function submit (line 245) | pub fn submit(self: Pin<&mut Self>) {
  type Output (line 252) | type Output = std::io::Result<usize>;
  method poll (line 254) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function onewrite (line 286) | async fn onewrite() {
  function reuse (line 307) | async fn reuse() {

FILE: tokio/tests/io_read.rs
  function read (line 17) | async fn read() {
  type BadAsyncRead (line 45) | struct BadAsyncRead {
    method new (line 50) | fn new() -> Self {
  method poll_read (line 58) | fn poll_read(
  function read_buf_bad_async_read (line 72) | async fn read_buf_bad_async_read() {

FILE: tokio/tests/io_read_buf.rs
  function read_buf (line 12) | async fn read_buf() {
  function issue_5588 (line 40) | async fn issue_5588() {

FILE: tokio/tests/io_read_exact.rs
  function read_exact (line 8) | async fn read_exact() {

FILE: tokio/tests/io_read_line.rs
  function read_line (line 11) | async fn read_line() {
  function read_line_not_all_ready (line 33) | async fn read_line_not_all_ready() {
  function read_line_invalid_utf8 (line 64) | async fn read_line_invalid_utf8() {
  function read_line_fail (line 77) | async fn read_line_fail() {
  function read_line_fail_and_utf8_fail (line 93) | async fn read_line_fail_and_utf8_fail() {

FILE: tokio/tests/io_read_to_end.rs
  function read_to_end (line 11) | async fn read_to_end() {
  type State (line 21) | enum State {
  type UninitTest (line 27) | struct UninitTest {
  method poll_read (line 33) | fn poll_read(
  function read_to_end_uninit (line 70) | async fn read_to_end_uninit() {
  function read_to_end_doesnt_grow_with_capacity (line 83) | async fn read_to_end_doesnt_grow_with_capacity() {
  function read_to_end_grows_capacity_if_unfit (line 115) | async fn read_to_end_grows_capacity_if_unfit() {

FILE: tokio/tests/io_read_to_string.rs
  function read_to_string (line 10) | async fn read_to_string() {
  function to_string_does_not_truncate_on_utf8_error (line 20) | async fn to_string_does_not_truncate_on_utf8_error() {
  function to_string_does_not_truncate_on_io_error (line 35) | async fn to_string_does_not_truncate_on_io_error() {
  function to_string_appends (line 52) | async fn to_string_appends() {

FILE: tokio/tests/io_read_until.rs
  function read_until (line 9) | async fn read_until() {
  function read_until_not_all_ready (line 27) | async fn read_until_not_all_ready() {
  function read_until_fail (line 58) | async fn read_until_fail() {

FILE: tokio/tests/io_repeat.rs
  function repeat_poll_read_is_cooperative (line 7) | async fn repeat_poll_read_is_cooperative() {

FILE: tokio/tests/io_sink.rs
  function sink_poll_write_is_cooperative (line 7) | async fn sink_poll_write_is_cooperative() {
  function sink_poll_flush_is_cooperative (line 21) | async fn sink_poll_flush_is_cooperative() {
  function sink_poll_shutdown_is_cooperative (line 34) | async fn sink_poll_shutdown_is_cooperative() {

FILE: tokio/tests/io_split.rs
  type RW (line 12) | struct RW;
  method poll_read (line 15) | fn poll_read(
  method poll_write (line 26) | fn poll_write(
  method poll_flush (line 34) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 38) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...
  method poll_write_vectored (line 42) | fn poll_write_vectored(
  method is_write_vectored (line 50) | fn is_write_vectored(&self) -> bool {
  function is_send_and_sync (line 56) | fn is_send_and_sync() {
  function split_stream_id (line 64) | fn split_stream_id() {
  function unsplit_ok (line 74) | fn unsplit_ok() {
  function unsplit_err1 (line 81) | fn unsplit_err1() {
  function unsplit_err2 (line 89) | fn unsplit_err2() {
  function method_delegation (line 96) | fn method_delegation() {

FILE: tokio/tests/io_take.rs
  function take (line 15) | async fn take() {
  function issue_4435 (line 26) | async fn issue_4435() {
  type BadReader (line 42) | struct BadReader {
    method new (line 47) | fn new() -> Self {
  method poll_read (line 55) | fn poll_read(
  function bad_reader_fails (line 70) | async fn bad_reader_fails() {

FILE: tokio/tests/io_util_empty.rs
  function empty_read_is_cooperative (line 5) | async fn empty_read_is_cooperative() {
  function empty_buf_reads_are_cooperative (line 20) | async fn empty_buf_reads_are_cooperative() {
  function empty_seek (line 35) | async fn empty_seek() {

FILE: tokio/tests/io_write.rs
  function write (line 13) | async fn write() {
  function write_cursor (line 50) | async fn write_cursor() {

FILE: tokio/tests/io_write_all.rs
  function write_all (line 14) | async fn write_all() {

FILE: tokio/tests/io_write_all_buf.rs
  function write_all_buf (line 14) | async fn write_all_buf() {
  function write_buf_err (line 59) | async fn write_buf_err() {
  function write_all_buf_vectored (line 99) | async fn write_all_buf_vectored() {

FILE: tokio/tests/io_write_buf.rs
  function write_all (line 14) | async fn write_all() {
  function write_buf_vectored (line 59) | async fn write_buf_vectored() {

FILE: tokio/tests/io_write_int.rs
  function write_int_should_err_if_write_count_0 (line 11) | async fn write_int_should_err_if_write_count_0() {

FILE: tokio/tests/join_handle_panic.rs
  type PanicsOnDrop (line 5) | struct PanicsOnDrop;
  method drop (line 8) | fn drop(&mut self) {
  function test_panics_do_not_propagate_when_dropping_join_handle (line 14) | async fn test_panics_do_not_propagate_when_dropping_join_handle() {

FILE: tokio/tests/macros_join.rs
  function sync_one_lit_expr_comma (line 18) | async fn sync_one_lit_expr_comma() {
  function sync_one_lit_expr_no_comma (line 27) | async fn sync_one_lit_expr_no_comma() {
  function sync_two_lit_expr_comma (line 36) | async fn sync_two_lit_expr_comma() {
  function sync_two_lit_expr_no_comma (line 45) | async fn sync_two_lit_expr_no_comma() {
  function two_await (line 54) | async fn two_await() {
  function join_size (line 77) | fn join_size() {
  function non_cooperative_task (line 95) | async fn non_cooperative_task(permits: Arc<Semaphore>) -> usize {
  function poor_little_task (line 110) | async fn poor_little_task(permits: Arc<Semaphore>) -> usize {
  function join_does_not_allow_tasks_to_starve (line 122) | async fn join_does_not_allow_tasks_to_starve() {
  function a_different_future_is_polled_first_every_time_poll_fn_is_polled (line 136) | async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled...
  function futures_are_polled_in_order_in_biased_mode (line 166) | async fn futures_are_polled_in_order_in_biased_mode() {
  function join_size_biased (line 198) | fn join_size_biased() {
  function empty_join (line 218) | async fn empty_join() {
  function join_into_future (line 224) | async fn join_into_future() {
  function caller_names_const_count (line 243) | async fn caller_names_const_count() {

FILE: tokio/tests/macros_pin.rs
  function one (line 9) | async fn one() {}
  function two (line 10) | async fn two() {}
  function multi_pin (line 13) | async fn multi_pin() {

FILE: tokio/tests/macros_rename_test.rs
  function compute (line 12) | async fn compute() -> usize {
  function compute_main (line 18) | async fn compute_main() -> usize {
  function crate_rename_main (line 23) | fn crate_rename_main() {
  function crate_rename_test (line 28) | async fn crate_rename_test() {
  function crate_path_test (line 33) | async fn crate_path_test() {

FILE: tokio/tests/macros_select.rs
  function sync_one_lit_expr_comma (line 17) | async fn sync_one_lit_expr_comma() {
  function no_branch_else_only (line 26) | async fn no_branch_else_only() {
  function no_branch_else_only_biased (line 35) | async fn no_branch_else_only_biased() {
  function nested_one (line 45) | async fn nested_one() {
  function sync_one_lit_expr_no_comma (line 56) | async fn sync_one_lit_expr_no_comma() {
  function sync_one_lit_expr_block (line 65) | async fn sync_one_lit_expr_block() {
  function sync_one_await (line 74) | async fn sync_one_await() {
  function sync_one_ident (line 83) | async fn sync_one_ident() {
  function sync_two (line 94) | async fn sync_two() {
  function drop_in_fut (line 115) | async fn drop_in_fut() {
  function one_ready (line 131) | async fn one_ready() {
  function select_streams (line 149) | async fn select_streams() {
  function move_uncompleted_futures (line 190) | async fn move_uncompleted_futures() {
  function nested (line 216) | async fn nested() {
  function struct_size_1 (line 235) | async fn struct_size_1() {
  function struct_size_2 (line 248) | async fn struct_size_2() {
  function struct_size_3 (line 263) | async fn struct_size_3() {
  function mutable_borrowing_future_with_same_borrow_in_block (line 281) | async fn mutable_borrowing_future_with_same_borrow_in_block() {
  function mutable_borrowing_future_with_same_borrow_in_block_and_else (line 295) | async fn mutable_borrowing_future_with_same_borrow_in_block_and_else() {
  function future_panics_after_poll (line 312) | async fn future_panics_after_poll() {
  function disable_with_if (line 342) | async fn disable_with_if() {
  function join_with_select (line 364) | async fn join_with_select() {
  function use_future_in_if_condition (line 400) | async fn use_future_in_if_condition() {
  function use_future_in_if_condition_biased (line 414) | async fn use_future_in_if_condition_biased() {
  function many_branches (line 428) | async fn many_branches() {
  function never_branch_no_warnings (line 500) | async fn never_branch_no_warnings() {
  function one (line 508) | async fn one() -> usize {
  function require_mutable (line 512) | async fn require_mutable(_: &mut i32) {}
  function async_noop (line 513) | async fn async_noop() {}
  function async_never (line 515) | async fn async_never() -> ! {
  function mut_on_left_hand_side (line 521) | async fn mut_on_left_hand_side() {
  function biased_one_not_ready (line 537) | async fn biased_one_not_ready() {
  function biased_eventually_ready (line 562) | async fn biased_eventually_ready() {
  function default_numeric_fallback (line 599) | pub async fn default_numeric_fallback() {
  function mut_ref_patterns (line 608) | async fn mut_ref_patterns() {
  function deterministic_select_current_thread (line 637) | fn deterministic_select_current_thread() {
  function deterministic_select_multi_thread (line 656) | fn deterministic_select_multi_thread() {
  function select_0_to_9 (line 697) | async fn select_0_to_9() -> u32 {
  function select_into_future (line 714) | async fn select_into_future() {
  function temporary_lifetime_extension (line 732) | async fn temporary_lifetime_extension() {
  function select_is_budget_aware (line 739) | async fn select_is_budget_aware() {

FILE: tokio/tests/macros_test.rs
  function test_macro_can_be_used_via_use (line 6) | async fn test_macro_can_be_used_via_use() {
  function test_macro_is_resilient_to_shadowing (line 11) | async fn test_macro_is_resilient_to_shadowing() {
  function unused_braces_main (line 18) | pub async fn unused_braces_main() { println!("hello") }
  function unused_braces_test (line 21) | async fn unused_braces_test() { assert_eq!(1 + 1, 2) }
  function trait_method (line 25) | fn trait_method() {
  function issue_4175_main_1 (line 44) | pub async fn issue_4175_main_1() -> ! {
  function issue_4175_main_2 (line 48) | pub async fn issue_4175_main_2() -> std::io::Result<()> {
  function issue_4175_test (line 53) | pub async fn issue_4175_test() -> std::io::Result<()> {
  function local (line 64) | pub async fn local() {
  function item (line 68) | pub async fn item() {
  function semi (line 72) | pub async fn semi() {
  function empty (line 76) | pub async fn empty() {
  function unhandled_panic_shutdown_runtime (line 102) | async fn unhandled_panic_shutdown_runtime() {
  function unhandled_panic_ignore (line 110) | async fn unhandled_panic_ignore() {

FILE: tokio/tests/macros_try_join.rs
  function sync_one_lit_expr_comma (line 16) | async fn sync_one_lit_expr_comma() {
  function sync_one_lit_expr_no_comma (line 25) | async fn sync_one_lit_expr_no_comma() {
  function sync_two_lit_expr_comma (line 34) | async fn sync_two_lit_expr_comma() {
  function sync_two_lit_expr_no_comma (line 43) | async fn sync_two_lit_expr_no_comma() {
  function two_await (line 52) | async fn two_await() {
  function err_abort_early (line 72) | async fn err_abort_early() {
  function try_join_size (line 95) | fn try_join_size() {
  function ok (line 113) | fn ok<T>(val: T) -> Result<T, ()> {
  function non_cooperative_task (line 117) | async fn non_cooperative_task(permits: Arc<Semaphore>) -> Result<usize, ...
  function poor_little_task (line 132) | async fn poor_little_task(permits: Arc<Semaphore>) -> Result<usize, Stri...
  function try_join_does_not_allow_tasks_to_starve (line 145) | async fn try_join_does_not_allow_tasks_to_starve() {
  function a_different_future_is_polled_first_every_time_poll_fn_is_polled (line 161) | async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled...
  function futures_are_polled_in_order_in_biased_mode (line 193) | async fn futures_are_polled_in_order_in_biased_mode() {
  function try_join_size_biased (line 227) | fn try_join_size_biased() {
  function empty_try_join (line 246) | async fn empty_try_join() {
  function caller_names_const_count (line 256) | async fn caller_names_const_count() {

FILE: tokio/tests/net_bind_resource.rs
  function no_runtime_panics_binding_net_tcp_listener (line 11) | fn no_runtime_panics_binding_net_tcp_listener() {

FILE: tokio/tests/net_lookup_host.rs
  function lookup_socket_addr (line 10) | async fn lookup_socket_addr() {
  function lookup_str_socket_addr (line 18) | async fn lookup_str_socket_addr() {
  function resolve_dns (line 27) | async fn resolve_dns() -> io::Result<()> {

FILE: tokio/tests/net_named_pipe.rs
  function test_named_pipe_client_drop (line 12) | async fn test_named_pipe_client_drop() -> io::Result<()> {
  function test_named_pipe_single_client (line 32) | async fn test_named_pipe_single_client() -> io::Result<()> {
  function test_named_pipe_multi_client (line 71) | async fn test_named_pipe_multi_client() -> io::Result<()> {
  function test_named_pipe_multi_client_ready (line 148) | async fn test_named_pipe_multi_client_ready() -> io::Result<()> {
  function test_named_pipe_mode_message (line 328) | async fn test_named_pipe_mode_message() -> io::Result<()> {
  function _named_pipe_mode_message (line 336) | async fn _named_pipe_mode_message(mode: PipeMode) -> io::Result<()> {
  function test_named_pipe_access (line 376) | async fn test_named_pipe_access() -> io::Result<()> {

FILE: tokio/tests/net_panic.rs
  function udp_socket_from_std_panic_caller (line 16) | fn udp_socket_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function tcp_listener_from_std_panic_caller (line 39) | fn tcp_listener_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function tcp_stream_from_std_panic_caller (line 58) | fn tcp_stream_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function unix_listener_bind_panic_caller (line 80) | fn unix_listener_bind_panic_caller() -> Result<(), Box<dyn Error>> {
  function unix_listener_from_std_panic_caller (line 102) | fn unix_listener_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function unix_stream_from_std_panic_caller (line 125) | fn unix_stream_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function unix_datagram_from_std_panic_caller (line 149) | fn unix_datagram_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
  function server_options_max_instances_panic_caller (line 176) | fn server_options_max_instances_panic_caller() -> Result<(), Box<dyn Err...
  function runtime_without_io (line 194) | fn runtime_without_io() -> Runtime {

FILE: tokio/tests/net_quickack.rs
  function socket_works_with_quickack (line 19) | async fn socket_works_with_quickack() {

FILE: tokio/tests/net_unix_pipe.rs
  type TempFifo (line 16) | struct TempFifo {
    method new (line 22) | fn new(name: &str) -> io::Result<TempFifo> {
    method as_ref (line 34) | fn as_ref(&self) -> &Path {
  function fifo_simple_send (line 41) | async fn fifo_simple_send() -> io::Result<()> {
  function fifo_simple_send_sender_first (line 73) | async fn fifo_simple_send_sender_first() -> io::Result<()> {
  function write_and_close (line 99) | async fn write_and_close(path: impl AsRef<Path>, msg: &[u8]) -> io::Resu...
  function fifo_multiple_writes (line 110) | async fn fifo_multiple_writes() -> io::Result<()> {
  function fifo_resilient_reader (line 139) | async fn fifo_resilient_reader() -> io::Result<()> {
  function open_detects_not_a_fifo (line 170) | async fn open_detects_not_a_fifo() -> io::Result<()> {
  function from_file (line 193) | async fn from_file() -> io::Result<()> {
  function from_file_detects_not_a_fifo (line 230) | async fn from_file_detects_not_a_fifo() -> io::Result<()> {
  function from_file_detects_wrong_access_mode (line 255) | async fn from_file_detects_wrong_access_mode() -> io::Result<()> {
  function is_nonblocking (line 280) | fn is_nonblocking<T: AsRawFd>(fd: &T) -> io::Result<bool> {
  function from_file_sets_nonblock (line 287) | async fn from_file_sets_nonblock() -> io::Result<()> {
  function writable_by_poll (line 309) | fn writable_by_poll(writer: &pipe::Sender) -> bool {
  function try_read_write (line 315) | async fn try_read_write() -> io::Result<()> {
  function try_read_write_vectored (line 356) | async fn try_read_write_vectored() -> io::Result<()> {
  function try_read_buf (line 404) | async fn try_read_buf() -> std::io::Result<()> {
  function anon_pipe_simple_send (line 444) | async fn anon_pipe_simple_send() -> io::Result<()> {
  function anon_pipe_spawn_echo (line 473) | async fn anon_pipe_spawn_echo() -> std::io::Result<()> {
  function anon_pipe_from_owned_fd (line 504) | async fn anon_pipe_from_owned_fd() -> std::io::Result<()> {
  function anon_pipe_into_nonblocking_fd (line 523) | async fn anon_pipe_into_nonblocking_fd() -> std::io::Result<()> {
  function anon_pipe_into_blocking_fd (line 536) | async fn anon_pipe_into_blocking_fd() -> std::io::Result<()> {

FILE: tokio/tests/no_rt.rs
  function timeout_panics_when_no_tokio_context (line 15) | fn timeout_panics_when_no_tokio_context() {
  function panics_when_no_reactor (line 24) | fn panics_when_no_reactor() {
  function timeout_value (line 30) | async fn timeout_value() {
  function io_panics_when_no_tokio_context (line 41) | fn io_panics_when_no_tokio_context() {

FILE: tokio/tests/process_arg0.rs
  function arg0 (line 7) | async fn arg0() {

FILE: tokio/tests/process_change_of_runtime.rs
  function process_spawned_and_wait_in_different_runtime (line 12) | fn process_spawned_and_wait_in_different_runtime() {
  function process_spawned_outside_runtime (line 29) | fn process_spawned_outside_runtime() {

FILE: tokio/tests/process_issue_2174.rs
  function issue_2174 (line 21) | async fn issue_2174() {

FILE: tokio/tests/process_issue_42.rs
  function issue_42 (line 12) | async fn issue_42() {

FILE: tokio/tests/process_issue_7144.rs
  function issue_7144 (line 10) | async fn issue_7144() {
  function has_strace (line 20) | async fn has_strace() -> bool {
  function test_one (line 24) | async fn test_one() {

FILE: tokio/tests/process_kill_after_wait.rs
  function kill_after_wait (line 7) | async fn kill_after_wait() {

FILE: tokio/tests/process_kill_on_drop.rs
  function kill_on_drop (line 13) | async fn kill_on_drop() {

FILE: tokio/tests/process_raw_handle.rs
  function obtain_raw_handle (line 10) | async fn obtain_raw_handle() {

FILE: tokio/tests/process_smoke.rs
  function simple (line 8) | async fn simple() {

FILE: tokio/tests/rt_basic.rs
  function spawned_task_does_not_progress_without_block_on (line 29) | fn spawned_task_does_not_progress_without_block_on() {
  function no_extra_poll (line 48) | fn no_extra_poll() {
  function acquire_mutex_in_drop (line 116) | fn acquire_mutex_in_drop() {
  function drop_tasks_in_context (line 152) | fn drop_tasks_in_context() {
  function wake_in_drop_after_panic (line 183) | fn wake_in_drop_after_panic() {
  function spawn_two (line 221) | fn spawn_two() {
  function spawn_remote (line 254) | fn spawn_remote() {
  function timeout_panics_when_no_time_handle (line 293) | fn timeout_panics_when_no_time_handle() {
  function shutdown_on_panic (line 312) | fn shutdown_on_panic() {
  function spawns_do_nothing (line 329) | fn spawns_do_nothing() {
  function shutdown_all_concurrent_block_on (line 358) | fn shutdown_all_concurrent_block_on() {
  function rng_seed (line 396) | fn rng_seed() {
  function rng_seed_multi_enter (line 424) | fn rng_seed_multi_enter() {
  function rt (line 453) | fn rt() -> Runtime {
  function before_park_yields (line 461) | fn before_park_yields() {

FILE: tokio/tests/rt_common.rs
  function send_sync_bound (line 60) | fn send_sync_bound() {

FILE: tokio/tests/rt_common_before_park.rs
  function before_park_wakes_block_on_task (line 11) | fn before_park_wakes_block_on_task() {
  function before_park_spawns_task (line 41) | fn before_park_spawns_task() {
  function wake_from_other_thread_block_on (line 73) | fn wake_from_other_thread_block_on() {

FILE: tokio/tests/rt_handle.rs
  function basic_enter (line 10) | fn basic_enter() {
  function interleave_enter_different_rt (line 24) | fn interleave_enter_different_rt() {
  function interleave_enter_same_rt (line 38) | fn interleave_enter_same_rt() {
  function interleave_then_enter (line 52) | fn interleave_then_enter() {
  function drop_tasks_with_reference_cycle (line 71) | fn drop_tasks_with_reference_cycle() {
  function runtime_id_is_same (line 104) | fn runtime_id_is_same() {
  function runtime_ids_different (line 114) | fn runtime_ids_different() {
  function rt (line 121) | fn rt() -> Runtime {

FILE: tokio/tests/rt_handle_block_on.rs
  function basic (line 98) | fn basic() {
  function bounded_mpsc_channel (line 106) | fn bounded_mpsc_channel() {
  function unbounded_mpsc_channel (line 118) | fn unbounded_mpsc_channel() {
  function yield_in_block_in_place (line 130) | fn yield_in_block_in_place() {
  function new_multi_thread (line 518) | fn new_multi_thread(n: usize) -> Runtime {
  function new_current_thread (line 527) | fn new_current_thread() -> Runtime {
  function test_with_runtimes (line 535) | fn test_with_runtimes<F>(f: F)

FILE: tokio/tests/rt_local.rs
  function test_spawn_local_in_runtime (line 10) | fn test_spawn_local_in_runtime() {
  function test_spawn_from_handle (line 28) | fn test_spawn_from_handle() {
  function test_spawn_local_on_runtime_object (line 44) | fn test_spawn_local_on_runtime_object() {
  function test_spawn_local_from_guard (line 60) | fn test_spawn_local_from_guard() {
  function test_spawn_from_guard_other_thread (line 79) | fn test_spawn_from_guard_other_thread() {
  function test_spawn_local_from_guard_other_thread (line 99) | fn test_spawn_local_from_guard_other_thread() {
  function test_spawn_local_panic (line 125) | fn test_spawn_local_panic() {
  function test_spawn_local_in_current_thread_runtime (line 145) | fn test_spawn_local_in_current_thread_runtime() {
  function test_spawn_local_in_multi_thread_runtime (line 157) | fn test_spawn_local_in_multi_thread_runtime() {
  function rt (line 165) | fn rt() -> tokio::runtime::LocalRuntime {

FILE: tokio/tests/rt_metrics.rs
  function num_workers (line 10) | fn num_workers() {
  function num_alive_tasks (line 19) | fn num_alive_tasks() {
  function global_queue_depth_current_thread (line 51) | fn global_queue_depth_current_thread() {
  function global_queue_depth_multi_thread (line 68) | fn global_queue_depth_multi_thread() {
  function worker_total_busy_duration (line 87) | fn worker_total_busy_duration() {
  function worker_park_count (line 130) | fn worker_park_count() {
  function worker_park_unpark_count (line 150) | fn worker_park_unpark_count() {
  function try_block_threaded (line 187) | fn try_block_threaded(rt: &Runtime) -> Result<Vec<mpsc::Sender<()>>, mps...
  function current_thread (line 220) | fn current_thread() -> Runtime {
  function threaded (line 227) | fn threaded() -> Runtime {

FILE: tokio/tests/rt_panic.rs
  function current_handle_panic_caller (line 16) | fn current_handle_panic_caller() -> Result<(), Box<dyn Error>> {
  function into_panic_panic_caller (line 28) | fn into_panic_panic_caller() -> Result<(), Box<dyn Error>> {
  function builder_worker_threads_panic_caller (line 50) | fn builder_worker_threads_panic_caller() -> Result<(), Box<dyn Error>> {
  function builder_max_blocking_threads_panic_caller (line 62) | fn builder_max_blocking_threads_panic_caller() -> Result<(), Box<dyn Err...
  function builder_global_queue_interval_panic_caller (line 74) | fn builder_global_queue_interval_panic_caller() -> Result<(), Box<dyn Er...
  function builder_event_interval_interval_panic_caller (line 86) | fn builder_event_interval_interval_panic_caller() -> Result<(), Box<dyn ...
  function current_thread (line 97) | fn current_thread() -> Runtime {

FILE: tokio/tests/rt_poll_callbacks.rs
  function callbacks_fire_multi_thread (line 10) | fn callbacks_fire_multi_thread() {
  function callbacks_fire_current_thread (line 75) | fn callbacks_fire_current_thread() {

FILE: tokio/tests/rt_shutdown_err.rs
  function rt (line 9) | fn rt() -> tokio::runtime::Runtime {
  function test_is_rt_shutdown_err (line 14) | fn test_is_rt_shutdown_err() {
  function test_is_not_rt_shutdown_err (line 31) | fn test_is_not_rt_shutdown_err() {
  function test_join_error_panic (line 41) | fn test_join_error_panic() {
  function test_join_error_cancelled (line 53) | fn test_join_error_cancelled() {
  function test_other_error_kinds_and_strings (line 65) | fn test_other_error_kinds_and_strings() {

FILE: tokio/tests/rt_threaded.rs
  function single_thread (line 28) | fn single_thread() {
  function many_oneshot_futures (line 38) | fn many_oneshot_futures() {
  function spawn_two (line 69) | fn spawn_two() {
  function many_multishot_futures (line 101) | fn many_multishot_futures() {
  function lifo_slot_budget (line 165) | fn lifo_slot_budget() {
  function spawn_shutdown (line 192) | fn spawn_shutdown() {
  function client_server (line 210) | async fn client_server(tx: mpsc::Sender<()>) {
  function drop_threadpool_drops_futures (line 235) | fn drop_threadpool_drops_futures() {
  function start_stop_callbacks_called (line 291) | fn start_stop_callbacks_called() {
  function blocking (line 327) | fn blocking() {
  function multi_threadpool (line 372) | fn multi_threadpool() {
  function coop_and_block_in_place (line 400) | fn coop_and_block_in_place() {
  function yield_after_block_in_place (line 449) | fn yield_after_block_in_place() {
  function max_blocking_threads (line 476) | fn max_blocking_threads() {
  function max_blocking_threads_set_to_zero (line 485) | fn max_blocking_threads_set_to_zero() {
  function global_queue_interval_set_to_one (line 498) | fn global_queue_interval_set_to_one() {
  function hang_on_shutdown (line 521) | async fn hang_on_shutdown() {
  function wake_during_shutdown (line 536) | fn wake_during_shutdown() {
  function test_block_in_place1 (line 600) | async fn test_block_in_place1() {
  function test_block_in_place2 (line 605) | async fn test_block_in_place2() {
  function test_block_in_place3 (line 612) | async fn test_block_in_place3() {
  function test_block_in_place4 (line 618) | async fn test_block_in_place4() {
  function test_nested_block_in_place_with_block_on_between (line 624) | fn test_nested_block_in_place_with_block_on_between() {
  function yield_now_in_block_in_place (line 651) | fn yield_now_in_block_in_place() {
  function mutex_in_block_in_place (line 669) | fn mutex_in_block_in_place() {
  function wake_deferred_tasks_before_block_in_place (line 698) | fn wake_deferred_tasks_before_block_in_place() {
  function test_tuning (line 750) | fn test_tuning() {
  function rt (line 863) | fn rt() -> runtime::Runtime {
  function test_disable_lifo_slot (line 872) | fn test_disable_lifo_slot() {
  function runtime_id_is_same (line 916) | fn runtime_id_is_same() {
  function runtime_ids_different (line 926) | fn runtime_ids_different() {

FILE: tokio/tests/rt_time_start_paused.rs
  function test_start_paused (line 6) | async fn test_start_paused() {

FILE: tokio/tests/rt_unstable_metrics.rs
  function num_workers (line 20) | fn num_workers() {
  function num_blocking_threads (line 29) | fn num_blocking_threads() {
  function num_idle_blocking_threads (line 42) | fn num_idle_blocking_threads() {
  function num_idle_blocking_threads_is_zero_after_shutdown (line 66) | fn num_idle_blocking_threads_is_zero_after_shutdown() {
  function blocking_queue_depth (line 98) | fn blocking_queue_depth() {
  function spawned_tasks_count (line 128) | fn spawned_tasks_count() {
  function remote_schedule_count (line 153) | fn remote_schedule_count() {
  function worker_thread_id_current_thread (line 186) | fn worker_thread_id_current_thread() {
  function worker_thread_id_threaded (line 209) | fn worker_thread_id_threaded() {
  function worker_noop_count (line 248) | fn worker_noop_count() {
  function worker_steal_count (line 271) | fn worker_steal_count() {
  function worker_poll_count_and_time (line 302) | fn worker_poll_count_and_time() {
  function log_histogram (line 359) | fn log_histogram() {
  function minimal_log_histogram (line 401) | fn minimal_log_histogram() {
  function legacy_log_histogram (line 430) | fn legacy_log_histogram() {
  function log_histogram_default_configuration (line 444) | fn log_histogram_default_configuration() {
  function worker_poll_count_histogram (line 458) | fn worker_poll_count_histogram() {
  function worker_poll_count_histogram_range (line 507) | fn worker_poll_count_histogram_range() {
  function worker_poll_count_histogram_disabled_without_explicit_enable (line 543) | fn worker_poll_count_histogram_disabled_without_explicit_enable() {
  function worker_local_schedule_count (line 571) | fn worker_local_schedule_count() {
  function worker_overflow_count (line 603) | fn worker_overflow_count() {
  function worker_local_queue_depth (line 648) | fn worker_local_queue_depth() {
  function budget_exhaustion_yield (line 700) | fn budget_exhaustion_yield() {
  function budget_exhaustion_yield_with_joins (line 727) | fn budget_exhaustion_yield_with_joins() {
  function io_driver_fd_count (line 773) | fn io_driver_fd_count() {
  function io_driver_ready_count (line 793) | fn io_driver_ready_count() {
  function try_spawn_stealable_task (line 803) | async fn try_spawn_stealable_task() -> Result<(), mpsc::RecvTimeoutError> {
  function current_thread (line 827) | fn current_thread() -> Runtime {
  function threaded (line 834) | fn threaded() -> Runtime {
  function threaded_no_lifo (line 842) | fn threaded_no_lifo() -> Runtime {
  function us (line 851) | fn us(n: u64) -> Duration {

FILE: tokio/tests/rt_worker_index.rs
  function worker_index_current_thread (line 7) | fn worker_index_current_thread() {
  function worker_index_local_runtime (line 19) | fn worker_index_local_runtime() {
  function worker_index_outside_runtime (line 28) | fn worker_index_outside_runtime() {
  function worker_index_matches_metrics_worker_thread_id (line 34) | fn worker_index_matches_metrics_worker_thread_id() {
  function worker_index_from_spawn_blocking (line 61) | fn worker_index_from_spawn_blocking() {
  function worker_index_block_on_multi_thread (line 75) | fn worker_index_block_on_multi_thread() {

FILE: tokio/tests/signal_ctrl_c.rs
  function ctrl_c (line 15) | async fn ctrl_c() {

FILE: tokio/tests/signal_drop_recv.rs
  function drop_then_get_a_signal (line 14) | async fn drop_then_get_a_signal() {

FILE: tokio/tests/signal_drop_rt.rs
  function dropping_loops_does_not_cause_starvation (line 15) | fn dropping_loops_does_not_cause_starvation() {
  function rt (line 40) | fn rt() -> Runtime {

FILE: tokio/tests/signal_drop_signal.rs
  function dropping_signal_does_not_deregister_any_other_instances (line 14) | async fn dropping_signal_does_not_deregister_any_other_instances() {

FILE: tokio/tests/signal_info.rs
  function siginfo (line 23) | async fn siginfo() {

FILE: tokio/tests/signal_multi_rt.rs
  function multi_loop (line 18) | fn multi_loop() {
  function rt (line 50) | fn rt() -> Runtime {

FILE: tokio/tests/signal_no_rt.rs
  function no_runtime_panics_creating_signals (line 11) | fn no_runtime_panics_creating_signals() {

FILE: tokio/tests/signal_notify_both.rs
  function notify_both (line 14) | async fn notify_both() {

FILE: tokio/tests/signal_panic.rs
  function signal_panic_caller (line 17) | fn signal_panic_caller() -> Result<(), Box<dyn Error>> {

FILE: tokio/tests/signal_realtime.rs
  function signal_realtime (line 20) | async fn signal_realtime() {
  function sigrt_max (line 91) | fn sigrt_max() -> c_int {
  function sigrtnum_to_string (line 103) | fn sigrtnum_to_string(signum: i32) -> String {

FILE: tokio/tests/signal_twice.rs
  function twice (line 14) | async fn twice() {

FILE: tokio/tests/signal_usr1.rs
  function signal_usr1 (line 15) | async fn signal_usr1() {

FILE: tokio/tests/support/io_vec.rs
  type IoBufs (line 5) | pub struct IoBufs<'a, 'b>(&'b mut [IoSlice<'a>]);
  function new (line 8) | pub fn new(slices: &'b mut [IoSlice<'a>]) -> Self {
  function is_empty (line 12) | pub fn is_empty(&self) -> bool {
  function advance (line 16) | pub fn advance(mut self, n: usize) -> IoBufs<'a, 'b> {
  type Target (line 41) | type Target = [IoSlice<'a>];
  method deref (line 42) | fn deref(&self) -> &[IoSlice<'a>] {

FILE: tokio/tests/support/leaked_buffers.rs
  type LeakedBuffers (line 10) | pub struct LeakedBuffers {
    method new (line 15) | pub fn new() -> Self {
    method create (line 20) | pub unsafe fn create<'a>(&mut self, size: usize) -> &'a mut [u8] {

FILE: tokio/tests/support/mpsc_stream.rs
  type UnboundedStream (line 8) | struct UnboundedStream<T> {
  type Item (line 12) | type Item = T;
  method poll_next (line 13) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function unbounded_channel_stream (line 18) | pub fn unbounded_channel_stream<T: Unpin>() -> (UnboundedSender<T>, impl...
  type BoundedStream (line 26) | struct BoundedStream<T> {
  type Item (line 30) | type Item = T;
  method poll_next (line 31) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function channel_stream (line 36) | pub fn channel_stream<T: Unpin>(size: usize) -> (Sender<T>, impl Stream<...

FILE: tokio/tests/support/panic.rs
  function test_panic (line 4) | pub fn test_panic<Func: FnOnce() + panic::UnwindSafe>(func: Func) -> Opt...

FILE: tokio/tests/support/signal.rs
  function send_signal (line 1) | pub fn send_signal(signal: libc::c_int) {

FILE: tokio/tests/sync_barrier.rs
  type IsSend (line 13) | struct IsSend<T: Send>(T);
  function barrier_future_is_send (line 15) | fn barrier_future_is_send() {
  function zero_does_not_block (line 21) | fn zero_does_not_block() {
  function single (line 37) | fn single() {
  function tango (line 58) | fn tango() {
  function lots (line 73) | fn lots() {

FILE: tokio/tests/sync_broadcast.rs
  type AssertSend (line 56) | trait AssertSend: Send + Sync {}
  function send_try_recv_bounded (line 62) | fn send_try_recv_bounded() {
  function send_two_recv (line 77) | fn send_two_recv() {
  function send_recv_bounded (line 98) | fn send_recv_bounded() {
  function send_two_recv_bounded (line 113) | fn send_two_recv_bounded() {
  function change_tasks (line 152) | fn change_tasks() {
  function send_slow_rx (line 169) | fn send_slow_rx() {
  function drop_rx_while_values_remain (line 219) | fn drop_rx_while_values_remain() {
  function lagging_rx (line 234) | fn lagging_rx() {
  function send_no_rx (line 266) | fn send_no_rx() {
  function zero_capacity (line 282) | fn zero_capacity() {
  function capacity_too_big (line 289) | fn capacity_too_big() {
  function panic_in_clone (line 296) | fn panic_in_clone() {
  function dropping_tx_notifies_rx (line 325) | fn dropping_tx_notifies_rx() {
  function unconsumed_messages_are_dropped (line 355) | fn unconsumed_messages_are_dropped() {
  function single_capacity_recvs (line 370) | fn single_capacity_recvs() {
  function single_capacity_recvs_after_drop_1 (line 380) | fn single_capacity_recvs_after_drop_1() {
  function single_capacity_recvs_after_drop_2 (line 391) | fn single_capacity_recvs_after_drop_2() {
  function dropping_sender_does_not_overwrite (line 404) | fn dropping_sender_does_not_overwrite() {
  function lagging_receiver_recovers_after_wrap_closed_1 (line 417) | fn lagging_receiver_recovers_after_wrap_closed_1() {
  function lagging_receiver_recovers_after_wrap_closed_2 (line 432) | fn lagging_receiver_recovers_after_wrap_closed_2() {
  function lagging_receiver_recovers_after_wrap_open (line 448) | fn lagging_receiver_recovers_after_wrap_open() {
  function receiver_len_with_lagged (line 462) | fn receiver_len_with_lagged() {
  function is_closed (line 480) | fn is_closed(err: broadcast::error::RecvError) -> bool {
  function resubscribe_points_to_tail (line 485) | fn resubscribe_points_to_tail() {
  function resubscribe_lagged (line 508) | fn resubscribe_lagged() {
  function resubscribe_to_closed_channel (line 523) | fn resubscribe_to_closed_channel() {
  function sender_len (line 532) | fn sender_len() {
  function sender_len_random (line 567) | fn sender_len_random() {
  function send_in_waker_drop (line 590) | fn send_in_waker_drop() {
  function receiver_recv_is_cooperative (line 644) | async fn receiver_recv_is_cooperative() {
  function broadcast_sender_closed (line 660) | fn broadcast_sender_closed() {
  function broadcast_sender_closed_with_extra_subscribe (line 677) | fn broadcast_sender_closed_with_extra_subscribe() {
  function broadcast_sender_new_must_be_closed (line 711) | async fn broadcast_sender_new_must_be_closed() {

FILE: tokio/tests/sync_broadcast_weak.rs
  function weak_sender (line 11) | async fn weak_sender() {
  function downgrade_upgrade_sender_failure (line 57) | fn downgrade_upgrade_sender_failure() {
  function downgrade_drop_upgrade (line 67) | fn downgrade_drop_upgrade() {
  function test_tx_count_weak_sender (line 78) | fn test_tx_count_weak_sender() {
  function test_rx_is_closed_when_dropping_all_senders_except_weak_senders (line 94) | async fn test_rx_is_closed_when_dropping_all_senders_except_weak_senders...
  function sender_strong_count_when_cloned (line 106) | async fn sender_strong_count_when_cloned() {
  function sender_weak_count_when_downgraded (line 117) | async fn sender_weak_count_when_downgraded() {
  function sender_strong_count_when_dropped (line 127) | async fn sender_strong_count_when_dropped() {
  function sender_weak_count_when_dropped (line 139) | async fn sender_weak_count_when_dropped() {
  function sender_strong_and_weak_conut (line 151) | async fn sender_strong_and_weak_conut() {

FILE: tokio/tests/sync_errors.rs
  function is_error (line 7) | fn is_error<T: std::error::Error + Send + Sync>() {}
  function mpsc_error_bound (line 10) | fn mpsc_error_bound() {
  function oneshot_error_bound (line 18) | fn oneshot_error_bound() {
  function watch_error_bound (line 26) | fn watch_error_bound() {

FILE: tokio/tests/sync_mpsc.rs
  type AssertRefUnwindSafe (line 26) | trait AssertRefUnwindSafe: panic::RefUnwindSafe {}
  type AssertUnwindSafe (line 38) | trait AssertUnwindSafe: panic::UnwindSafe {}
  function send_recv_with_buffer (line 50) | async fn send_recv_with_buffer() {
  function reserve_disarm (line 75) | async fn reserve_disarm() {
  function send_recv_stream_with_buffer (line 113) | async fn send_recv_stream_with_buffer() {
  function async_send_recv_with_buffer (line 131) | async fn async_send_recv_with_buffer() {
  function async_send_recv_many_with_buffer (line 146) | async fn async_send_recv_many_with_buffer() {
  function start_send_past_cap (line 174) | async fn start_send_past_cap() {
  function buffer_gteq_one (line 208) | fn buffer_gteq_one() {
  function send_recv_unbounded (line 213) | async fn send_recv_unbounded() {
  function send_recv_many_unbounded (line 229) | async fn send_recv_many_unbounded() {
  function send_recv_many_bounded_capacity (line 279) | async fn send_recv_many_bounded_capacity() {
  function send_recv_many_unbounded_capacity (line 321) | async fn send_recv_many_unbounded_capacity() {
  function async_send_recv_unbounded (line 363) | async fn async_send_recv_unbounded() {
  function send_recv_stream_unbounded (line 378) | async fn send_recv_stream_unbounded() {
  function no_t_bounds_buffer (line 396) | async fn no_t_bounds_buffer() {
  function no_t_bounds_unbounded (line 412) | async fn no_t_bounds_unbounded() {
  function send_recv_buffer_limited (line 429) | async fn send_recv_buffer_limited() {
  function recv_close_gets_none_idle (line 459) | async fn recv_close_gets_none_idle() {
  function recv_close_gets_none_reserved (line 471) | async fn recv_close_gets_none_reserved() {
  function tx_close_gets_none (line 499) | async fn tx_close_gets_none() {
  function try_send_fail (line 505) | async fn try_send_fail() {
  function try_send_fail_with_try_recv (line 526) | async fn try_send_fail_with_try_recv() {
  function reserve_many_above_cap (line 547) | async fn reserve_many_above_cap() {
  function try_reserve_many_zero (line 557) | fn try_reserve_many_zero() {
  function reserve_many_zero (line 577) | async fn reserve_many_zero() {
  function try_reserve_many_edge_cases (line 594) | async fn try_reserve_many_edge_cases() {
  function try_reserve_fails (line 620) | async fn try_reserve_fails() {
  function reserve_many_and_send (line 643) | async fn reserve_many_and_send() {
  function try_reserve_many_and_send (line 654) | async fn try_reserve_many_and_send() {
  function reserve_many_on_closed_channel (line 666) | async fn reserve_many_on_closed_channel() {
  function try_reserve_many_on_closed_channel (line 673) | async fn try_reserve_many_on_closed_channel() {
  function try_reserve_many_full (line 684) | async fn try_reserve_many_full() {
  function drop_permit_releases_permit (line 726) | async fn drop_permit_releases_permit() {
  function drop_permit_iterator_releases_permits (line 744) | async fn drop_permit_iterator_releases_permits() {
  function dropping_rx_closes_channel (line 768) | async fn dropping_rx_closes_channel() {
  function dropping_rx_closes_channel_for_try (line 781) | fn dropping_rx_closes_channel_for_try() {
  function unconsumed_messages_are_dropped (line 803) | fn unconsumed_messages_are_dropped() {
  function blocking_recv (line 819) | fn blocking_recv() {
  function blocking_recv_async (line 837) | async fn blocking_recv_async() {
  function blocking_send (line 844) | fn blocking_send() {
  function blocking_send_async (line 862) | async fn blocking_send_async() {
  function ready_close_cancel_bounded (line 869) | async fn ready_close_cancel_bounded() {
  function permit_available_not_acquired_close (line 889) | async fn permit_available_not_acquired_close() {
  function try_recv_bounded (line 908) | fn try_recv_bounded() {
  function try_recv_unbounded (line 951) | fn try_recv_unbounded() {
  function try_recv_after_receiver_close (line 970) | fn try_recv_after_receiver_close() {
  function try_recv_close_while_empty_bounded (line 979) | fn try_recv_close_while_empty_bounded() {
  function try_recv_close_while_empty_unbounded (line 988) | fn try_recv_close_while_empty_unbounded() {
  function recv_timeout (line 998) | async fn recv_timeout() {
  function recv_timeout_panic (line 1024) | fn recv_timeout_panic() {
  function test_tx_capacity (line 1034) | async fn test_tx_capacity() {
  function test_rx_is_closed_when_calling_close_with_sender (line 1052) | async fn test_rx_is_closed_when_calling_close_with_sender() {
  function test_rx_is_closed_when_dropping_all_senders (line 1061) | async fn test_rx_is_closed_when_dropping_all_senders() {
  function test_rx_is_not_closed_when_there_are_senders (line 1076) | async fn test_rx_is_not_closed_when_there_are_senders() {
  function test_rx_is_not_closed_when_there_are_senders_and_buffer_filled (line 1083) | async fn test_rx_is_not_closed_when_there_are_senders_and_buffer_filled() {
  function test_rx_is_closed_when_there_are_no_senders_and_there_are_messages (line 1093) | async fn test_rx_is_closed_when_there_are_no_senders_and_there_are_messa...
  function test_rx_is_closed_when_there_are_messages_and_close_is_called (line 1104) | async fn test_rx_is_closed_when_there_are_messages_and_close_is_called() {
  function test_rx_is_not_closed_when_there_are_permits_but_not_senders (line 1115) | async fn test_rx_is_not_closed_when_there_are_permits_but_not_senders() {
  function test_rx_is_empty_when_no_messages_were_sent (line 1123) | async fn test_rx_is_empty_when_no_messages_were_sent() {
  function test_rx_is_not_empty_when_there_are_messages_in_the_buffer (line 1129) | async fn test_rx_is_not_empty_when_there_are_messages_in_the_buffer() {
  function test_rx_is_not_empty_when_the_buffer_is_full (line 1136) | async fn test_rx_is_not_empty_when_the_buffer_is_full() {
  function test_rx_is_not_empty_when_all_but_one_messages_are_consumed (line 1145) | async fn test_rx_is_not_empty_when_all_but_one_messages_are_consumed() {
  function test_rx_is_empty_when_all_messages_are_consumed (line 1159) | async fn test_rx_is_empty_when_all_messages_are_consumed() {
  function test_rx_is_empty_all_senders_are_dropped_and_messages_consumed (line 1169) | async fn test_rx_is_empty_all_senders_are_dropped_and_messages_consumed() {
  function test_rx_len_on_empty_channel (line 1184) | async fn test_rx_len_on_empty_channel() {
  function test_rx_len_on_empty_channel_without_senders (line 1190) | async fn test_rx_len_on_empty_channel_without_senders() {
  function test_rx_len_on_filled_channel (line 1200) | async fn test_rx_len_on_filled_channel() {
  function test_rx_len_on_filled_channel_without_senders (line 1210) | async fn test_rx_len_on_filled_channel_without_senders() {
  function test_rx_len_when_consuming_all_messages (line 1221) | async fn test_rx_len_when_consuming_all_messages() {
  function test_rx_len_when_close_is_called (line 1238) | async fn test_rx_len_when_close_is_called() {
  function test_rx_len_when_close_is_called_before_dropping_sender (line 1247) | async fn test_rx_len_when_close_is_called_before_dropping_sender() {
  function test_rx_len_when_close_is_called_after_dropping_sender (line 1257) | async fn test_rx_len_when_close_is_called_after_dropping_sender() {
  function test_rx_unbounded_is_closed_when_calling_close_with_sender (line 1267) | async fn test_rx_unbounded_is_closed_when_calling_close_with_sender() {
  function test_rx_unbounded_is_closed_when_dropping_all_senders (line 1276) | async fn test_rx_unbounded_is_closed_when_dropping_all_senders() {
  function test_rx_unbounded_is_not_closed_when_there_are_senders (line 1291) | async fn test_rx_unbounded_is_not_closed_when_there_are_senders() {
  function test_rx_unbounded_is_closed_when_there_are_no_senders_and_there_are_messages (line 1298) | async fn test_rx_unbounded_is_closed_when_there_are_no_senders_and_there...
  function test_rx_unbounded_is_closed_when_there_are_messages_and_close_is_called (line 1309) | async fn test_rx_unbounded_is_closed_when_there_are_messages_and_close_i...
  function test_rx_unbounded_is_empty_when_no_messages_were_sent (line 1320) | async fn test_rx_unbounded_is_empty_when_no_messages_were_sent() {
  function test_rx_unbounded_is_not_empty_when_there_are_messages_in_the_buffer (line 1326) | async fn test_rx_unbounded_is_not_empty_when_there_are_messages_in_the_b...
  function test_rx_unbounded_is_not_empty_when_all_but_one_messages_are_consumed (line 1333) | async fn test_rx_unbounded_is_not_empty_when_all_but_one_messages_are_co...
  function test_rx_unbounded_is_empty_when_all_messages_are_consumed (line 1347) | async fn test_rx_unbounded_is_empty_when_all_messages_are_consumed() {
  function test_rx_unbounded_is_empty_all_senders_are_dropped_and_messages_consumed (line 1357) | async fn test_rx_unbounded_is_empty_all_senders_are_dropped_and_messages...
  function test_rx_unbounded_len_on_empty_channel (line 1372) | async fn test_rx_unbounded_len_on_empty_channel() {
  function test_rx_unbounded_len_on_empty_channel_without_senders (line 1378) | async fn test_rx_unbounded_len_on_empty_channel_without_senders() {
  function test_rx_unbounded_len_with_multiple_messages (line 1388) | async fn test_rx_unbounded_len_with_multiple_messages() {
  function test_rx_unbounded_len_with_multiple_messages_and_dropped_senders (line 1398) | async fn test_rx_unbounded_len_with_multiple_messages_and_dropped_sender...
  function test_rx_unbounded_len_when_consuming_all_messages (line 1409) | async fn test_rx_unbounded_len_when_consuming_all_messages() {
  function test_rx_unbounded_len_when_close_is_called (line 1426) | async fn test_rx_unbounded_len_when_close_is_called() {
  function test_rx_unbounded_len_when_close_is_called_before_dropping_sender (line 1435) | async fn test_rx_unbounded_len_when_close_is_called_before_dropping_send...
  function test_rx_unbounded_len_when_close_is_called_after_dropping_sender (line 1445) | async fn test_rx_unbounded_len_when_close_is_called_after_dropping_sende...
  function test_is_empty_32_msgs (line 1456) | async fn test_is_empty_32_msgs() {
  function drop_all_elements_during_panic (line 1468) | fn drop_all_elements_during_panic() {
  function is_debug (line 1512) | fn is_debug<T: fmt::Debug>(_: &T) {}

FILE: tokio/tests/sync_mpsc_weak.rs
  function weak_sender (line 14) | async fn weak_sender() {
  function actor_weak_sender (line 59) | async fn actor_weak_sender() {
  type Msg (line 171) | struct Msg;
  method drop (line 174) | fn drop(&mut self) {
  function test_msgs_dropped_on_rx_drop (line 188) | async fn test_msgs_dropped_on_rx_drop() {
  function downgrade_upgrade_sender_success (line 214) | fn downgrade_upgrade_sender_success() {
  function downgrade_upgrade_sender_failure (line 222) | fn downgrade_upgrade_sender_failure() {
  function downgrade_drop_upgrade (line 232) | fn downgrade_drop_upgrade() {
  function downgrade_get_permit_upgrade_no_senders (line 244) | async fn downgrade_get_permit_upgrade_no_senders() {
  function downgrade_upgrade_get_permit_no_senders (line 254) | async fn downgrade_upgrade_get_permit_no_senders() {
  function test_tx_count_weak_sender (line 265) | fn test_tx_count_weak_sender() {
  function weak_unbounded_sender (line 275) | async fn weak_unbounded_sender() {
  function actor_weak_unbounded_sender (line 320) | async fn actor_weak_unbounded_sender() {
  type MsgUnbounded (line 432) | struct MsgUnbounded;
  method drop (line 435) | fn drop(&mut self) {
  function test_msgs_dropped_on_unbounded_rx_drop (line 449) | async fn test_msgs_dropped_on_unbounded_rx_drop() {
  function downgrade_upgrade_unbounded_sender_success (line 476) | fn downgrade_upgrade_unbounded_sender_success() {
  function downgrade_upgrade_unbounded_sender_failure (line 485) | fn downgrade_upgrade_unbounded_sender_failure() {
  function downgrade_drop_upgrade_unbounded (line 495) | fn downgrade_drop_upgrade_unbounded() {
  function test_tx_count_weak_unbounded_sender (line 506) | fn test_tx_count_weak_unbounded_sender() {
  function test_rx_is_closed_when_dropping_all_senders_except_weak_senders (line 516) | async fn test_rx_is_closed_when_dropping_all_senders_except_weak_senders...
  function test_rx_unbounded_is_closed_when_dropping_all_senders_except_weak_senders (line 525) | async fn test_rx_unbounded_is_closed_when_dropping_all_senders_except_we...
  function sender_strong_count_when_cloned (line 534) | async fn sender_strong_count_when_cloned() {
  function sender_weak_count_when_downgraded (line 545) | async fn sender_weak_count_when_downgraded() {
  function sender_strong_count_when_dropped (line 555) | async fn sender_strong_count_when_dropped() {
  function sender_weak_count_when_dropped (line 567) | async fn sender_weak_count_when_dropped() {
  function sender_strong_and_weak_conut (line 579) | async fn sender_strong_and_weak_conut() {
  function unbounded_sender_strong_count_when_cloned (line 612) | async fn unbounded_sender_strong_count_when_cloned() {
  function unbounded_sender_weak_count_when_downgraded (line 623) | async fn unbounded_sender_weak_count_when_downgraded() {
  function unbounded_sender_strong_count_when_dropped (line 634) | async fn unbounded_sender_strong_count_when_dropped() {
  function unbounded_sender_weak_count_when_dropped (line 646) | async fn unbounded_sender_weak_count_when_dropped() {
  function unbounded_sender_strong_and_weak_conut (line 658) | async fn unbounded_sender_strong_and_weak_conut() {

FILE: tokio/tests/sync_mutex.rs
  function straight_execution (line 19) | fn straight_execution() {
  function readiness (line 42) | fn readiness() {
  function aborted_future_1 (line 95) | async fn aborted_future_1() {
  function aborted_future_2 (line 125) | async fn aborted_future_2() {
  function try_lock (line 152) | fn try_lock() {
  function debug_format (line 165) | async fn debug_format() {
  function mutex_debug (line 172) | async fn mutex_debug() {

FILE: tokio/tests/sync_mutex_owned.rs
  function straight_execution (line 19) | fn straight_execution() {
  function readiness (line 42) | fn readiness() {
  function aborted_future_1 (line 63) | async fn aborted_future_1() {
  function aborted_future_2 (line 93) | async fn aborted_future_2() {
  function try_lock_owned (line 120) | fn try_lock_owned() {
  function debug_format (line 133) | async fn debug_format() {

FILE: tokio/tests/sync_notify.rs
  type AssertSend (line 12) | trait AssertSend: Send + Sync {}
  function notify_notified_one (line 16) | fn notify_notified_one() {
  function notify_multi_notified_one (line 25) | fn notify_multi_notified_one() {
  function notify_multi_notified_last (line 41) | fn notify_multi_notified_last() {
  function notified_one_notify (line 57) | fn notified_one_notify() {
  function notified_multi_notify (line 69) | fn notified_multi_notify() {
  function notify_notified_multi (line 86) | fn notify_notified_multi() {
  function notified_drop_notified_notify (line 104) | fn notified_drop_notified_notify() {
  function notified_multi_notify_drop_one (line 121) | fn notified_multi_notify_drop_one() {
  function notified_multi_notify_one_drop (line 141) | fn notified_multi_notify_one_drop() {
  function notified_multi_notify_last_drop (line 163) | fn notified_multi_notify_last_drop() {
  function notify_in_drop_after_wake (line 184) | fn notify_in_drop_after_wake() {
  function notify_one_after_dropped_all (line 218) | fn notify_one_after_dropped_all() {
  function test_notify_one_not_enabled (line 235) | fn test_notify_one_not_enabled() {
  function test_notify_one_after_enable (line 244) | fn test_notify_one_after_enable() {
  function test_poll_after_enable (line 256) | fn test_poll_after_enable() {
  function test_enable_after_poll (line 265) | fn test_enable_after_poll() {
  function test_enable_consumes_permit (line 274) | fn test_enable_consumes_permit() {
  function test_waker_update (line 288) | fn test_waker_update() {

FILE: tokio/tests/sync_notify_owned.rs
  type AssertSend (line 13) | trait AssertSend: Send + Sync {}
  function notify_notified_one (line 17) | fn notify_notified_one() {
  function notify_multi_notified_one (line 26) | fn notify_multi_notified_one() {
  function notify_multi_notified_last (line 42) | fn notify_multi_notified_last() {
  function notified_one_notify (line 58) | fn notified_one_notify() {
  function notified_multi_notify (line 70) | fn notified_multi_notify() {
  function notify_notified_multi (line 87) | fn notify_notified_multi() {
  function notified_drop_notified_notify (line 105) | fn notified_drop_notified_notify() {
  function notified_multi_notify_drop_one (line 122) | fn notified_multi_notify_drop_one() {
  function notified_multi_notify_one_drop (line 142) | fn notified_multi_notify_one_drop() {
  function notified_multi_notify_last_drop (line 164) | fn notified_multi_notify_last_drop() {
  function notify_in_drop_after_wake (line 185) | fn notify_in_drop_after_wake() {
  function notify_one_after_dropped_all (line 219) | fn notify_one_after_dropped_all() {
  function test_notify_one_not_enabled (line 236) | fn test_notify_one_not_enabled() {
  function test_notify_one_after_enable (line 245) | fn test_notify_one_after_enable() {
  function test_poll_after_enable (line 257) | fn test_poll_after_enable() {
  function test_enable_after_poll (line 266) | fn test_enable_after_poll() {
  function test_enable_consumes_permit (line 275) | fn test_enable_consumes_permit() {
  function test_waker_update (line 289) | fn test_waker_update() {

FILE: tokio/tests/sync_once_cell.rs
  type Foo (line 13) | struct Foo {
    method from (line 24) | fn from(value: Arc<AtomicU32>) -> Self {
  method drop (line 18) | fn drop(&mut self) {
  function drop_cell (line 30) | fn drop_cell() {
  function drop_cell_new_with (line 41) | fn drop_cell_new_with() {
  function drop_into_inner (line 51) | fn drop_into_inner() {
  function drop_into_inner_new_with (line 65) | fn drop_into_inner_new_with() {
  function from (line 79) | fn from() {
  function func1 (line 84) | async fn func1() -> u32 {
  function func2 (line 88) | async fn func2() -> u32 {
  function func_err (line 93) | async fn func_err() -> Result<u32, ()> {
  function func_ok (line 97) | async fn func_ok() -> Result<u32, ()> {
  function func_panic (line 101) | async fn func_panic() -> u32 {
  function sleep_and_set (line 106) | async fn sleep_and_set() -> u32 {
  function advance_time_and_set (line 114) | async fn advance_time_and_set(cell: &'static OnceCell<u32>, v: u32) -> R...
  function get_or_init (line 120) | fn get_or_init() {
  function get_or_init_panic (line 145) | fn get_or_init_panic() {
  function set_and_get (line 170) | fn set_and_get() {
  function get_uninit (line 186) | fn get_uninit() {
  function set_twice (line 193) | fn set_twice() {
  function set_while_initializing (line 203) | fn set_while_initializing() {
  function get_or_try_init (line 228) | fn get_or_try_init() {

FILE: tokio/tests/sync_oneshot.rs
  type AssertSend (line 21) | trait AssertSend: Send {}
  type SenderExt (line 26) | trait SenderExt {
    method poll_closed (line 27) | fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll<()>;
    method poll_closed (line 31) | fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function send_recv (line 40) | fn send_recv() {
  function async_send_recv (line 55) | async fn async_send_recv() {
  function close_tx (line 63) | fn close_tx() {
  function close_rx (line 76) | fn close_rx() {
  function async_rx_closed (line 101) | async fn async_rx_closed() {
  function explicit_close_poll (line 112) | fn explicit_close_poll() {
  function explicit_close_try_recv (line 157) | fn explicit_close_try_recv() {
  function close_try_recv_poll (line 186) | fn close_try_recv_poll() {
  function close_after_recv (line 198) | fn close_after_recv() {
  function try_recv_after_completion (line 208) | fn try_recv_after_completion() {
  function try_recv_after_completion_await (line 219) | fn try_recv_after_completion_await() {
  function drops_tasks (line 231) | fn drops_tasks() {
  function receiver_changes_task (line 247) | fn receiver_changes_task() {
  function sender_changes_task (line 272) | fn sender_changes_task() {
  function receiver_is_terminated_send (line 297) | fn receiver_is_terminated_send() {
  function receiver_is_terminated_try_recv (line 321) | fn receiver_is_terminated_try_recv() {
  function receiver_is_terminated_drop (line 344) | fn receiver_is_terminated_drop() {
  function receiver_is_terminated_rx_close (line 368) | fn receiver_is_terminated_rx_close() {
  function receiver_is_empty_send (line 391) | fn receiver_is_empty_send() {
  function receiver_is_empty_try_recv (line 406) | fn receiver_is_empty_try_recv() {
  function receiver_is_empty_drop (line 420) | fn receiver_is_empty_drop() {
  function receiver_is_empty_rx_close (line 435) | fn receiver_is_empty_rx_close() {

FILE: tokio/tests/sync_panic.rs
  function broadcast_channel_panic_caller (line 17) | fn broadcast_channel_panic_caller() -> Result<(), Box<dyn Error>> {
  function mutex_blocking_lock_panic_caller (line 29) | fn mutex_blocking_lock_panic_caller() -> Result<(), Box<dyn Error>> {
  function oneshot_blocking_recv_panic_caller (line 45) | fn oneshot_blocking_recv_panic_caller() -> Result<(), Box<dyn Error>> {
  function rwlock_with_max_readers_panic_caller (line 61) | fn rwlock_with_max_readers_panic_caller() -> Result<(), Box<dyn Error>> {
  function rwlock_blocking_read_panic_caller (line 73) | fn rwlock_blocking_read_panic_caller() -> Result<(), Box<dyn Error>> {
  function rwlock_blocking_write_panic_caller (line 89) | fn rwlock_blocking_write_panic_caller() -> Result<(), Box<dyn Error>> {
  function mpsc_bounded_channel_panic_caller (line 105) | fn mpsc_bounded_channel_panic_caller() -> Result<(), Box<dyn Error>> {
  function mpsc_bounded_receiver_blocking_recv_panic_caller (line 117) | fn mpsc_bounded_receiver_blocking_recv_panic_caller() -> Result<(), Box<...
  function mpsc_bounded_receiver_blocking_recv_many_panic_caller (line 133) | fn mpsc_bounded_receiver_blocking_recv_many_panic_caller() -> Result<(),...
  function mpsc_bounded_sender_blocking_send_panic_caller (line 149) | fn mpsc_bounded_sender_blocking_send_panic_caller() -> Result<(), Box<dy...
  function mpsc_unbounded_receiver_blocking_recv_panic_caller (line 165) | fn mpsc_unbounded_receiver_blocking_recv_panic_caller() -> Result<(), Bo...
  function mpsc_unbounded_receiver_blocking_recv_many_panic_caller (line 181) | fn mpsc_unbounded_receiver_blocking_recv_many_panic_caller() -> Result<(...
  function semaphore_merge_unrelated_owned_permits (line 198) | fn semaphore_merge_unrelated_owned_permits() -> Result<(), Box<dyn Error...
  function semaphore_merge_unrelated_permits (line 214) | fn semaphore_merge_unrelated_permits() -> Result<(), Box<dyn Error>> {
  function current_thread (line 229) | fn current_thread() -> Runtime {

FILE: tokio/tests/sync_rwlock.rs
  function into_inner (line 21) | fn into_inner() {
  function read_shared (line 28) | fn read_shared() {
  function write_shared_pending (line 39) | fn write_shared_pending() {
  function read_exclusive_pending (line 50) | fn read_exclusive_pending() {
  function exhaust_reading (line 62) | fn exhaust_reading() {
  function write_exclusive_pending (line 83) | fn write_exclusive_pending() {
  function write_shared_drop (line 94) | fn write_shared_drop() {
  function write_read_shared_pending (line 109) | fn write_read_shared_pending() {
  function write_read_shared_drop_pending (line 127) | fn write_read_shared_drop_pending() {
  function read_uncontested (line 145) | async fn read_uncontested() {
  function write_uncontested (line 154) | async fn write_uncontested() {
  function write_order (line 163) | async fn write_order() {
  function multithreaded (line 178) | async fn multithreaded() {
  function try_write (line 252) | async fn try_write() {
  function try_read_try_write (line 261) | fn try_read_try_write() {
  function downgrade_map (line 285) | async fn downgrade_map() {
  function try_downgrade_map (line 307) | async fn try_downgrade_map() {

FILE: tokio/tests/sync_semaphore.rs
  function no_permits (line 10) | fn no_permits() {
  function try_acquire (line 16) | fn try_acquire() {
  function acquire (line 30) | async fn acquire() {
  function add_permits (line 43) | async fn add_permits() {
  function forget (line 54) | fn forget() {
  function merge (line 67) | fn merge() {
  function merge_unrelated_permits (line 83) | fn merge_unrelated_permits() {
  function split (line 92) | fn split() {
  function stress_test (line 119) | async fn stress_test() {
  function add_max_amount_permits (line 141) | fn add_max_amount_permits() {
  function add_more_than_max_amount_permits1 (line 150) | fn add_more_than_max_amount_permits1() {
  function add_more_than_max_amount_permits2 (line 158) | fn add_more_than_max_amount_permits2() {
  function panic_when_exceeds_maxpermits (line 167) | fn panic_when_exceeds_maxpermits() {
  function no_panic_at_maxpermits (line 172) | fn no_panic_at_maxpermits() {

FILE: tokio/tests/sync_semaphore_owned.rs
  function try_acquire (line 10) | fn try_acquire() {
  function try_acquire_many (line 23) | fn try_acquire_many() {
  function acquire (line 40) | async fn acquire() {
  function acquire_many (line 53) | async fn acquire_many() {
  function add_permits (line 69) | async fn add_permits() {
  function forget (line 80) | fn forget() {
  function merge (line 93) | fn merge() {
  function merge_unrelated_permits (line 109) | fn merge_unrelated_permits() {
  function split (line 118) | fn split() {
  function stress_test (line 145) | async fn stress_test() {

FILE: tokio/tests/sync_set_once.rs
  type DropCounter (line 11) | struct DropCounter {
    method new (line 16) | fn new() -> Self {
    method assert_num_drops (line 22) | fn assert_num_drops(&self, value: u32) {
  method drop (line 28) | fn drop(&mut self) {
  function drop_cell (line 34) | fn drop_cell() {
  function drop_cell_new_with (line 48) | fn drop_cell_new_with() {
  function drop_into_inner (line 60) | fn drop_into_inner() {
  function drop_into_inner_new_with (line 72) | fn drop_into_inner_new_with() {
  function from (line 83) | fn from() {
  function set_and_get (line 89) | fn set_and_get() {
  function set_and_wait (line 98) | async fn set_and_wait() {
  function set_and_wait_multiple_threads (line 109) | fn set_and_wait_multiple_threads() {
  function set_and_wait_threads (line 124) | async fn set_and_wait_threads() {
  function get_uninit (line 137) | fn get_uninit() {
  function set_twice (line 144) | fn set_twice() {
  function is_none_initializing (line 154) | fn is_none_initializing() {
  function is_some_initializing (line 165) | async fn is_some_initializing() {
  function into_inner_int_empty_setonce (line 174) | fn into_inner_int_empty_setonce() {

FILE: tokio/tests/sync_watch.rs
  function single_rx_recv (line 15) | fn single_rx_recv() {
  function rx_version_underflow (line 50) | fn rx_version_underflow() {
  function rx_mark_changed (line 59) | fn rx_mark_changed() {
  function rx_mark_unchanged (line 108) | fn rx_mark_unchanged() {
  function multi_rx (line 141) | fn multi_rx() {
  function rx_observes_final_value (line 208) | fn rx_observes_final_value() {
  function poll_close (line 253) | fn poll_close() {
  function borrow_and_update (line 270) | fn borrow_and_update() {
  function reopened_after_subscribe (line 294) | fn reopened_after_subscribe() {
  function send_modify_panic (line 311) | fn send_modify_panic() {
  function multiple_sender (line 339) | async fn multiple_sender() {
  function receiver_is_notified_when_last_sender_is_dropped (line 358) | async fn receiver_is_notified_when_last_sender_is_dropped() {
  function receiver_changed_is_cooperative (line 373) | async fn receiver_changed_is_cooperative() {
  function receiver_changed_is_cooperative_ok (line 390) | async fn receiver_changed_is_cooperative_ok() {
  function receiver_wait_for_is_cooperative (line 406) | async fn receiver_wait_for_is_cooperative() {
  function receiver_wait_for_is_cooperative_ok (line 423) | async fn receiver_wait_for_is_cooperative_ok() {
  function sender_closed_is_cooperative (line 439) | async fn sender_closed_is_cooperative() {
  function changed_succeeds_on_closed_channel_with_unseen_value (line 455) | async fn changed_succeeds_on_closed_channel_with_unseen_value() {
  function changed_errors_on_closed_channel_with_seen_value (line 467) | async fn changed_errors_on_closed_channel_with_seen_value() {
  function has_changed_errors_on_closed_channel_with_unseen_value (line 477) | fn has_changed_errors_on_closed_channel_with_unseen_value() {
  function has_changed_errors_on_closed_channel_with_seen_value (line 488) | fn has_changed_errors_on_closed_channel_with_seen_value() {
  function wait_for_errors_on_closed_channel_true_predicate (line 497) | async fn wait_for_errors_on_closed_channel_true_predicate() {

FILE: tokio/tests/task_abort.rs
  type PanicOnDrop (line 11) | struct PanicOnDrop;
  method drop (line 15) | fn drop(&mut self) {
  function test_abort_without_panic_3157 (line 23) | fn test_abort_without_panic_3157() {
  function test_abort_without_panic_3662 (line 45) | fn test_abort_without_panic_3662() {
  function remote_abort_local_set_3929 (line 108) | fn remote_abort_local_set_3929() {
  function test_abort_wakes_task_3964 (line 151) | fn test_abort_wakes_task_3964() {
  function test_abort_task_that_panics_on_drop_contained (line 182) | fn test_abort_task_that_panics_on_drop_contained() {
  function test_abort_task_that_panics_on_drop_returned (line 206) | fn test_abort_task_that_panics_on_drop_returned() {
  function test_join_error_display (line 229) | fn test_join_error_display() {
  function test_join_error_debug (line 280) | fn test_join_error_debug() {

FILE: tokio/tests/task_blocking.rs
  function basic_blocking (line 15) | async fn basic_blocking() {
  function block_in_blocking (line 36) | async fn block_in_blocking() {
  function block_in_block (line 59) | async fn block_in_block() {
  function no_block_in_current_thread_scheduler (line 80) | async fn no_block_in_current_thread_scheduler() {
  function yes_block_in_threaded_block_on (line 85) | fn yes_block_in_threaded_block_on() {
  function no_block_in_current_thread_block_on (line 94) | fn no_block_in_current_thread_block_on() {
  function can_enter_current_thread_rt_from_within_block_in_place (line 102) | fn can_enter_current_thread_rt_from_within_block_in_place() {
  function useful_panic_message_when_dropping_rt_in_rt (line 118) | fn useful_panic_message_when_dropping_rt_in_rt() {
  function can_shutdown_with_zero_timeout_in_runtime (line 142) | fn can_shutdown_with_zero_timeout_in_runtime() {
  function can_shutdown_now_in_runtime (line 154) | fn can_shutdown_now_in_runtime() {
  function coop_disabled_in_block_in_place (line 166) | fn coop_disabled_in_block_in_place() {
  function coop_disabled_in_block_in_place_in_block_on (line 197) | fn coop_disabled_in_block_in_place_in_block_on() {
  function blocking_when_paused (line 232) | async fn blocking_when_paused() {
  function blocking_task_wakes_paused_runtime (line 257) | async fn blocking_task_wakes_paused_runtime() {
  function unawaited_blocking_task_wakes_paused_runtime (line 274) | async fn unawaited_blocking_task_wakes_paused_runtime() {
  function panicking_blocking_task_wakes_paused_runtime (line 294) | async fn panicking_blocking_task_wakes_paused_runtime() {

FILE: tokio/tests/task_builder.rs
  function spawn_with_name (line 7) | async fn spawn_with_name() {
  function spawn_local_on_local_runtime (line 18) | async fn spawn_local_on_local_runtime() {
  function spawn_local_panics_outside_local_set_or_local_runtime (line 29) | async fn spawn_local_panics_outside_local_set_or_local_runtime() {
  function spawn_local_panics_in_multi_thread_runtime (line 38) | async fn spawn_local_panics_in_multi_thread_runtime() {
  function spawn_blocking_with_name (line 46) | async fn spawn_blocking_with_name() {
  function spawn_local_with_name (line 57) | async fn spawn_local_with_name() {
  function spawn_without_name (line 73) | async fn spawn_without_name() {
  function spawn_blocking_without_name (line 83) | async fn spawn_blocking_without_name() {
  function spawn_local_without_name (line 93) | async fn spawn_local_without_name() {

FILE: tokio/tests/task_hooks.rs
  constant TASKS (line 10) | const TASKS: usize = 8;
  constant ITERATIONS (line 11) | const ITERATIONS: usize = 64;
  function spawn_task_hook_fires (line 14) | fn spawn_task_hook_fires() {
  function terminate_task_hook_fires (line 50) | fn terminate_task_hook_fires() {
  function task_hook_spawn_location_current_thread (line 78) | fn task_hook_spawn_location_current_thread() {
  function task_hook_spawn_location_multi_thread (line 129) | fn task_hook_spawn_location_multi_thread() {
  function mk_spawn_location_hook (line 177) | fn mk_spawn_location_hook(

FILE: tokio/tests/task_id.rs
  function task_id_spawn (line 18) | async fn task_id_spawn() {
  function task_id_spawn_blocking (line 26) | async fn task_id_spawn_blocking() {
  function task_id_collision_current_thread (line 33) | async fn task_id_collision_current_thread() {
  function task_id_collision_multi_thread (line 43) | async fn task_id_collision_multi_thread() {
  function task_ids_match_current_thread (line 52) | async fn task_ids_match_current_thread() {
  function task_ids_match_multi_thread (line 64) | async fn task_ids_match_multi_thread() {
  function task_id_future_destructor_completion (line 76) | async fn task_id_future_destructor_completion() {
  function task_id_future_destructor_abort (line 104) | async fn task_id_future_destructor_abort() {
  function task_id_output_destructor_handle_dropped_before_completion (line 131) | async fn task_id_output_destructor_handle_dropped_before_completion() {
  function task_id_output_destructor_handle_dropped_after_completion (line 163) | async fn task_id_output_destructor_handle_dropped_after_completion() {
  function task_try_id_outside_task (line 204) | fn task_try_id_outside_task() {
  function task_try_id_inside_block_on (line 210) | fn task_try_id_inside_block_on() {
  function task_id_spawn_local (line 218) | async fn task_id_spawn_local() {
  function task_id_nested_spawn_local (line 229) | async fn task_id_nested_spawn_local() {
  function task_id_block_in_place_block_on_spawn (line 253) | async fn task_id_block_in_place_block_on_spawn() {
  function task_id_outside_task_panic_caller (line 275) | fn task_id_outside_task_panic_caller() -> Result<(), Box<dyn Error>> {
  function task_id_inside_block_on_panic_caller (line 288) | fn task_id_inside_block_on_panic_caller() -> Result<(), Box<dyn Error>> {

FILE: tokio/tests/task_join_set.rs
  function rt (line 10) | fn rt() -> tokio::runtime::Runtime {
  function spawn_index_tasks (line 17) | fn spawn_index_tasks(set: &mut JoinSet<usize>, n: usize, on: Option<&Loc...
  function spawn_pending_tasks (line 30) | fn spawn_pending_tasks(
  function drain_joinset_and_assert (line 53) | async fn drain_joinset_and_assert(mut set: JoinSet<usize>, n: usize) {
  function await_receivers_and_assert (line 65) | async fn await_receivers_and_assert(receivers: Vec<oneshot::Receiver<()>...
  function test_with_sleep (line 75) | async fn test_with_sleep() {
  function test_abort_on_drop (line 125) | async fn test_abort_on_drop() {
  function alternating (line 150) | async fn alternating() {
  function abort_tasks (line 168) | async fn abort_tasks() {
  function runtime_gone (line 202) | fn runtime_gone() {
  function join_all (line 218) | async fn join_all() {
  function task_panics (line 234) | async fn task_panics() {
  function abort_all (line 258) | async fn abort_all() {
  function join_set_coop (line 290) | async fn join_set_coop() {
  function try_join_next (line 331) | async fn try_join_next() {
  function try_join_next_with_id (line 367) | async fn try_join_next_with_id() {
  function extend (line 408) | async fn extend() {
  function panic_outside_any_runtime (line 431) | fn panic_outside_any_runtime() {
  function panic_in_multi_thread_runtime (line 440) | async fn panic_in_multi_thread_runtime() {
  function spawn_then_join_next (line 451) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 463) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 480) | async fn spawn_then_drop() {
  function spawn_then_join_next (line 499) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 514) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 536) | async fn spawn_then_drop() {
  function spawn_then_join_next (line 565) | async fn spawn_then_join_next() {
  function spawn_then_join_next (line 587) | async fn spawn_then_join_next() {
  function spawn_then_shutdown (line 604) | async fn spawn_then_shutdown() {
  function spawn_then_drop (line 625) | async fn spawn_then_drop() {

FILE: tokio/tests/task_local.rs
  function local (line 9) | async fn local() {
  function task_local_available_on_abort (line 41) | async fn task_local_available_on_abort() {
  function task_local_available_on_completion_drop (line 92) | async fn task_local_available_on_completion_drop() {
  function take_value (line 122) | async fn take_value() {
  function poll_after_take_value_should_fail (line 133) | async fn poll_after_take_value_should_fail() {
  function get_value (line 150) | async fn get_value() {

FILE: tokio/tests/task_local_set.rs
  function local_current_thread_scheduler (line 25) | async fn local_current_thread_scheduler() {
  function local_threadpool (line 35) | async fn local_threadpool() {
  function localset_future_threadpool (line 56) | async fn localset_future_threadpool() {
  function localset_future_timers (line 72) | async fn localset_future_timers() {
  function localset_future_drives_all_local_futs (line 91) | async fn localset_future_drives_all_local_futs() {
  function local_threadpool_timer (line 117) | async fn local_threadpool_timer() {
  function enter_guard_spawn (line 139) | fn enter_guard_spawn() {
  type BlockInPlaceOnDrop (line 161) | struct BlockInPlaceOnDrop;
  type Output (line 163) | type Output = ();
  method poll (line 165) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Outpu...
  method drop (line 170) | fn drop(&mut self) {
  function complete (line 175) | async fn complete(jh: tokio::task::JoinHandle<()>) {
  function local_threadpool_blocking_in_place (line 186) | fn local_threadpool_blocking_in_place() {
  function block_in_place_in_run_until_mt (line 210) | async fn block_in_place_in_run_until_mt() {
  function block_in_place_in_spawn_local_mt (line 221) | async fn block_in_place_in_spawn_local_mt() {
  function block_in_place_in_spawn_local_drop_mt (line 232) | async fn block_in_place_in_spawn_local_drop_mt() {
  function block_in_place_in_run_until_ct (line 242) | async fn block_in_place_in_run_until_ct() {
  function block_in_place_in_spawn_local_ct (line 253) | async fn block_in_place_in_spawn_local_ct() {
  function block_in_place_in_spawn_local_drop_ct (line 264) | async fn block_in_place_in_spawn_local_drop_ct() {
  function local_threadpool_blocking_run (line 275) | async fn local_threadpool_blocking_run() {
  function all_spawns_are_local (line 304) | async fn all_spawns_are_local() {
  function nested_spawn_is_local (line 331) | async fn nested_spawn_is_local() {
  function join_local_future_elsewhere (line 367) | fn join_local_future_elsewhere() {
  function localset_in_thread_local (line 404) | async fn localset_in_thread_local() {
  function drop_cancels_tasks (line 423) | fn drop_cancels_tasks() {
  function with_timeout (line 456) | fn with_timeout(timeout: Duration, f: impl FnOnce() + Send + 'static) {
  function drop_cancels_remote_tasks (line 497) | fn drop_cancels_remote_tasks() {
  function local_tasks_wake_join_all (line 523) | fn local_tasks_wake_join_all() {
  function local_tasks_are_polled_after_tick (line 545) | fn local_tasks_are_polled_after_tick() {
  function local_tasks_are_polled_after_tick_inner (line 562) | async fn local_tasks_are_polled_after_tick_inner() {
  function acquire_mutex_in_drop (line 623) | async fn acquire_mutex_in_drop() {
  function spawn_wakes_localset (line 659) | async fn spawn_wakes_localset() {
  function sleep_with_local_enter_guard (line 670) | async fn sleep_with_local_enter_guard() {
  function store_local_set_in_thread_local_with_runtime (line 689) | fn store_local_set_in_thread_local_with_runtime() {
  function shutdown_on_panic (line 739) | async fn shutdown_on_panic() {
  function run_until_does_not_get_own_budget (line 759) | async fn run_until_does_not_get_own_budget() {
  function rt (line 803) | fn rt() -> runtime::Runtime {

FILE: tokio/tests/task_panic.rs
  function block_in_place_panic_caller (line 16) | fn block_in_place_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_set_spawn_local_panic_caller (line 31) | fn local_set_spawn_local_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_set_block_on_panic_caller (line 45) | fn local_set_block_on_panic_caller() -> Result<(), Box<dyn Error>> {
  function spawn_panic_caller (line 62) | fn spawn_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_key_sync_scope_panic_caller (line 74) | fn local_key_sync_scope_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_key_with_panic_caller (line 94) | fn local_key_with_panic_caller() -> Result<(), Box<dyn Error>> {
  function local_key_get_panic_caller (line 110) | fn local_key_get_panic_caller() -> Result<(), Box<dyn Error>> {

FILE: tokio/tests/task_trace_self.rs
  type State (line 26) | enum State {
  function pretty (line 33) | pub fn pretty(f: F, logs: Arc<Mutex<Vec<Trace>>>) -> Self {
  type Output (line 43) | type Output = F::Output;
  method poll (line 45) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<F::Output> {
  function task_trace_self (line 70) | async fn task_trace_self() {

FILE: tokio/tests/task_yield_now.rs
  function yield_now_outside_of_runtime (line 8) | fn yield_now_outside_of_runtime() {
  function yield_now_external_executor_and_block_in_place (line 19) | async fn yield_now_external_executor_and_block_in_place() {

FILE: tokio/tests/tcp_accept.rs
  type TrackPolls (line 52) | struct TrackPolls<'a> {
  type Item (line 58) | type Item = io::Result<(TcpStream, SocketAddr)>;
  method poll_next (line 60) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function no_extra_poll (line 67) | async fn no_extra_poll() {
  function accept_many (line 99) | async fn accept_many() {

FILE: tokio/tests/tcp_connect.rs
  function connect_v4 (line 12) | async fn connect_v4() {
  function connect_v6 (line 39) | async fn connect_v6() {
  function connect_addr_ip_string (line 66) | async fn connect_addr_ip_string() {
  function connect_addr_ip_str_slice (line 83) | async fn connect_addr_ip_str_slice() {
  function connect_addr_host_string (line 100) | async fn connect_addr_host_string() {
  function connect_addr_ip_port_tuple (line 117) | async fn connect_addr_ip_port_tuple() {
  function connect_addr_ip_str_port_tuple (line 134) | async fn connect_addr_ip_str_port_tuple() {
  function connect_addr_host_str_port_tuple (line 151) | async fn connect_addr_host_str_port_tuple() {

FILE: tokio/tests/tcp_echo.rs
  function echo_server (line 11) | async fn echo_server() {

FILE: tokio/tests/tcp_into_split.rs
  function split (line 14) | async fn split() -> Result<()> {
  function reunite (line 58) | async fn reunite() -> Result<()> {
  function drop_write (line 86) | async fn drop_write() -> Result<()> {

FILE: tokio/tests/tcp_into_std.rs
  function tcp_into_std (line 12) | async fn tcp_into_std() -> Result<()> {

FILE: tokio/tests/tcp_peek.rs
  function peek (line 14) | async fn peek() {

FILE: tokio/tests/tcp_shutdown.rs
  function shutdown (line 11) | async fn shutdown() {
  function shutdown_after_tcp_reset (line 35) | async fn shutdown_after_tcp_reset() {
  function shutdown_multiple_calls (line 62) | async fn shutdown_multiple_calls() {

FILE: tokio/tests/tcp_socket.rs
  function basic_usage_v4 (line 10) | async fn basic_usage_v4() {
  function basic_usage_v6 (line 28) | async fn basic_usage_v6() {
  function bind_before_connect (line 46) | async fn bind_before_connect() {
  function basic_linger (line 65) | async fn basic_linger() {
  constant SET_BUF_SIZE (line 122) | const SET_BUF_SIZE: u32 = 4096;
  constant GET_BUF_SIZE (line 127) | const GET_BUF_SIZE: u32 = SET_BUF_SIZE;
  constant GET_BUF_SIZE (line 130) | const GET_BUF_SIZE: u32 = 2 * SET_BUF_SIZE;

FILE: tokio/tests/tcp_split.rs
  function split (line 13) | async fn split() -> Result<()> {

FILE: tokio/tests/tcp_stream.rs
  function set_linger (line 18) | async fn set_linger() {
  function try_read_write (line 37) | async fn try_read_write() {
  function buffer_not_included_in_future (line 160) | fn buffer_not_included_in_future() {
  function poll_read_ready (line 218) | async fn poll_read_ready() {
  function poll_write_ready (line 242) | async fn poll_write_ready() {
  function create_pair (line 257) | async fn create_pair() -> (TcpStream, TcpStream) {
  function read_until_pending (line 264) | fn read_until_pending(stream: &mut TcpStream) -> usize {
  function write_until_pending (line 279) | fn write_until_pending(stream: &mut TcpStream) -> usize {
  function try_read_buf (line 296) | async fn try_read_buf() {
  function read_closed (line 376) | async fn read_closed() {
  function write_closed (line 392) | async fn write_closed() {

FILE: tokio/tests/test_clock.rs
  function resume_lets_time_move_forward_instead_of_resetting_it (line 7) | async fn resume_lets_time_move_forward_instead_of_resetting_it() {
  function can_pause_after_resume (line 20) | async fn can_pause_after_resume() {
  function freezing_time_while_frozen_panics (line 33) | async fn freezing_time_while_frozen_panics() {
  function advancing_time_when_time_is_not_frozen_panics (line 40) | async fn advancing_time_when_time_is_not_frozen_panics() {
  function resuming_time_when_not_frozen_panics (line 46) | async fn resuming_time_when_not_frozen_panics() {

FILE: tokio/tests/time_alt.rs
  function rt_combinations (line 7) | fn rt_combinations() -> Vec<Runtime> {
  function sleep (line 47) | fn sleep() {
  function timeout (line 77) | fn timeout() {

FILE: tokio/tests/time_interval.rs
  function interval_zero_duration (line 29) | async fn interval_zero_duration() {
  function burst (line 43) | async fn burst() {
  function delay (line 87) | async fn delay() {
  function skip (line 139) | async fn skip() {
  function reset (line 172) | async fn reset() {
  function reset_immediately (line 208) | async fn reset_immediately() {
  function reset_after (line 243) | async fn reset_after() {
  function reset_at (line 279) | async fn reset_at() {
  function reset_at_bigger_than_interval (line 315) | async fn reset_at_bigger_than_interval() {
  function poll_next (line 355) | fn poll_next(interval: &mut task::Spawn<time::Interval>) -> Poll<Instant> {
  function ms (line 359) | fn ms(n: u64) -> Duration {
  type IntervalStreamer (line 373) | struct IntervalStreamer {
  type Item (line 380) | type Item = u32;
  method poll_next (line 382) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function stream_with_interval_poll_tick_self_waking (line 408) | async fn stream_with_interval_poll_tick_self_waking() {
  function stream_with_interval_poll_tick_no_waking (line 440) | async fn stream_with_interval_poll_tick_no_waking() {
  function interval_doesnt_panic_max_duration_when_polling (line 474) | async fn interval_doesnt_panic_max_duration_when_polling() {

FILE: tokio/tests/time_panic.rs
  function rt_combinations (line 16) | fn rt_combinations() -> Vec<Runtime> {
  function pause_panic_caller (line 62) | fn pause_panic_caller() -> Result<(), Box<dyn Error>> {
  function resume_panic_caller (line 79) | fn resume_panic_caller() -> Result<(), Box<dyn Error>> {
  function interval_panic_caller (line 95) | fn interval_panic_caller() -> Result<(), Box<dyn Error>> {
  function interval_at_panic_caller (line 107) | fn interval_at_panic_caller() -> Result<(), Box<dyn Error>> {
  function timeout_panic_caller (line 119) | fn timeout_panic_caller() -> Result<(), Box<dyn Error>> {
  function current_thread (line 134) | fn current_thread() -> Runtime {

FILE: tokio/tests/time_pause.rs
  function pause_time_in_main (line 20) | async fn pause_time_in_main() {
  function pause_time_in_task (line 25) | async fn pause_time_in_task() {
  function pause_time_in_main_threads (line 36) | async fn pause_time_in_main_threads() {
  function pause_time_in_spawn_threads (line 43) | async fn pause_time_in_spawn_threads() {
  function paused_time_is_deterministic (line 52) | fn paused_time_is_deterministic() {
  function paused_time_stress_run (line 60) | async fn paused_time_stress_run() -> Vec<Duration> {
  function advance_after_poll (line 75) | async fn advance_after_poll() {
  function sleep_no_poll (line 92) | async fn sleep_no_poll() {
  type State (line 107) | enum State {
  type Tester (line 113) | struct Tester {
  type Output (line 121) | type Output = ();
  method poll (line 123) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function sleep_same_task (line 153) | async fn sleep_same_task() {
  function sleep_same_task_no_poll (line 171) | async fn sleep_same_task_no_poll() {
  function interval (line 189) | async fn interval() {
  function test_time_advance_sub_ms (line 226) | async fn test_time_advance_sub_ms() {
  function test_time_advance_3ms_and_change (line 242) | async fn test_time_advance_3ms_and_change() {
  function regression_3710_with_submillis_advance (line 258) | async fn regression_3710_with_submillis_advance() {
  function exact_1ms_advance (line 276) | async fn exact_1ms_advance() {
  function advance_once_with_timer (line 292) | async fn advance_once_with_timer() {
  function advance_multi_with_timer (line 306) | async fn advance_multi_with_timer() {
  function poll_next (line 327) | fn poll_next(interval: &mut task::Spawn<time::Interval>) -> Poll<Instant> {
  function ms (line 331) | fn ms(n: u64) -> Duration {

FILE: tokio/tests/time_rt.rs
  function rt_combinations (line 9) | fn rt_combinations() -> Vec<Runtime> {
  function timer_with_threaded_runtime (line 56) | fn timer_with_threaded_runtime() {
  function timer_with_current_thread_scheduler (line 97) | fn timer_with_current_thread_scheduler() {
  function starving (line 116) | fn starving() {
  function timeout_value (line 151) | fn timeout_value() {

FILE: tokio/tests/time_sleep.rs
  function immediate_sleep (line 14) | async fn immediate_sleep() {
  function is_elapsed (line 25) | async fn is_elapsed() {
  function delayed_sleep_level_0 (line 44) | async fn delayed_sleep_level_0() {
  function sub_ms_delayed_sleep (line 58) | async fn sub_ms_delayed_sleep() {
  function delayed_sleep_wrapping_level_0 (line 72) | async fn delayed_sleep_wrapping_level_0() {
  function reset_future_sleep_before_fire (line 84) | async fn reset_future_sleep_before_fire() {
  function reset_past_sleep_before_turn (line 101) | async fn reset_past_sleep_before_turn() {
  function reset_past_sleep_before_fire (line 118) | async fn reset_past_sleep_before_fire() {
  function reset_future_sleep_after_fire (line 137) | async fn reset_future_sleep_after_fire() {
  function reset_sleep_to_past (line 152) | async fn reset_sleep_to_past() {
  function creating_sleep_outside_of_context (line 175) | fn creating_sleep_outside_of_context() {
  function greater_than_max (line 184) | async fn greater_than_max() {
  function short_sleeps (line 192) | async fn short_sleeps() {
  function multi_long_sleeps (line 199) | async fn multi_long_sleeps() {
  function long_sleeps (line 222) | async fn long_sleeps() {
  function reset_after_firing (line 238) | async fn reset_after_firing() {
  function exactly_max (line 263) | async fn exactly_max() {
  function issue_5183 (line 269) | async fn issue_5183() {
  function no_out_of_bounds_close_to_max (line 283) | async fn no_out_of_bounds_close_to_max() {
  function ms (line 288) | fn ms(n: u64) -> Duration {
  function drop_after_reschedule_at_new_scheduled_time (line 293) | async fn drop_after_reschedule_at_new_scheduled_time() {
  function drop_from_wake (line 315) | async fn drop_from_wake() {

FILE: tokio/tests/time_timeout.rs
  function simultaneous_deadline_future_completion (line 12) | async fn simultaneous_deadline_future_completion() {
  function completed_future_past_deadline (line 22) | async fn completed_future_past_deadline() {
  function future_and_deadline_in_future (line 31) | async fn future_and_deadline_in_future() {
  function future_and_timeout_in_future (line 55) | async fn future_and_timeout_in_future() {
  function very_large_timeout (line 79) | async fn very_large_timeout() {
  function deadline_now_elapses (line 106) | async fn deadline_now_elapses() {
  function deadline_future_elapses (line 122) | async fn deadline_future_elapses() {
  function ms (line 136) | fn ms(n: u64) -> Duration {
  function timeout_is_not_exhausted_by_future (line 141) | async fn timeout_is_not_exhausted_by_future() {

FILE: tokio/tests/time_wasm.rs
  function instant_now_panics (line 8) | fn instant_now_panics() {
  function runtime_without_time_does_not_panic (line 14) | fn runtime_without_time_does_not_panic() {
  function runtime_with_time_does_not_panic (line 24) | fn runtime_with_time_does_not_panic() {
  function sleep_panics_on_unknown_unknown (line 34) | fn sleep_panics_on_unknown_unknown() {

FILE: tokio/tests/tracing_sync.rs
  function test_barrier_creates_span (line 12) | async fn test_barrier_creates_span() {
  function test_mutex_creates_span (line 47) | async fn test_mutex_creates_span() {
  function test_oneshot_creates_span (line 91) | async fn test_oneshot_creates_span() {
  function test_rwlock_creates_span (line 190) | async fn test_rwlock_creates_span() {
  function test_semaphore_creates_span (line 246) | async fn test_semaphore_creates_span() {

FILE: tokio/tests/tracing_task.rs
  function task_spawn_creates_span (line 14) | async fn task_spawn_creates_span() {
  function task_spawn_loc_file_recorded (line 40) | async fn task_spawn_loc_file_recorded() {
  function task_builder_name_recorded (line 60) | async fn task_builder_name_recorded() {
  function task_builder_loc_file_recorded (line 79) | async fn task_builder_loc_file_recorded() {
  function task_spawn_sizes_recorded (line 101) | async fn task_spawn_sizes_recorded() {
  function task_big_spawn_sizes_recorded (line 128) | async fn task_big_spawn_sizes_recorded() {
  function expect_task_named (line 179) | fn expect_task_named(name: &str) -> NewSpan {

FILE: tokio/tests/tracing_time.rs
  function test_sleep_creates_span (line 13) | async fn test_sleep_creates_span() {

FILE: tokio/tests/udp.rs
  constant MSG (line 11) | const MSG: &[u8] = b"hello";
  constant MSG_LEN (line 12) | const MSG_LEN: usize = MSG.len();
  function send_recv (line 15) | async fn send_recv() -> std::io::Result<()> {
  function send_recv_poll (line 32) | async fn send_recv_poll() -> std::io::Result<()> {
  function send_to_recv_from (line 50) | async fn send_to_recv_from() -> std::io::Result<()> {
  function send_to_recv_from_poll (line 66) | async fn send_to_recv_from_poll() -> std::io::Result<()> {
  function send_to_peek_from (line 83) | async fn send_to_peek_from() -> std::io::Result<()> {
  function send_to_try_peek_from (line 111) | async fn send_to_try_peek_from() -> std::io::Result<()> {
  function send_to_peek_from_poll (line 150) | async fn send_to_peek_from_poll() -> std::io::Result<()> {
  function peek_sender (line 178) | async fn peek_sender() -> std::io::Result<()> {
  function poll_peek_sender (line 203) | async fn poll_peek_sender() -> std::io::Result<()> {
  function try_peek_sender (line 229) | async fn try_peek_sender() -> std::io::Result<()> {
  function split (line 264) | async fn split() -> std::io::Result<()> {
  function split_chan (line 280) | async fn split_chan() -> std::io::Result<()> {
  function split_chan_poll (line 312) | async fn split_chan_poll() -> std::io::Result<()> {
  function try_send_spawn (line 357) | async fn try_send_spawn() {
  function try_send_recv (line 398) | async fn try_send_recv() {
  function try_send_to_recv_from (line 442) | async fn try_send_to_recv_from() {
  function try_recv_buf (line 485) | async fn try_recv_buf() {
  function recv_buf (line 529) | async fn recv_buf() -> std::io::Result<()> {
  function try_recv_buf_from (line 546) | async fn try_recv_buf_from() {
  function recv_buf_from (line 589) | async fn recv_buf_from() -> std::io::Result<()> {
  function poll_ready (line 606) | async fn poll_ready() {

FILE: tokio/tests/uds_cred.rs
  function test_socket_pair (line 15) | async fn test_socket_pair() {

FILE: tokio/tests/uds_datagram.rs
  function echo_server (line 13) | async fn echo_server(socket: UnixDatagram) -> io::Result<()> {
  function echo (line 25) | async fn echo() -> io::Result<()> {
  function echo_from (line 50) | async fn echo_from() -> io::Result<()> {
  function try_send_recv_never_block (line 77) | async fn try_send_recv_never_block() -> io::Result<()> {
  function split (line 123) | async fn split() -> std::io::Result<()> {
  function send_to_recv_from_poll (line 148) | async fn send_to_recv_from_poll() -> std::io::Result<()> {
  function send_recv_poll (line 170) | async fn send_recv_poll() -> std::io::Result<()> {
  function try_send_to_recv_from (line 194) | async fn try_send_to_recv_from() -> std::io::Result<()> {
  function try_recv_buf_from (line 242) | async fn try_recv_buf_from() -> std::io::Result<()> {
  function recv_buf_from (line 290) | async fn recv_buf_from() -> std::io::Result<()> {
  function try_recv_buf_never_block (line 314) | async fn try_recv_buf_never_block() -> io::Result<()> {
  function recv_buf (line 362) | async fn recv_buf() -> std::io::Result<()> {
  function poll_ready (line 381) | async fn poll_ready() -> io::Result<()> {

FILE: tokio/tests/uds_socket.rs
  function datagram_echo_server (line 14) | async fn datagram_echo_server() -> io::Result<()> {
  function listen_and_stream (line 56) | async fn listen_and_stream() -> std::io::Result<()> {
  function assert_usage (line 96) | async fn assert_usage() -> std::io::Result<()> {

FILE: tokio/tests/uds_split.rs
  function split (line 15) | async fn split() -> std::io::Result<()> {
  function send_recv_all (line 33) | async fn send_recv_all(

FILE: tokio/tests/uds_stream.rs
  function accept_read_write (line 20) | async fn accept_read_write() -> std::io::Result<()> {
  function shutdown (line 47) | async fn shutdown() -> std::io::Result<()> {
  function try_read_write (line 70) | async fn try_read_write() -> std::io::Result<()> {
  function create_pair (line 196) | async fn create_pair() -> (UnixStream, UnixStream) {
  function poll_read_ready (line 242) | async fn poll_read_ready() {
  function poll_write_ready (line 265) | async fn poll_write_ready() {
  function read_until_pending (line 280) | fn read_until_pending(stream: &mut UnixStream) {
  function write_until_pending (line 293) | fn write_until_pending(stream: &mut UnixStream) {
  function try_read_buf (line 307) | async fn try_read_buf() -> std::io::Result<()> {
  function epollhup (line 391) | async fn epollhup() -> io::Result<()> {
  function abstract_socket_name (line 432) | async fn abstract_socket_name() {

FILE: tokio/tests/unwindsafe.rs
  function notify_is_unwind_safe (line 7) | fn notify_is_unwind_safe() {
  function join_handle_is_unwind_safe (line 12) | fn join_handle_is_unwind_safe() {
  function net_types_are_unwind_safe (line 17) | fn net_types_are_unwind_safe() {
  function unix_net_types_are_unwind_safe (line 26) | fn unix_net_types_are_unwind_safe() {
  function windows_net_types_are_unwind_safe (line 34) | fn windows_net_types_are_unwind_safe() {
  function is_unwind_safe (line 42) | fn is_unwind_safe<T: UnwindSafe + RefUnwindSafe>() {}