Auto merge of #29883 - Manishearth:rollup, r=Manishearth

- Successful merges: #29868, #29873, #29874, #29875, #29876, #29880, #29881
- Failed merges:

11 files changed, 48 insertions, 24 deletions

diff --git a/mk/platform.mk b/mk/platform.mk
index 9d27f6b2a67..e6669f5c58d 100644
--- a/mk/platform.mk
+++ b/mk/platform.mk
@@ -14,7 +14,7 @@
 # would create a variable HOST_i686-darwin-macos with the value
 # i386.
 define DEF_HOST_VAR
-  HOST_$(1) = $(subst i686,i386,$(word 1,$(subst -, ,$(1))))
+  HOST_$(1) = $(patsubst i%86,i386,$(word 1,$(subst -, ,$(1))))
 endef
 $(foreach t,$(CFG_TARGET),$(eval $(call DEF_HOST_VAR,$(t))))
 $(foreach t,$(CFG_TARGET),$(info cfg: host for $(t) is $(HOST_$(t))))
diff --git a/src/doc/nomicon/unbounded-lifetimes.md b/src/doc/nomicon/unbounded-lifetimes.md
index 2c5ba79a507..1f2961b5861 100644
--- a/src/doc/nomicon/unbounded-lifetimes.md
+++ b/src/doc/nomicon/unbounded-lifetimes.md
@@ -32,6 +32,5 @@ Within a function, bounding lifetimes is more error-prone. The safest and easies
 way to bound a lifetime is to return it from a function with a bound lifetime.
 However if this is unacceptable, the reference can be placed in a location with
 a specific lifetime. Unfortunately it's impossible to name all lifetimes involved
-in a function. To get around this, you can in principle use `copy_lifetime`, though
-these are unstable due to their awkward nature and questionable utility.
+in a function.
 
diff --git a/src/doc/trpl/ownership.md b/src/doc/trpl/ownership.md
index d8ef44b782a..17b263ef00a 100644
--- a/src/doc/trpl/ownership.md
+++ b/src/doc/trpl/ownership.md
@@ -187,7 +187,7 @@ fn change_truth(x: bool) -> bool {
 }
 ```
 
-If we would have used types that do not implement the `Copy` trait,
+If we had used types that do not implement the `Copy` trait,
 we would have gotten a compile error because we tried to use a moved value.
 
 ```text
diff --git a/src/doc/trpl/ufcs.md b/src/doc/trpl/ufcs.md
index 2353c63a606..7725970564b 100644
--- a/src/doc/trpl/ufcs.md
+++ b/src/doc/trpl/ufcs.md
@@ -109,19 +109,28 @@ Here’s an example of using the longer form.
 
 ```rust
 trait Foo {
-    fn clone(&self);
+    fn foo() -> i32;
 }
 
-#[derive(Clone)]
 struct Bar;
 
-impl Foo for Bar {
-    fn clone(&self) {
-        println!("Making a clone of Bar");
+impl Bar {
+    fn foo() -> i32 {
+        20
+    }
+}
 
-        <Bar as Clone>::clone(self);
+impl Foo for Bar {
+    fn foo() -> i32 {
+        10
     }
 }
+
+fn main() {
+    assert_eq!(10, <Bar as Foo>::foo());
+    assert_eq!(20, Bar::foo());
+}
 ```
 
-This will call the `Clone` trait’s `clone()` method, rather than `Foo`’s.
+Using the angle bracket syntax lets you call the trait method instead of the
+inherent one.
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 979ddd45412..769faedf46e 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -24,6 +24,8 @@
 use marker::Sized;
 
 /// A common trait for cloning an object.
+///
+/// This trait can be used with `#[derive]`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Clone : Sized {
     /// Returns a copy of the value.
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 5458a7b9c38..3ac4ffb2236 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -43,6 +43,8 @@ use option::Option::{self, Some};
 /// in terms of it by default. Any manual implementation of `ne` *must* respect
 /// the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and
 /// only if `a != b`.
+///
+/// This trait can be used with `#[derive]`.
 #[lang = "eq"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PartialEq<Rhs: ?Sized = Self> {
