Add and fix more links.

Author: ehuss

src/expressions/await-expr.md

@@ -5,16 +5,16 @@
 >    [_Expression_] `.` `await`
 
 Await expressions are legal only within `async` contexts, like an
-`async fn` or an `async` block. They operate on a future. Their effect
+[`async fn`] or an [`async` block]. They operate on a [future]. Their effect
 is to suspend the current computation until the given future is ready
 to produce a value.
 
 More specifically, an `<expr>.await` expression has the following effect.
 
 1. Evaluate `<expr>` to a [future] `tmp`;
-2. Pin `tmp` using `Pin::new_unchecked`;
+2. Pin `tmp` using [`Pin::new_unchecked`];
 3. This pinned future is then polled by calling the [`Future::poll`] method and
-   passing it the current task context (see below);
+   passing it the current [task context](#task-context);
 3. If the call to `poll` returns [`Poll::Pending`], then the future
    returns `Poll::Pending`, suspending its state so that, when the
    surrounding async context is re-polled, execution returns to step
@@ -23,10 +23,13 @@ More specifically, an `<expr>.await` expression has the following effect.
    value contained in the [`Poll::Ready`] variant is used as the result
    of the `await` expression itself.
 
+[`async fn`]: items/functions.html#async-functions
+[`async` block]: expressions/block-expr.html#async-blocks
 [future]: ../std/future/trait.Future.html
 [_Expression_]: expressions.html
 [`Future::poll`]: ../std/future/trait.Future.html#tymethod.poll
 [`Context`]: ../std/task/struct.Context.html
+[`Pin::new_unchecked`]: ../std/pin/struct.Pin.html#method.new_unchecked
 [`Poll::Pending`]: ../std/task/enum.Poll.html#variant.Pending
 [`Poll::Ready`]: ../std/task/enum.Poll.html#variant.Ready
 

src/expressions/block-expr.md

@@ -93,8 +93,8 @@ the result value of the future.
 Executing an async block is similar to executing a closure expression:
 its immediate effect is to produce and return an anonymous type.
 Whereas closures return a type that implements one or more of the
-`std::ops::Fn` traits, however, the type returned for an async block
-implements the `std::future::Future` trait. The actual data format for
+[`std::ops::Fn`] traits, however, the type returned for an async block
+implements the [`std::future::Future`] trait. The actual data format for
 this type is unspecified.
 
 > **Note:** The future type that rustc generates is roughly equivalent
@@ -103,6 +103,9 @@ this type is unspecified.
 
 > **Edition differences**: Async blocks are only available in Rust 2018.
 
+[`std::ops::Fn`]: ../std/ops/trait.Fn.html
+[`std::future::Future`]: ../std/future/trait.Future.html
+
 ### Capture modes
 
 Async blocks capture variables from their environment using the same

src/items/functions.md

@@ -207,7 +207,8 @@ capture their arguments into a future. When polled, that future will
 execute the function's body.
 
 An async function is roughly equivalent to a function
-that returns [`impl Future`] and with an [`async move` block] as its body:
+that returns [`impl Future`] and with an [`async move` block][async-blocks] as
+its body:
 
 ```rust,edition2018
 // Source
@@ -227,18 +228,18 @@ The actual desugaring is more complex:
   parameters from the `async fn` declaration. This can be seen in the
   desugared example above, which explicitly outlives, and hence
   captures, `'a`.
-- The [`async move` block] in the body captures all function
+- The [`async move` block][async-blocks] in the body captures all function
   parameters, including those that are unused or bound to a `_`
   pattern. This ensures that function parameters are dropped in the
   same order as they would be if the function were not async, except
   that the drop occurs when the returned future has been fully
   awaited.
-  
-For more information on the effect of async, see [`async` blocks][`async` block]. 
 
-[`async move` block]: ../expressions/block-expr.html#async-blocks
-[`impl Future`]: ../types/impl-trait.html
-  
+For more information on the effect of async, see [`async` blocks][async-blocks].
+
+[async-blocks]: expressions/block-expr.html#async-blocks
+[`impl Future`]: types/impl-trait.html
+
 > **Edition differences**: Async functions are only available in Rust 2018.
 
 ## Attributes on functions