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

- Successful merges: #24072, #24233, #24321, #24339, #24341, #24342, #24347
- Failed merges:

Author: bors

src/doc/trpl/traits.md

@@ -273,8 +273,8 @@ not, because both the trait and the type aren't in our crate.
 
 One last thing about traits: generic functions with a trait bound use
 *monomorphization* (*mono*: one, *morph*: form), so they are statically
-dispatched. What's that mean? Check out the chapter on [static and dynamic
-dispatch](static-and-dynamic-dispatch.html) for more.
+dispatched. What's that mean? Check out the chapter on [trait
+objects](trait-objects.html) for more.
 
 ## Multiple trait bounds
 

src/libcore/iter.rs

@@ -2197,13 +2197,9 @@ impl<I> Iterator for Fuse<I> where I: Iterator {
         if self.done {
             None
         } else {
-            match self.iter.next() {
-                None => {
-                    self.done = true;
-                    None
-                }
-                x => x
-            }
+            let next = self.iter.next();
+            self.done = next.is_none();
+            next
         }
     }
 
@@ -2224,13 +2220,9 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
         if self.done {
             None
         } else {
-            match self.iter.next_back() {
-                None => {
-                    self.done = true;
-                    None
-                }
-                x => x
-            }
+            let next = self.iter.next_back();
+            self.done = next.is_none();
+            next
         }
     }
 }

src/libcore/num/mod.rs

@@ -2705,7 +2705,7 @@ macro_rules! from_str_radix_float_impl {
             ///
             /// # Return value
             ///
-            /// `Err(ParseIntError)` if the string did not represent a valid number.  Otherwise,
+            /// `Err(ParseFloatError)` if the string did not represent a valid number.
             /// Otherwise, `Ok(n)` where `n` is the floating-point number represented by `src`.
             #[inline]
             #[allow(deprecated)]
@@ -2734,7 +2734,7 @@ macro_rules! from_str_radix_float_impl {
             ///
             /// # Return value
             ///
-            /// `Err(ParseIntError)` if the string did not represent a valid number.  Otherwise,
+            /// `Err(ParseFloatError)` if the string did not represent a valid number.
             /// Otherwise, `Ok(n)` where `n` is the floating-point number represented by `src`.
             fn from_str_radix(src: &str, radix: u32)
                               -> Result<$T, ParseFloatError> {

src/librustc/middle/infer/error_reporting.rs

@@ -373,8 +373,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
     fn report_and_explain_type_error(&self,
                                      trace: TypeTrace<'tcx>,
                                      terr: &ty::type_err<'tcx>) {
+        let span = trace.origin.span();
         self.report_type_error(trace, terr);
-        ty::note_and_explain_type_err(self.tcx, terr);
+        ty::note_and_explain_type_err(self.tcx, terr, span);
     }
 
     /// Returns a string of the form "expected `{}`, found `{}`", or None if this is a derived
@@ -812,7 +813,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         }
         self.give_suggestion(same_regions);
         for &(ref trace, terr) in trace_origins {
-            self.report_type_error(trace.clone(), &terr);
+            self.report_and_explain_type_error(trace.clone(), &terr);
         }
     }
 

src/librustc/middle/infer/mod.rs

@@ -987,7 +987,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     error_str));
 
                 if let Some(err) = err {
-                    ty::note_and_explain_type_err(self.tcx, err)
+                    ty::note_and_explain_type_err(self.tcx, err, sp)
                 }
             }
         }

src/librustc/middle/ty.rs

@@ -5103,7 +5103,7 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
     }
 }
 
