Move all links to bottom.

Author: Alexis Hunt

src/crates-and-source-files.md

@@ -9,7 +9,7 @@
 
 > **<sup>Lexer</sup>**\
 > UTF8BOM : `\uFEFF`\
-> SHEBANG : `#!` ~[`[` `\n`] ~`\n`<sup>*</sup>
+> SHEBANG : `#!` ~[`[` `\n`] ~`\n`<sup>\*</sup>
 
 
 > Note: Although Rust, like any other language, can be implemented by an
@@ -78,11 +78,11 @@ type must  be one of the following:
 > Note: The implementation of which return types are allowed is determined by
 > the unstable [`Termination`] trait.
 
-The optional [_UTF8 byte order mark_] (UTF8BOM production) indicates that the
+The optional [_UTF8 byte order mark_] \(UTF8BOM production) indicates that the
 file is encoded in UTF8. It can only occur at the beginning of the file and
 is ignored by the compiler.
 
-A source file can have a [_shebang_] (SHEBANG production), which indicates
+A source file can have a [_shebang_] \(SHEBANG production), which indicates
 to the operating system what program to use to execute this file. It serves
 essentially to treat the source file as an executable script. The shebang
 can only occur at the beginning of the file (but after the optional

src/expressions.md

@@ -87,7 +87,7 @@ A *value expression* is an expression that represents an actual value.
 The left operand of an [assignment][assign] or [compound assignment] expression
 is a place expression context, as is the single operand of a unary [borrow], and
 the operand of any [implicit borrow]. The discriminant or subject of a
-[match expression][match] and right side of a [let statement] is also a place
+[match expression][match] and right side of a [let statement][let] is also a place
 expression context. All other expression contexts are value expression contexts.
 
 > Note: Historically, place expressions were called *lvalues* and value
@@ -102,7 +102,7 @@ the remaining situations if that type is [`Sized`], then it may be possible to
 move the value. Only the following place expressions may be moved out of:
 
 * [Variables] which are not currently borrowed.
-* [Temporary values](#temporary-lifetimes).
+* [Temporary values].
 * [Fields][field] of a place expression which can be moved out of and
   doesn't implement [`Drop`].
 * The result of [dereferencing] an expression with type [`Box<T>`] and that can
@@ -145,9 +145,9 @@ of a value expression to a `'static` slot occurs when the expression could be
 written in a constant, borrowed, and dereferencing that borrow where the
 expression was the originally written, without changing the runtime behavior.
 That is, the promoted expression can be evaluated at compile-time and the
-resulting value does not contain [interior mutability] or [destructors] (these
-properties are determined based on the value where possible, e.g. `&None`
-always has the type `&'static Option<_>`, as it contains nothing disallowed).
+resulting value does not contain [interior mutability] or [destructors] \(these
+properties are determined based on the value where possible, e.g. `&None` always
+has the type `&'static Option<_>`, as it contains nothing disallowed).
 Otherwise, the lifetime of temporary values is typically
 
 - the innermost enclosing statement; the tail expression of a block is
@@ -233,9 +233,9 @@ Implicit borrows may be taken in the following expressions:
 
 Certain types of expressions can be evaluated at compile time. These are called
 _constant expressions_. Certain places, such as in
-[constants](items/constant-items.html) and [statics](items/static-items.html),
+[constants] and [statics](static variables),
 require a constant expression, and are always evaluated at compile time. In
-other places, such as in [`let` statements](statements.html#let-statements),
+other places, such as in [`let` statements][let],
 constant expressions may be evaluated at compile time. If errors, such as out
 of bounds [array indexing] or [overflow] occurs,
 then it is a compiler error if the value must be evaluated at compile time,
@@ -246,7 +246,7 @@ also constant expressions and do not cause any [`Drop::drop`][destructors] calls
 to be ran.
 
 * [Literals].
-* [Paths] to [functions](items/functions.html) and constants.
+* [Paths] to [functions] and constants.
   Recursively defining constants is not allowed.
 * [Tuple expressions].
 * [Array expressions].
@@ -302,6 +302,8 @@ exist in `core::ops` and `core::cmp` with the same names.
 [negation]:             expressions/operator-expr.html#negation-operators
 [overflow]:             expressions/operator-expr.html#overflow
 
+[functions]: items/functions.html
+[constants]: items/constant-items.html
 [destructors]:          destructors.html
 [interior mutability]:  interior-mutability.html
 [`Box<T>`]:             ../std/boxed/struct.Box.html
@@ -311,7 +313,6 @@ exist in `core::ops` and `core::cmp` with the same names.
 [implicit borrow]:      #implicit-borrows
 [implicitly mutably borrowed]: #implicit-borrows
 [let]:                  statements.html#let-statements
-[let statement]:        statements.html#let-statements
 [Mutable `static` items]: items/static-items.html#mutable-statics
 [slice]:                types.html#array-and-slice-types
 [static variables]:     items/static-items.html

src/influences.md

@@ -18,5 +18,6 @@ that have since been removed):
 * C#: attributes
 * Ruby: <strike>block syntax</strike>
 * NIL, Hermes: <strike>typestate</strike>
-* [Unicode Annex #31](http://www.unicode.org/reports/tr31/): identifier and
-  pattern syntax
+* [Unicode Annex #31]: identifier and pattern syntax
+
+[Unicode Annex #31]: http://www.unicode.org/reports/tr31/

src/interior-mutability.md

@@ -26,5 +26,3 @@ across threads.
 [`std::cell::UnsafeCell<T>`]: ../std/cell/struct.UnsafeCell.html
 [`std::cell::RefCell<T>`]: ../std/cell/struct.RefCell.html
 [`std::sync::atomic`]: ../std/sync/atomic/index.html
-
-

src/items.md

@@ -5,27 +5,24 @@ nested set of [modules]. Every crate has a single "outermost" anonymous module;
 all further items within the crate have [paths] within the module tree of the
 crate.
 
-[modules]: items/modules.html
-[paths]: paths.html
-
 Items are entirely determined at compile-time, generally remain fixed during
 execution, and may reside in read-only memory.
 
 There are several kinds of items:
 
-* [modules](items/modules.html)
-* [`extern crate` declarations](items/extern-crates.html)
-* [`use` declarations](items/use-declarations.html)
-* [function definitions](items/functions.html)
-* [type definitions](items/type-aliases.html)
-* [struct definitions](items/structs.html)
-* [enumeration definitions](items/enumerations.html)
-* [union definitions](items/unions.html)
-* [constant items](items/constant-items.html)
-* [static items](items/static-items.html)
-* [trait definitions](items/traits.html)
-* [implementations](items/implementations.html)
-* [`extern` blocks](items/external-blocks.html)
+* [modules]
+* [`extern crate` declarations]
+* [`use` declarations]
+* [function definitions]
+* [type definitions]
+* [struct definitions]
+* [enumeration definitions]
+* [union definitions]
+* [constant items]
+* [static items]
+* [trait definitions]
+* [implementations]
+* [`extern` blocks]
 
 Some items form an implicit scope for the declaration of sub-items. In other
 words, within a function or module, declarations of items can (in many cases)
@@ -36,3 +33,19 @@ as if the item was declared outside the scope — it is still a static item
 qualified by the name of the enclosing item, or is private to the enclosing
 item (in the case of functions). The grammar specifies the exact locations in
 which sub-item declarations may appear.
+
+[modules]: items/modules.html
+[paths]: paths.html
+[modules]: items/modules.html
+[`extern crate` declarations]: items/extern-crates.html
+[`use` declarations]: items/use-declarations.html
+[function definitions]: items/functions.html
+[type definitions]: items/type-aliases.html
+[struct definitions]: items/structs.html
+[enumeration definitions]: items/enumerations.html
+[union definitions]: items/unions.html
+[constant items]: items/constant-items.html
+[static items]: items/static-items.html
+[trait definitions]: items/traits.html
+[implementations]: items/implementations.html
+[`extern` blocks]: items/external-blocks.html

src/keywords.md

@@ -2,9 +2,9 @@
 
 Rust divides keywords into three categories:
 
-* [strict](#strict-keywords)
-* [reserved](#reserved-keywords)
-* [weak](#weak-keywords)
+* [strict]
+* [reserved]
+* [weak]
 
 ## Strict keywords
 
@@ -111,3 +111,6 @@ is possible to declare a variable or method with the name `union`.
 [union]: items/unions.html
 [variants]: items/enumerations.html
 [trait object]: types.html#trait-objects
+[strict]: #strict-keywords
+[reserved]: #reserved-keywords
+[weak]: #weak-keywords

src/lifetime-elision.md

@@ -12,7 +12,7 @@ It is an error to elide lifetime parameters that cannot be inferred. The
 placeholder lifetime, `'_`, can also be used to have a lifetime inferred in the
 same way. For lifetimes in paths, using `'_` is preferred. Trait object
 lifetimes follow different rules discussed
-[below](#default-trait-object-lifetimes).
+[below][trait object lifetimes].
 
 * Each elided lifetime in the parameters becomes a distinct lifetime parameter.
 * If there is exactly one lifetime used in the parameters (elided or not), that
@@ -179,3 +179,4 @@ const RESOLVED_STATIC: &dyn Fn(&Foo, &Bar) -> &Baz = ..
 [static]: items/static-items.html
 [trait object]: types.html#trait-objects
 [type aliases]: items/type-aliases.html
+[trait object lifetimes]: #default-trait-object-lifetimes

src/linkage.md

@@ -5,8 +5,6 @@ statically and dynamically. This section will explore the various methods to
 link Rust crates together, and more information about native libraries can be
 found in the [FFI section of the book][ffi].
 
-[ffi]: ../book/ffi.html
-
 In one session of compilation, the compiler can generate multiple artifacts
 through the usage of either command line flags or the `crate_type` attribute.
 If one or more command line flags are specified, all `crate_type` attributes will
@@ -196,12 +194,13 @@ fn main() {
 }
 ```
 
-[cargo]: http://doc.crates.io/environment-variables.html#environment-variables-cargo-sets-for-build-scripts
-
 To use this feature locally, you typically will use the `RUSTFLAGS` environment
 variable to specify flags to the compiler through Cargo. For example to compile
 a statically linked binary on MSVC you would execute:
 
 ```ignore,notrust
 RUSTFLAGS='-C target-feature=+crt-static' cargo build --target x86_64-pc-windows-msvc
 ```
+
+[ffi]: ../book/ffi.html
+[cargo]: http://doc.crates.io/environment-variables.html#environment-variables-cargo-sets-for-build-scripts

src/macros-by-example.md

@@ -32,18 +32,6 @@ syntax named by _designator_. Valid designators are:
 * `meta`: the contents of an [attribute]
 * `lifetime`: a lifetime. Examples: `'static`, `'a`.
 
-[item]: items.html
-[block]: expressions/block-expr.html
-[statement]: statements.html
-[pattern]: expressions/match-expr.html
-[expression]: expressions.html
-[type]: types.html
-[identifier]: identifiers.html
-[keyword]: keywords.html
-[path]: paths.html
-[token]: tokens.html
-[attribute]: attributes.html
-
 In the transcriber, the
 designator is already known, and so only the name of a matched nonterminal comes
 after the dollar sign.
@@ -88,3 +76,14 @@ Rust syntax is restricted in two ways:
    requiring a distinctive token in front can solve the problem.
 
 [RFC 550]: https://github.com/rust-lang/rfcs/blob/master/text/0550-macro-future-proofing.md
+[item]: items.html
+[block]: expressions/block-expr.html
+[statement]: statements.html
+[pattern]: expressions/match-expr.html
+[expression]: expressions.html
+[type]: types.html
+[identifier]: identifiers.html
+[keyword]: keywords.html
+[path]: paths.html
+[token]: tokens.html
+[attribute]: attributes.html

src/paths.md

@@ -164,6 +164,7 @@ mod without { // ::without
 
 # fn main() {}
 ```
+
 [item]: items.html
 [variable]: variables.html
 [identifiers]: identifiers.html