Auto merge of #39866 - steveklabnik:unstable-book, r=alexcrichton

Create the Unstable Book

Part of #39588

This isn't done yet. To do:

- [x] import the nightly book contents here
- [ ] possibly write some more chapters

This will _not_ be done before it lands; that's part of the whole unstable thing.

Author: bors

src/bootstrap/step.rs

@@ -577,6 +577,15 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
          })
          .default(build.config.docs)
          .run(move |s| doc::rustbook(build, s.target, "reference"));
+    rules.doc("doc-unstable-book", "src/doc/unstable-book")
+         .dep(move |s| {
+             s.name("tool-rustbook")
+              .host(&build.config.build)
+              .target(&build.config.build)
+              .stage(0)
+         })
+         .default(build.config.docs)
+         .run(move |s| doc::rustbook(build, s.target, "unstable-book"));
     rules.doc("doc-standalone", "src/doc")
          .dep(move |s| {
              s.name("rustc")

src/doc/book/src/README.md

@@ -21,15 +21,13 @@ is the first. After this:
 * [Tutorial: Guessing Game][gg] - Learn some Rust with a small project.
 * [Syntax and Semantics][ss] - Each bit of Rust, broken down into small chunks.
 * [Effective Rust][er] - Higher-level concepts for writing excellent Rust code.
-* [Nightly Rust][nr] - Cutting-edge features that aren’t in stable builds yet.
 * [Glossary][gl] - A reference of terms used in the book.
 * [Bibliography][bi] - Background on Rust's influences, papers about Rust.
 
 [gs]: getting-started.html
 [gg]: guessing-game.html
 [er]: effective-rust.html
 [ss]: syntax-and-semantics.html
-[nr]: nightly-rust.html
 [gl]: glossary.html
 [bi]: bibliography.html
 

src/doc/book/src/SUMMARY.md

@@ -55,18 +55,6 @@
     * [Release Channels](release-channels.md)
     * [Using Rust without the standard library](using-rust-without-the-standard-library.md)
     * [Procedural Macros (and custom derive)](procedural-macros.md)
-* [Nightly Rust](nightly-rust.md)
-    * [Compiler Plugins](compiler-plugins.md)
-    * [Inline Assembly](inline-assembly.md)
-    * [No stdlib](no-stdlib.md)
-    * [Intrinsics](intrinsics.md)
-    * [Lang items](lang-items.md)
-    * [Advanced linking](advanced-linking.md)
-    * [Benchmark Tests](benchmark-tests.md)
-    * [Box Syntax and Patterns](box-syntax-and-patterns.md)
-    * [Slice Patterns](slice-patterns.md)
-    * [Associated Constants](associated-constants.md)
-    * [Custom Allocators](custom-allocators.md)
 * [Glossary](glossary.md)
 * [Syntax Index](syntax-index.md)
 * [Bibliography](bibliography.md)

src/doc/book/src/advanced-linking.md

@@ -151,12 +151,9 @@ elements of the array. These kinds of casts are very dangerous, because they
 make assumptions about the way that multiple underlying structures are
 implemented. For this, we need something more dangerous.
 
-The `transmute` function is provided by a [compiler intrinsic][intrinsics], and
-what it does is very simple, but very scary. It tells Rust to treat a value of
-one type as though it were another type. It does this regardless of the
-typechecking system, and completely trusts you.
-
-[intrinsics]: intrinsics.html
+The `transmute` function is very simple, but very scary. It tells Rust to treat
+a value of one type as though it were another type. It does this regardless of
+the typechecking system, and completely trusts you.
 
 In our previous example, we know that an array of four `u8`s represents a `u32`
 properly, and so we want to do the cast. Using `transmute` instead of `as`,

src/doc/book/src/box-syntax-and-patterns.md

@@ -79,16 +79,13 @@ Will be the same as `#[b]` if `a` is set by `cfg` attribute, and nothing otherwi
 
 # cfg!
 
-The `cfg!` [syntax extension][compilerplugins] lets you use these kinds of flags
-elsewhere in your code, too:
+The `cfg!` macro lets you use these kinds of flags elsewhere in your code, too:
 
 ```rust
 if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
     println!("Think Different!");
 }
 ```
 
-[compilerplugins]: compiler-plugins.html
-
 These will be replaced by a `true` or `false` at compile-time, depending on the
 configuration settings.