auto merge of #19785 : brson/rust/rollup, r=brson

Author: bors

configure

@@ -988,8 +988,7 @@ do
     make_dir $t/rt/jemalloc
     for i in                                          \
       isaac sync test \
-      arch/i386 arch/x86_64 arch/arm arch/mips  \
-      sundown/src sundown/html
+      arch/i386 arch/x86_64 arch/arm arch/mips
     do
       make_dir $t/rt/stage$s/$i
     done

mk/ctags.mk

@@ -16,7 +16,7 @@
 .PHONY: TAGS.emacs TAGS.vi
 
 # This is using a blacklist approach, probably more durable than a whitelist.
-# We exclude: external dependencies (llvm, rt/{msvc,sundown,vg}),
+# We exclude: external dependencies (llvm, rt/{msvc,vg}),
 # tests (compiletest, test) and a couple of other things (rt/arch, etc)
 CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,, \
 				$(patsubst ${CFG_SRC_DIR}src/compiletest,, \
@@ -25,7 +25,6 @@ CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/arch,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/msvc,, \
-				$(patsubst ${CFG_SRC_DIR}src/rt/sundown,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/vg,, \
 				$(wildcard ${CFG_SRC_DIR}src/*) $(wildcard ${CFG_SRC_DIR}src/rt/*) \
 				)))))))))

src/doc/complement-bugreport.md

@@ -37,7 +37,7 @@ It's also helpful to provide the exact version and host by copying the output of
 re-running the erroneous rustc command with the `--version=verbose` flag, which will
 produce something like this:
 
-```{ignore}
+```text
 rustc 0.12.0 (ba4081a5a 2014-10-07 13:44:41 -0700)
 binary: rustc
 commit-hash: ba4081a5a8573875fed17545846f6f6902c8ba8d
@@ -46,8 +46,13 @@ host: i686-apple-darwin
 release: 0.12.0
 ```
 
-Finally, if you can run the offending command under gdb, pasting a stack trace can be
-useful; to do so, you will need to set a breakpoint on `rust_panic`.
+Finally, if you can also provide a backtrace, that'd be great. You can get a
+backtrace by setting the `RUST_BACKTRACE` environment variable to `1`, like
+this: 
+
+```bash
+$ RUST_BACKTRACE=1 rustc ...
+```
 
 # I submitted a bug, but nobody has commented on it!
 

src/doc/guide-crates.md

@@ -452,7 +452,7 @@ fn main() {
 
 Rust will give us a compile-time error:
 
-```{notrust}
+```text
    Compiling phrases v0.0.1 (file:///home/you/projects/phrases)
 /home/you/projects/phrases/src/main.rs:4:5: 4:40 error: a value named `hello` has already been imported in this module
 /home/you/projects/phrases/src/main.rs:4 use phrases::japanese::greetings::hello;

src/doc/guide-error-handling.md

@@ -76,7 +76,7 @@ fn main() {
 
 This will give us an error:
 
-```{notrust}
+```text
 error: non-exhaustive patterns: `_` not covered [E0004]
 ```
 
@@ -189,7 +189,7 @@ panic!("boom");
 
 gives
 
-```{notrust}
+```text
 task '<main>' panicked at 'boom', hello.rs:2
 ```
 

src/doc/guide-ownership.md

@@ -130,7 +130,7 @@ fn add_one(mut num: Box<int>) {
 
 This does not compile, and gives us an error:
 
-```{notrust}
+```text
 error: use of moved value: `x`
    println!("{}", x);
                   ^
@@ -208,7 +208,7 @@ the function is over, and `num` goes out of scope, the borrow is over.
 Lending out a reference to a resource that someone else owns can be
 complicated, however. For example, imagine this set of operations:
 
-1. I aquire a handle to some kind of resource.
+1. I acquire a handle to some kind of resource.
 2. I lend you a reference to the resource.
 3. I decide I'm done with the resource, and deallocate it, while you still have
    your reference.
@@ -406,7 +406,7 @@ fn main() {
 We try to make four `Wheel`s, each with a `Car` that it's attached to. But the
 compiler knows that on the second iteration of the loop, there's a problem:
 
-```{notrust}
+```text
 error: use of moved value: `car`
     Wheel { size: 360, owner: car };
                               ^~~

src/doc/guide-pointers.md

@@ -84,7 +84,7 @@ println!("{}", x + z);
 
 This gives us an error:
 
-```{notrust}
+```text
 hello.rs:6:24: 6:25 error: mismatched types: expected `int` but found `&int` (expected int but found &-ptr)
 hello.rs:6     println!("{}", x + z);
                                   ^
@@ -132,7 +132,7 @@ Pointers are useful in languages that are pass-by-value, rather than
 pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
-```{ignore}
+```text
 func foo(x) {
     x = 5
 }
@@ -152,7 +152,7 @@ and therefore, can change its value. At the comment, `i` will be `5`.
 So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
-```{ignore}
+```text
 func foo(&int x) {
     *x = 5
 }
@@ -191,7 +191,7 @@ knows. This might be harmless, and it might be catastrophic.
 When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
-```{ignore}
+```text
 func make_pointer(): &int {
     x = 5;
 
@@ -213,7 +213,7 @@ As one last example of a big problem with pointers, **aliasing** can be an
 issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
-```{ignore}
+```text
 func mutate(&int i, int j) {
     *i = j;
 }
@@ -398,7 +398,7 @@ fn main() {
 
 It gives this error:
 
-```{notrust}
+```text
 test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
 test.rs:5         *x -= 1;
                   ^~
@@ -522,7 +522,7 @@ boxes, though. As a rough approximation, you can treat this Rust code:
 
 As being similar to this C code:
 
-```{ignore}
+```c
 {
     int *x;
     x = (int *)malloc(sizeof(int));
@@ -626,7 +626,7 @@ fn main() {
 
 This prints:
 
-```{ignore}
+```text
 Cons(1, box Cons(2, box Cons(3, box Nil)))
 ```