Update doc comments (#2572)

* Update doc comments

* Remove trailing whitespace

1 files changed, 16 insertions, 11 deletions

diff --git a/tokio/src/time/driver/mod.rs b/tokio/src/time/driver/mod.rs
index 4616816f..554042fc 100644
--- a/tokio/src/time/driver/mod.rs
+++ b/tokio/src/time/driver/mod.rs
@@ -26,29 +26,29 @@ use std::sync::Arc;
 use std::usize;
 use std::{cmp, fmt};
 
-/// Time implementation that drives [`Delay`], [`Interval`], and [`Timeout`].
+/// Time implementation that drives [`Delay`][delay], [`Interval`][interval], and [`Timeout`][timeout].
 ///
 /// A `Driver` instance tracks the state necessary for managing time and
-/// notifying the [`Delay`] instances once their deadlines are reached.
+/// notifying the [`Delay`][delay] instances once their deadlines are reached.
 ///
-/// It is expected that a single instance manages many individual [`Delay`]
+/// It is expected that a single instance manages many individual [`Delay`][delay]
 /// instances. The `Driver` implementation is thread-safe and, as such, is able
 /// to handle callers from across threads.
 ///
-/// After creating the `Driver` instance, the caller must repeatedly call
-/// [`turn`]. The time driver will perform no work unless [`turn`] is called
-/// repeatedly.
+/// After creating the `Driver` instance, the caller must repeatedly call `park`
+/// or `park_timeout`. The time driver will perform no work unless `park` or
+/// `park_timeout` is called repeatedly.
 ///
 /// The driver has a resolution of one millisecond. Any unit of time that falls
 /// between milliseconds are rounded up to the next millisecond.
 ///
-/// When an instance is dropped, any outstanding [`Delay`] instance that has not
+/// When an instance is dropped, any outstanding [`Delay`][delay] instance that has not
 /// elapsed will be notified with an error. At this point, calling `poll` on the
-/// [`Delay`] instance will result in `Err` being returned.
+/// [`Delay`][delay] instance will result in panic.
 ///
 /// # Implementation
 ///
-/// THe time driver is based on the [paper by Varghese and Lauck][paper].
+/// The time driver is based on the [paper by Varghese and Lauck][paper].
 ///
 /// A hashed timing wheel is a vector of slots, where each slot handles a time
 /// slice. As time progresses, the timer walks over the slot for the current
@@ -73,9 +73,14 @@ use std::{cmp, fmt};
 /// When the timer processes entries at level zero, it will notify all the
 /// `Delay` instances as their deadlines have been reached. For all higher
 /// levels, all entries will be redistributed across the wheel at the next level
-/// down. Eventually, as time progresses, entries will [`Delay`] instances will
+/// down. Eventually, as time progresses, entries will [`Delay`][delay] instances will
 /// either be canceled (dropped) or their associated entries will reach level
 /// zero and be notified.
+///
+/// [paper]: http://www.cs.columbia.edu/~nahum/w6998/papers/ton97-timing-wheels.pdf
+/// [delay]: crate::time::Delay
+/// [timeout]: crate::time::Timeout
+/// [interval]: crate::time::Interval
 #[derive(Debug)]
 pub(crate) struct Driver<T> {
     /// Shared state
@@ -119,7 +124,7 @@ where
     T: Park,
 {
     /// Creates a new `Driver` instance that uses `park` to block the current
-    /// thread and `now` to get the current `Instant`.
+    /// thread and `clock` to get the current `Instant`.
     ///
     /// Specifying the source of time is useful when testing.
     pub(crate) fn new(park: T, clock: Clock) -> Driver<T> {