-pub fn note_and_explain_type_err(cx: &ctxt, err: &type_err) {
+pub fn note_and_explain_type_err<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>, sp: Span) {
     match *err {
         terr_regions_does_not_outlive(subregion, superregion) => {
             note_and_explain_region(cx, "", subregion, "...");
@@ -5134,6 +5134,16 @@ pub fn note_and_explain_type_err(cx: &ctxt, err: &type_err) {
                                     "expected concrete lifetime is ",
                                     conc_region, "");
         }
+        terr_sorts(values) => {
+            let expected_str = ty_sort_string(cx, values.expected);
+            let found_str = ty_sort_string(cx, values.found);
+            if expected_str == found_str && expected_str == "closure" {
+                cx.sess.span_note(sp, &format!("no two closures, even if identical, have the same \
+                                                type"));
+                cx.sess.span_help(sp, &format!("consider boxing your closure and/or \
+                                        using it as a trait object"));
+            }
+        }
         _ => {}
     }
 }

src/librustc/session/mod.rs

@@ -163,7 +163,7 @@ impl Session {
         self.diagnostic().handler().note(msg)
     }
     pub fn help(&self, msg: &str) {
-        self.diagnostic().handler().note(msg)
+        self.diagnostic().handler().help(msg)
     }
     pub fn opt_span_bug(&self, opt_sp: Option<Span>, msg: &str) -> ! {
         match opt_sp {

src/librustc_typeck/check/mod.rs

@@ -3575,7 +3575,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                             .ty_to_string(
                                                 actual_structure_type),
                                          type_error_description);
-                    ty::note_and_explain_type_err(tcx, &type_error);
+                    ty::note_and_explain_type_err(tcx, &type_error, path.span);
                 }
             }
         }

src/librustc_typeck/lib.rs

@@ -200,7 +200,7 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>,
                                       msg(),
                                       ty::type_err_to_str(tcx,
                                                           terr));
-            ty::note_and_explain_type_err(tcx, terr);
+            ty::note_and_explain_type_err(tcx, terr, span);
             false
         }
     }

src/libstd/path.rs

@@ -1574,7 +1574,8 @@ impl Path {
     ///
     /// let path = Path::new("/tmp/foo.rs");
     ///
-    /// let new_path = path.with_extension("foo.txt");
+    /// let new_path = path.with_extension("txt");
+    /// assert_eq!(new_path, Path::new("/tmp/foo.txt"));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {

src/test/compile-fail/issue-24036.rs

@@ -0,0 +1,30 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn closure_to_loc() {
+    let mut x = |c| c + 1;
+    x = |c| c + 1;
+    //~^ ERROR mismatched types
+    //~| NOTE no two closures, even if identical, have the same type
+    //~| HELP consider boxing your closure and/or using it as a trait object
+}
+
+fn closure_from_match() {
+    let x = match 1usize {
+        1 => |c| c + 1,
+        2 => |c| c - 1,
+        _ => |c| c - 1
+    };
+    //~^^^^^ ERROR match arms have incompatible types
+    //~| NOTE no two closures, even if identical, have the same type
+    //~| HELP consider boxing your closure and/or using it as a trait object
+}
+
+fn main() { }

src/test/run-pass/issue-16602-1.rs

@@ -0,0 +1,15 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let mut t = [1; 2];
+    t = [t[1] * 2, t[0] * 2];
+    assert_eq!(&t[..], &[2, 2]);
+}

src/test/run-pass/issue-16602-2.rs

@@ -0,0 +1,21 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A {
+    pub x: u32,
+    pub y: u32,
+}
+
+fn main() {
+    let mut a = A { x: 1, y: 1 };
+    a = A { x: a.y * 2, y: a.x * 2 };
+    assert_eq!(a.x, 2);
+    assert_eq!(a.y, 2);
+}

src/test/run-pass/issue-16602-3.rs

@@ -0,0 +1,34 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[derive(Debug)]
+enum Foo {
+    Bar(u32, u32),
+    Baz(&'static u32, &'static u32)
+}
+
+static NUM: u32 = 100;
+
+fn main () {
+    let mut b = Foo::Baz(&NUM, &NUM);
+    b = Foo::Bar(f(&b), g(&b));
+}
+
+static FNUM: u32 = 1;
+
+fn f (b: &Foo) -> u32 {
+    FNUM
+}
+
+static GNUM: u32 = 2;
+
+fn g (b: &Foo) -> u32 {
+    GNUM
+}