Rollup of 7 pull requests

src/bootstrap/flags.rs

@@ -136,9 +136,12 @@ To learn more about a subcommand, run `./x.py <subcommand> -h`");
         let subcommand = match subcommand {
             Some(s) => s,
             None => {
-                // No subcommand -- show the general usage and subcommand help
+                // No or an invalid subcommand -- show the general usage and subcommand help
+                // An exit code will be 0 when no subcommand is given, and 1 in case of an invalid
+                // subcommand.
                 println!("{}\n", subcommand_help);
-                process::exit(1);
+                let exit_code = if args.is_empty() { 0 } else { 1 };
+                process::exit(exit_code);
             }
         };
 

src/doc/unstable-book/src/language-features/on-unimplemented.md

@@ -15,8 +15,8 @@ For example:
 ```rust,compile_fail
 #![feature(on_unimplemented)]
 
-#[rustc_on_unimplemented="a collection of type `{Self}` cannot be built from an \
-                          iterator over elements of type `{A}`"]
+#[rustc_on_unimplemented="an iterator over elements of type `{A}` \
+    cannot be built from a collection of type `{Self}`"]
 trait MyIterator<A> {
     fn next(&mut self) -> A;
 }
@@ -37,9 +37,9 @@ error[E0277]: the trait bound `&[{integer}]: MyIterator<char>` is not satisfied
   --> <anon>:14:5
    |
 14 |     iterate_chars(&[1, 2, 3][..]);
-   |     ^^^^^^^^^^^^^ the trait `MyIterator<char>` is not implemented for `&[{integer}]`
+   |     ^^^^^^^^^^^^^ an iterator over elements of type `char` cannot be built from a collection of type `&[{integer}]`
    |
-   = note: a collection of type `&[{integer}]` cannot be built from an iterator over elements of type `char`
+   = help: the trait `MyIterator<char>` is not implemented for `&[{integer}]`
    = note: required by `iterate_chars`
 
 error: aborting due to previous error

src/librustc/diagnostics.rs

@@ -401,16 +401,6 @@ fn bar(x: &str, y: &str) -> &str { }
 fn baz<'a>(x: &'a str, y: &str) -> &str { }
 ```
 
-Here's an example that is currently an error, but may work in a future version
-of Rust:
-
-```compile_fail,E0106
-struct Foo<'a>(&'a str);
-
-trait Quux { }
-impl Quux for Foo { }
-```
-
 Lifetime elision in implementation headers was part of the lifetime elision
 RFC. It is, however, [currently unimplemented][iss15872].
 
