Skip to content

Commit

Permalink
Rollup merge of #39976 - steveklabnik:reenable-book-linkchecker, r=fr…
Browse files Browse the repository at this point in the history
…ewsxcv

Reenable linkchecker for books

In some senses, this is a revert of cacb3bc#diff-b64563d143f859565c8357a28ef81101R212; we disabled linkchecker for the book because the links were added by JavaScript. Now, that's fixed upstream, and so we can re-enable the checker.

This also involves two other fixes: we have to check for `name`s as well as `id`s for links, and the linking algorithm of mdBook changed to the same as rustdoc's, so we change some links back.

~~~This isn't quite ready yet; it's [depending on a PR of mine to mdBook](https://github.com/azerupi/mdBook/pull/209). After that's released, this should be the last of these kinds of shenanigans~~~ 😄

This is good to go 😄
  • Loading branch information
frewsxcv authored Feb 20, 2017
2 parents 7ef0192 + 010a28d commit 9a8dbbe
Show file tree
Hide file tree
Showing 30 changed files with 116 additions and 108 deletions.
6 changes: 3 additions & 3 deletions src/Cargo.lock

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion src/doc/book/src/casting-between-types.md
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@ most dangerous features of Rust!
# Coercion

Coercion between types is implicit and has no syntax of its own, but can
be spelled out with [`as`](#Explicit%20coercions).
be spelled out with [`as`](#explicit-coercions).

Coercion occurs in `let`, `const`, and `static` statements; in
function call arguments; in field values in struct initialization; and in a
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/closures.md
Original file line number Diff line number Diff line change
Expand Up @@ -463,7 +463,7 @@ fn factory() -> &(Fn(i32) -> i32) {

Right. Because we have a reference, we need to give it a lifetime. But
our `factory()` function takes no arguments, so
[elision](lifetimes.html#Lifetime%20Elision) doesn’t kick in here. Then what
[elision](lifetimes.html#lifetime-elision) doesn’t kick in here. Then what
choices do we have? Try `'static`:

```rust,ignore
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/compiler-plugins.md
Original file line number Diff line number Diff line change
Expand Up @@ -127,7 +127,7 @@ enum. For a more involved macro example, see

## Tips and tricks

Some of the [macro debugging tips](macros.html#Debugging%20macro%20code) are applicable.
Some of the [macro debugging tips](macros.html#debugging-macro-code) are applicable.

You can use `syntax::parse` to turn token trees into
higher-level syntax elements like expressions:
Expand Down
4 changes: 2 additions & 2 deletions src/doc/book/src/concurrency.md
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ For sharing references across threads, Rust provides a wrapper type called
`Arc<T>`. `Arc<T>` implements `Send` and `Sync` if and only if `T` implements
both `Send` and `Sync`. For example, an object of type `Arc<RefCell<U>>` cannot
be transferred across threads because
[`RefCell`](choosing-your-guarantees.html#RefCell%3CT%3E) does not implement
[`RefCell`](choosing-your-guarantees.html#refcellt) does not implement
`Sync`, consequently `Arc<RefCell<U>>` would not implement `Send`.

These two traits allow you to use the type system to make strong guarantees
Expand Down Expand Up @@ -126,7 +126,7 @@ closure only captures a _reference to `x`_. This is a problem, because the
thread may outlive the scope of `x`, leading to a dangling pointer.

To fix this, we use a `move` closure as mentioned in the error message. `move`
closures are explained in depth [here](closures.html#move%20closures); basically
closures are explained in depth [here](closures.html#move-closures); basically
they move variables from their environment into themselves.

```rust
Expand Down
72 changes: 36 additions & 36 deletions src/doc/book/src/error-handling.md
Original file line number Diff line number Diff line change
Expand Up @@ -21,35 +21,35 @@ sum types and combinators, and try to motivate the way Rust does error handling
incrementally. As such, programmers with experience in other expressive type
systems may want to jump around.

* [The Basics](#The%20Basics)
* [Unwrapping explained](#Unwrapping%20explained)
* [The `Option` type](#The%20Option%20type)
* [Composing `Option<T>` values](#Composing%20Option%3CT%3E%20values)
* [The `Result` type](#The%20Result%20type)
* [Parsing integers](#Parsing%20integers)
* [The `Result` type alias idiom](#The%20Result%20type%20alias%20idiom)
* [A brief interlude: unwrapping isn't evil](#A%20brief%20interlude:%20unwrapping%20isnt%20evil)
* [Working with multiple error types](#Working%20with%20multiple%20error%20types)
* [Composing `Option` and `Result`](#Composing%20Option%20and%20Result)
* [The limits of combinators](#The%20limits%20of%20combinators)
* [Early returns](#Early%20returns)
* [The `try!` macro](#The%20try%20macro)
* [Defining your own error type](#Defining%20your%20own%20error%20type)
* [Standard library traits used for error handling](#Standard%20library%20traits%20used%20for%20error%20handling)
* [The `Error` trait](#The%20Error%20trait)
* [The `From` trait](#The%20From%20trait)
* [The real `try!` macro](#The%20real%20try%20macro)
* [Composing custom error types](#Composing%20custom%20error%20types)
* [Advice for library writers](#Advice%20for%20library%20writers)
* [Case study: A program to read population data](#Case%20study:%20A%20program%20to%20read%20population%20data)
* [Initial setup](#Initial%20setup)
* [Argument parsing](#Argument%20parsing)
* [Writing the logic](#Writing%20the%20logic)
* [Error handling with `Box<Error>`](#Error%20handling%20with%20Box%3CError%3E)
* [Reading from stdin](#Reading%20from%20stdin)
* [Error handling with a custom type](#Error%20handling%20with%20a%20custom%20type)
* [Adding functionality](#Adding%20functionality)
* [The short story](#The%20short%20story)
* [The Basics](#the-basics)
* [Unwrapping explained](#unwrapping-explained)
* [The `Option` type](#the-option-type)
* [Composing `Option<T>` values](#composing-optiont-values)
* [The `Result` type](#the-result-type)
* [Parsing integers](#parsing-integers)
* [The `Result` type alias idiom](#the-result-type-alias-idiom)
* [A brief interlude: unwrapping isn't evil](#a-brief-interlude-unwrapping-isnt-evil)
* [Working with multiple error types](#working-with-multiple-error-types)
* [Composing `Option` and `Result`](#composing-option-and-result)
* [The limits of combinators](#the-limits-of-combinators)
* [Early returns](#early-returns)
* [The `try!` macro](#the-try-macro)
* [Defining your own error type](#defining-your-own-error-type)
* [Standard library traits used for error handling](#standard-library-traits-used-for-error-handling)
* [The `Error` trait](#the-error-trait)
* [The `From` trait](#the-from-trait)
* [The real `try!` macro](#the-real-try-macro)
* [Composing custom error types](#composing-custom-error-types)
* [Advice for library writers](#advice-for-library-writers)
* [Case study: A program to read population data](#case-study-a-program-to-read-population-data)
* [Initial setup](#initial-setup)
* [Argument parsing](#argument-parsing)
* [Writing the logic](#writing-the-logic)
* [Error handling with `Box<Error>`](#error-handling-with-boxerror)
* [Reading from stdin](#reading-from-stdin)
* [Error handling with a custom type](#error-handling-with-a-custom-type)
* [Adding functionality](#adding-functionality)
* [The short story](#the-short-story)

# The Basics

Expand Down Expand Up @@ -796,7 +796,7 @@ because of the return types of
[`std::fs::File::open`](../std/fs/struct.File.html#method.open) and
[`std::io::Read::read_to_string`](../std/io/trait.Read.html#method.read_to_string).
(Note that they both use the [`Result` type alias
idiom](#The%20Result%20type%20alias%20idiom) described previously. If you
idiom](#the-result-type-alias-idiom) described previously. If you
click on the `Result` type, you'll [see the type
alias](../std/io/type.Result.html), and consequently, the underlying
`io::Error` type.) The third problem is described by the
Expand Down Expand Up @@ -1120,7 +1120,7 @@ returns an `&Error`, which is itself a trait object. We'll revisit the

For now, it suffices to show an example implementing the `Error` trait. Let's
use the error type we defined in the
[previous section](#Defining%20your%20own%20error%20type):
[previous section](#defining-your-own-error-type):

```rust
use std::io;
Expand Down Expand Up @@ -1493,19 +1493,19 @@ representation. But certainly, this will vary depending on use cases.
At a minimum, you should probably implement the
[`Error`](../std/error/trait.Error.html)
trait. This will give users of your library some minimum flexibility for
[composing errors](#The%20real%20try%20macro). Implementing the `Error` trait also
[composing errors](#the-real-try-macro). Implementing the `Error` trait also
means that users are guaranteed the ability to obtain a string representation
of an error (because it requires impls for both `fmt::Debug` and
`fmt::Display`).

Beyond that, it can also be useful to provide implementations of `From` on your
error types. This allows you (the library author) and your users to
[compose more detailed errors](#Composing%20custom%20error%20types). For example,
[compose more detailed errors](#composing-custom-error-types). For example,
[`csv::Error`](http://burntsushi.net/rustdoc/csv/enum.Error.html)
provides `From` impls for both `io::Error` and `byteorder::Error`.

Finally, depending on your tastes, you may also want to define a
[`Result` type alias](#The%20Result%20type%20alias%20idiom), particularly if your
[`Result` type alias](#the-result-type-alias-idiom), particularly if your
library defines a single error type. This is used in the standard library
for [`io::Result`](../std/io/type.Result.html)
and [`fmt::Result`](../std/fmt/type.Result.html).
Expand Down Expand Up @@ -1538,7 +1538,7 @@ and [`rustc-serialize`](https://crates.io/crates/rustc-serialize) crates.

We're not going to spend a lot of time on setting up a project with
Cargo because it is already covered well in [the Cargo
section](getting-started.html#Hello%20Cargo) and [Cargo's documentation][14].
section](getting-started.html#hello-cargo) and [Cargo's documentation][14].

To get started from scratch, run `cargo new --bin city-pop` and make sure your
`Cargo.toml` looks something like this:
Expand Down Expand Up @@ -1729,7 +1729,7 @@ error types and you don't need any `From` implementations. The downside is that
since `Box<Error>` is a trait object, it *erases the type*, which means the
compiler can no longer reason about its underlying type.

[Previously](#The%20limits%20of%20combinators) we started refactoring our code by
[Previously](#the-limits-of-combinators) we started refactoring our code by
changing the type of our function from `T` to `Result<T, OurErrorType>`. In
this case, `OurErrorType` is only `Box<Error>`. But what's `T`? And can we add
a return type to `main`?
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/ffi.md
Original file line number Diff line number Diff line change
Expand Up @@ -680,7 +680,7 @@ pub extern fn hello_rust() -> *const u8 {

The `extern` makes this function adhere to the C calling convention, as
discussed above in "[Foreign Calling
Conventions](ffi.html#Foreign%20calling%20conventions)". The `no_mangle`
Conventions](ffi.html#foreign-calling-conventions)". The `no_mangle`
attribute turns off Rust's name mangling, so that it is easier to link to.

# FFI and panics
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/getting-started.md
Original file line number Diff line number Diff line change
Expand Up @@ -236,7 +236,7 @@ language]*, which means that most things are expressions, rather than
statements. The `;` indicates that this expression is over, and the next one is
ready to begin. Most lines of Rust code end with a `;`.

[expression-oriented language]: glossary.html#Expression-Oriented%20Language
[expression-oriented language]: glossary.html#expression-oriented-language

## Compiling and Running Are Separate Steps

Expand Down
6 changes: 3 additions & 3 deletions src/doc/book/src/glossary.md
Original file line number Diff line number Diff line change
Expand Up @@ -56,7 +56,7 @@ They can be used to manage control flow in a modular fashion.

A type without a statically known size or alignment. ([more info][link])

[link]: ../nomicon/exotic-sizes.html#Dynamically%20Sized%20Types%20(DSTs)
[link]: ../nomicon/exotic-sizes.html#dynamically-sized-types-dsts

### Expression

Expand All @@ -76,8 +76,8 @@ In an expression-oriented language, (nearly) every statement is an expression
and therefore returns a value. Consequently, these expression statements can
themselves form part of larger expressions.

[expression]: glossary.html#Expression
[statement]: glossary.html#Statement
[expression]: glossary.html#expression
[statement]: glossary.html#statement

### Statement

Expand Down
4 changes: 2 additions & 2 deletions src/doc/book/src/guessing-game.md
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,7 @@ there are no arguments, and `{` starts the body of the function. Because
we didn’t include a return type, it’s assumed to be `()`, an empty
[tuple][tuples].

[tuples]: primitive-types.html#Tuples
[tuples]: primitive-types.html#tuples

```rust,ignore
println!("Guess the number!");
Expand Down Expand Up @@ -727,7 +727,7 @@ thirty-two bit integer. Rust has [a number of built-in number types][number],
but we’ve chosen `u32`. It’s a good default choice for a small positive number.
[parse]: ../std/primitive.str.html#method.parse
[number]: primitive-types.html#Numeric%20types
[number]: primitive-types.html#numeric-types
Just like `read_line()`, our call to `parse()` could cause an error. What if
our string contained `A👍%`? There’d be no way to convert that to a number. As
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/lifetimes.md
Original file line number Diff line number Diff line change
Expand Up @@ -139,7 +139,7 @@ associated with it, but the compiler lets you elide (i.e. omit, see
["Lifetime Elision"][lifetime-elision] below) them in common cases. Before we
get to that, though, let’s look at a short example with explicit lifetimes:

[lifetime-elision]: #Lifetime%20Elision
[lifetime-elision]: #lifetime-elision

```rust,ignore
fn bar<'a>(...)
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/macros.md
Original file line number Diff line number Diff line change
Expand Up @@ -430,7 +430,7 @@ Even when Rust code contains un-expanded macros, it can be parsed as a full
tools that process code. It also has a few consequences for the design of
Rust’s macro system.

[ast]: glossary.html#Abstract%20Syntax%20Tree
[ast]: glossary.html#abstract-syntax-tree

One consequence is that Rust must determine, when it parses a macro invocation,
whether the macro stands in for
Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/mutability.md
Original file line number Diff line number Diff line change
Expand Up @@ -89,7 +89,7 @@ philosophy, memory safety, and the mechanism by which Rust guarantees it, the
> * exactly one mutable reference (`&mut T`).
[ownership]: ownership.html
[borrowing]: references-and-borrowing.html#Borrowing
[borrowing]: references-and-borrowing.html#borrowing

So, that’s the real definition of ‘immutability’: is this safe to have two
pointers to? In `Arc<T>`’s case, yes: the mutation is entirely contained inside
Expand Down
8 changes: 4 additions & 4 deletions src/doc/book/src/ownership.md
Original file line number Diff line number Diff line change
Expand Up @@ -65,10 +65,10 @@ elements onto them.
Vectors have a [generic type][generics] `Vec<T>`, so in this example `v` will have type
`Vec<i32>`. We'll cover [generics] in detail in a later chapter.

[arrays]: primitive-types.html#Arrays
[arrays]: primitive-types.html#arrays
[vectors]: vectors.html
[heap]: the-stack-and-the-heap.html#The%20Heap
[stack]: the-stack-and-the-heap.html#The%20Stack
[heap]: the-stack-and-the-heap.html#the-heap
[stack]: the-stack-and-the-heap.html#the-stack
[bindings]: variable-bindings.html
[generics]: generics.html

Expand Down Expand Up @@ -136,7 +136,7 @@ Rust allocates memory for an integer [i32] on the [stack][sh], copies the bit
pattern representing the value of 10 to the allocated memory and binds the
variable name x to this memory region for future reference.

[i32]: primitive-types.html#Numeric%20types
[i32]: primitive-types.html#numeric-types

Now consider the following code fragment:

Expand Down
2 changes: 1 addition & 1 deletion src/doc/book/src/primitive-types.md
Original file line number Diff line number Diff line change
Expand Up @@ -232,7 +232,7 @@ soon.
You can assign one tuple into another, if they have the same contained types
and [arity]. Tuples have the same arity when they have the same length.

[arity]: glossary.html#Arity
[arity]: glossary.html#arity

```rust
let mut x = (1, 2); // x: (i32, i32)
Expand Down
Loading

0 comments on commit 9a8dbbe

Please sign in to comment.