auto merge of #9475 : alexcrichton/rust/rustdoc++, r=cmr

The commit messages are a good technical summary, a good visual summary (contrib is this version):

Pub use statements now rendered. Notice how almost all components are also clickable!
* http://static.rust-lang.org/doc/master/std/prelude/index.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/std/prelude/index.html

Private things hidden by default (for at least some approximation of privacy). I hope to improve this once privacy is totally ironed out.
* http://static.rust-lang.org/doc/master/std/hashmap/struct.HashMap.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/std/hashmap/struct.HashMap.html

Unindentation now works properly:
* http://static.rust-lang.org/doc/master/extra/getopts/index.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/extra/getopts/index.html

Also sundown has massively reduced compilation time (of docs, not the of the crates)

4 files changed, 18 insertions, 18 deletions

diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs
index 7988f640687..3e801f28991 100644
--- a/src/libstd/rt/io/buffered.rs
+++ b/src/libstd/rt/io/buffered.rs
@@ -17,7 +17,7 @@
 //!
 //! # Examples
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let reader = BufferedReader::new(tcp_stream);
 //!
@@ -26,17 +26,17 @@
 //!     Some(nread) => println!("Read {} bytes", nread),
 //!     None => println!("At the end of the stream!")
 //! }
-//! ~~~
+//! ```
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let writer = BufferedWriter::new(tcp_stream);
 //!
 //! writer.write("hello, world".as_bytes());
 //! writer.flush();
-//! ~~~
+//! ```
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let stream = BufferedStream::new(tcp_stream);
 //!
@@ -48,7 +48,7 @@
 //!     Some(nread) => println!("Read {} bytes", nread),
 //!     None => println!("At the end of the stream!")
 //! }
-//! ~~~
+//! ```
 //!
 
 use prelude::*;
diff --git a/src/libstd/rt/io/file.rs b/src/libstd/rt/io/file.rs
index 2206f8bf6ae..b11ee014af9 100644
--- a/src/libstd/rt/io/file.rs
+++ b/src/libstd/rt/io/file.rs
@@ -477,7 +477,7 @@ pub trait FileSystemInfo {
 ///
 /// * Check if a file exists, reading from it if so
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std;
 /// use std::path::Path;
 /// use std::rt::io::file::{FileInfo, FileReader};
@@ -489,17 +489,17 @@ pub trait FileSystemInfo {
 ///     reader.read(mem);
 ///     // ...
 /// }
-/// ~~~
+/// ```
 ///
 /// * Is the given path a file?
 ///
-/// ~~~{.rust}
+/// ```rust
 /// let f = get_file_path_from_wherever();
 /// match f.is_file() {
 ///    true => doing_something_with_a_file(f),
 ///    _ => {}
 /// }
-/// ~~~
+/// ```
 pub trait FileInfo : FileSystemInfo {
     /// Whether the underlying implemention (be it a file path,
     /// or something else) points at a "regular file" on the FS. Will return
@@ -574,7 +574,7 @@ impl FileInfo for Path { }
 ///
 /// * Check if a directory exists, `mkdir`'ing it if not
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std;
 /// use std::path::Path;
 /// use std::rt::io::file::{DirectoryInfo};
@@ -583,11 +583,11 @@ impl FileInfo for Path { }
 /// if !dir.exists() {
 ///     dir.mkdir();
 /// }
-/// ~~~
+/// ```
 ///
 /// * Is the given path a directory? If so, iterate on its contents
 ///
-/// ~~~{.rust}
+/// ```rust
 /// fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
 ///     if dir.is_dir() {
 ///         let contents = dir.readdir();
@@ -598,7 +598,7 @@ impl FileInfo for Path { }
 ///     }
 ///     else { fail!("nope"); }
 /// }
-/// ~~~
+/// ```
 trait DirectoryInfo : FileSystemInfo {
     /// Whether the underlying implemention (be it a file path,
     /// or something else) is pointing at a directory in the underlying FS.
@@ -971,4 +971,4 @@ mod test {
             dir.rmdir();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/io/mock.rs b/src/libstd/rt/io/mock.rs
index b580b752bd9..c46e1372c64 100644
--- a/src/libstd/rt/io/mock.rs
+++ b/src/libstd/rt/io/mock.rs
@@ -47,4 +47,4 @@ impl MockWriter {
 impl Writer for MockWriter {
     fn write(&mut self, buf: &[u8]) { (self.write)(buf) }
     fn flush(&mut self) { (self.flush)() }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 92dc62490ed..6563ac2e96f 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -71,14 +71,14 @@ before reporting whether it succeeded or failed. A watching parent will only
 report success if it succeeded and all its children also reported success;
 otherwise, it will report failure. This is most useful for writing test cases:
 
-~~~
+ ```
 #[test]
 fn test_something_in_another_task {
     do spawn {
         assert!(collatz_conjecture_is_false());
     }
 }
-~~~
+ ```
 
 Here, as the child task will certainly outlive the parent task, we might miss
 the failure of the child when deciding whether or not the test case passed.