@@ -69,6 +71,8 @@ pub trait PartialEq<Rhs: ?Sized = Self> {
 ///
 /// This property cannot be checked by the compiler, and therefore `Eq` implies
 /// `PartialEq`, and has no extra methods.
+///
+/// This trait can be used with `#[derive]`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Eq: PartialEq<Self> {
     // FIXME #13101: this method is used solely by #[deriving] to
@@ -171,6 +175,8 @@ impl Ordering {
 /// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
 ///
 /// When this trait is `derive`d, it produces a lexicographic ordering.
+///
+/// This trait can be used with `#[derive]`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Ord: Eq + PartialOrd<Self> {
     /// This method returns an `Ordering` between `self` and `other`.
@@ -227,6 +233,8 @@ impl PartialOrd for Ordering {
 /// However it remains possible to implement the others separately for types which do not have a
 /// total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 ==
 /// false` (cf. IEEE 754-2008 section 5.11).
+///
+/// This trait can be used with `#[derive]`.
 #[lang = "ord"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 8fe65e27c03..dfcc5781f08 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -300,6 +300,8 @@ impl<'a> Display for Arguments<'a> {
 ///
 /// [module]: ../../std/fmt/index.html
 ///
+/// This trait can be used with `#[derive]`.
+///
 /// # Examples
 ///
 /// Deriving an implementation:
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index 0899dc28848..ea3a2f78d56 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -93,6 +93,8 @@ mod sip;
 ///
 /// In other words, if two keys are equal, their hashes should also be equal.
 /// `HashMap` and `HashSet` both rely on this behavior.
+///
+/// This trait can be used with `#[derive]`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Hash {
     /// Feeds this value into the state given, updating the hasher as necessary.
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 6e6ae618527..84a6196cc87 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -165,6 +165,10 @@ pub trait Unsize<T: ?Sized> {
 /// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
 /// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
 /// change: that second example would fail to compile if we made `Foo` non-`Copy`.
+///
+/// # Derivable
+///
+/// This trait can be used with `#[derive]`.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "copy"]
 pub trait Copy : Clone {
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index 5bc5567df2f..dabc8090270 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -167,22 +167,20 @@ impl StdError for JoinPathsError {
 #[cfg(target_os = "freebsd")]
 pub fn current_exe() -> io::Result<PathBuf> {
     unsafe {
-        use libc::funcs::bsd44::*;
-        use libc::consts::os::extra::*;
-        let mut mib = [CTL_KERN as c_int,
-                       KERN_PROC as c_int,
-                       KERN_PROC_PATHNAME as c_int,
+        let mut mib = [libc::CTL_KERN as c_int,
+                       libc::KERN_PROC as c_int,
+                       libc::KERN_PROC_PATHNAME as c_int,
                        -1 as c_int];
         let mut sz: libc::size_t = 0;
-        let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
-                         ptr::null_mut(), &mut sz, ptr::null_mut(),
-                         0 as libc::size_t);
+        let err = libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
+                               ptr::null_mut(), &mut sz, ptr::null_mut(),
+                               0 as libc::size_t);
         if err != 0 { return Err(io::Error::last_os_error()); }
         if sz == 0 { return Err(io::Error::last_os_error()); }
         let mut v: Vec<u8> = Vec::with_capacity(sz as usize);
-        let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
-                         v.as_mut_ptr() as *mut libc::c_void, &mut sz,
-                         ptr::null_mut(), 0 as libc::size_t);
+        let err = libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
+                               v.as_mut_ptr() as *mut libc::c_void, &mut sz,
+                               ptr::null_mut(), 0 as libc::size_t);
         if err != 0 { return Err(io::Error::last_os_error()); }
         if sz == 0 { return Err(io::Error::last_os_error()); }
         v.set_len(sz as usize - 1); // chop off trailing NUL
diff --git a/src/test/run-pass/mir_raw_fat_ptr.rs b/src/test/run-pass/mir_raw_fat_ptr.rs
index 20c3357d7d2..9bbfbb68224 100644
--- a/src/test/run-pass/mir_raw_fat_ptr.rs
+++ b/src/test/run-pass/mir_raw_fat_ptr.rs
@@ -76,7 +76,7 @@ fn compare_au8(a: *const [u8], b: *const [u8]) -> ComparisonResults {
     }
 }
 
-#[rustc_mir(graphviz="comparefoo.gv")]
+#[rustc_mir]
 fn compare_foo<'a>(a: *const (Foo+'a), b: *const (Foo+'a)) -> ComparisonResults {
     ComparisonResults {
         lt: a < b,
@@ -88,7 +88,7 @@ fn compare_foo<'a>(a: *const (Foo+'a), b: *const (Foo+'a)) -> ComparisonResults
     }
 }
 
-#[rustc_mir(graphviz="simpleeq.gv")]
+#[rustc_mir]
 fn simple_eq<'a>(a: *const (Foo+'a), b: *const (Foo+'a)) -> bool {
     let result = a == b;
     result