@@ -1875,7 +1865,7 @@ fn main() {
 "##,
 
 E0601: r##"
-No `main` function was found in a binary crate. To fix this error, just add a
+No `main` function was found in a binary crate. To fix this error, add a
 `main` function. For example:
 
 ```

src/librustc/session/mod.rs

@@ -776,7 +776,12 @@ pub fn build_session_(sopts: config::Options,
     let print_fuel_crate = sopts.debugging_opts.print_fuel.clone();
     let print_fuel = Cell::new(0);
 
-    let working_dir = env::current_dir().unwrap().to_string_lossy().into_owned();
+    let working_dir = match env::current_dir() {
+        Ok(dir) => dir.to_string_lossy().into_owned(),
+        Err(e) => {
+            panic!(p_s.span_diagnostic.fatal(&format!("Current directory is invalid: {}", e)))
+        }
+    };
     let working_dir = file_path_mapping.map_prefix(working_dir);
 
     let sess = Session {

src/librustdoc/Cargo.toml

@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 env_logger = { version = "0.4", default-features = false }
 log = "0.3"
-pulldown-cmark = { version = "0.0.14", default-features = false }
+pulldown-cmark = { version = "0.1.0", default-features = false }
 html-diff = "0.0.4"
 
 [build-dependencies]

src/librustdoc/html/markdown.rs

@@ -371,7 +371,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for Footnotes<'a, I> {
             match self.inner.next() {
                 Some(Event::FootnoteReference(ref reference)) => {
                     let entry = self.get_entry(&reference);
-                    let reference = format!("<sup id=\"supref{0}\"><a href=\"#ref{0}\">{0}\
+                    let reference = format!("<sup id=\"fnref{0}\"><a href=\"#fn{0}\">{0}\
                                              </a></sup>",
                                             (*entry).1);
                     return Some(Event::Html(reference.into()));
@@ -394,15 +394,15 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for Footnotes<'a, I> {
                         v.sort_by(|a, b| a.1.cmp(&b.1));
                         let mut ret = String::from("<div class=\"footnotes\"><hr><ol>");
                         for (mut content, id) in v {
-                            write!(ret, "<li id=\"ref{}\">", id).unwrap();
+                            write!(ret, "<li id=\"fn{}\">", id).unwrap();
                             let mut is_paragraph = false;
                             if let Some(&Event::End(Tag::Paragraph)) = content.last() {
                                 content.pop();
                                 is_paragraph = true;
                             }
                             html::push_html(&mut ret, content.into_iter());
                             write!(ret,
-                                   "&nbsp;<a href=\"#supref{}\" rev=\"footnote\">↩</a>",
+                                   "&nbsp;<a href=\"#fnref{}\" rev=\"footnote\">↩</a>",
                                    id).unwrap();
                             if is_paragraph {
                                 ret.push_str("</p>");

src/libstd/net/udp.rs

@@ -721,16 +721,45 @@ impl UdpSocket {
 
     /// Moves this UDP socket into or out of nonblocking mode.
     ///
-    /// On Unix this corresponds to calling fcntl, and on Windows this
-    /// corresponds to calling ioctlsocket.
+    /// This will result in `recv`, `recv_from`, `send`, and `send_to`
+    /// operations becoming nonblocking, i.e. immediately returning from their
+    /// calls. If the IO operation is successful, `Ok` is returned and no
+    /// further action is required. If the IO operation could not be completed
+    /// and needs to be retried, an error with kind
+    /// [`io::ErrorKind::WouldBlock`] is returned.
+    ///
+    /// On Unix platforms, calling this method corresponds to calling `fcntl`
+    /// `FIONBIO`. On Windows calling this method corresponds to calling
+    /// `ioctlsocket` `FIONBIO`.
+    ///
+    /// [`io::ErrorKind::WouldBlock`]: ../io/enum.ErrorKind.html#variant.WouldBlock
     ///
     /// # Examples
     ///
+    /// Create a UDP socket bound to `127.0.0.1:7878` and read bytes in
+    /// nonblocking mode:
+    ///
     /// ```no_run
+    /// use std::io;
     /// use std::net::UdpSocket;
     ///
-    /// let socket = UdpSocket::bind("127.0.0.1:34254").expect("couldn't bind to address");
-    /// socket.set_nonblocking(true).expect("set_nonblocking call failed");
+    /// let socket = UdpSocket::bind("127.0.0.1:7878").unwrap();
+    /// socket.set_nonblocking(true).unwrap();
+    ///
+    /// # fn wait_for_fd() { unimplemented!() }
+    /// let mut buf = [0; 10];
+    /// let (num_bytes_read, _) = loop {
+    ///     match socket.recv_from(&mut buf) {
+    ///         Ok(n) => break n,
+    ///         Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+    ///             // wait until network socket is ready, typically implemented
+    ///             // via platform-specific APIs such as epoll or IOCP
+    ///             wait_for_fd();
+    ///         }
+    ///         Err(e) => panic!("encountered IO error: {}", e),
+    ///     }
+    /// };
+    /// println!("bytes: {:?}", &buf[..num_bytes_read]);
     /// ```
     #[stable(feature = "net2_mutators", since = "1.9.0")]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {