---

yaml
---
r: 274749
b: refs/heads/stable
c: 456cedc
h: refs/heads/master
i:
  274747: 60a97fc

Author: dirk

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: b9732ed1471689976fc32fa6757fd29c5a587f5d
+refs/heads/stable: 456cedcf2337dc0aca1623c9b0ab1391880b527d
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/mk/crates.mk

@@ -106,7 +106,7 @@ DEPS_rustc_passes := syntax rustc core rustc_front
 DEPS_rustc_mir := rustc rustc_front syntax
 DEPS_rustc_resolve := arena rustc rustc_front log syntax
 DEPS_rustc_platform_intrinsics := rustc rustc_llvm
-DEPS_rustc_plugin := rustc rustc_metadata syntax rustc_mir
+DEPS_rustc_plugin := rustc rustc_metadata syntax
 DEPS_rustc_privacy := rustc rustc_front log syntax
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \
                     log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics

branches/stable/src/doc/book/error-handling.md

@@ -265,7 +265,7 @@ fn map<F, T, A>(option: Option<T>, f: F) -> Option<A> where F: FnOnce(T) -> A {
 ```
 
 Indeed, `map` is [defined as a method][2] on `Option<T>` in the standard library.
-As a method, it has a slightly different signature: methods take `self`, `&self`,
+As a method, it has a slighly different signature: methods take `self`, `&self`,
 or `&mut self` as their first argument.
 
 Armed with our new combinator, we can rewrite our `extension_explicit` method
@@ -1592,7 +1592,7 @@ fn print_usage(program: &str, opts: Options) {
 
 fn main() {
     let args: Vec<String> = env::args().collect();
-    let program = &args[0];
+    let program = args[0].clone();
 
     let mut opts = Options::new();
     opts.optflag("h", "help", "Show this usage message.");
@@ -1605,10 +1605,10 @@ fn main() {
         print_usage(&program, opts);
         return;
     }
-    let data_path = &args[1];
-    let city = &args[2];
+    let data_path = args[1].clone();
+    let city = args[2].clone();
 
-    // Do stuff with information
+	// Do stuff with information
 }
 ```
 
@@ -1640,6 +1640,7 @@ sure to add `extern crate csv;` to the top of your file.)
 
 ```rust,ignore
 use std::fs::File;
+use std::path::Path;
 
 // This struct represents the data in each row of the CSV file.
 // Type based decoding absolves us of a lot of the nitty gritty error
@@ -1665,7 +1666,7 @@ fn print_usage(program: &str, opts: Options) {
 
 fn main() {
     let args: Vec<String> = env::args().collect();
-    let program = &args[0];
+    let program = args[0].clone();
 
     let mut opts = Options::new();
     opts.optflag("h", "help", "Show this usage message.");
@@ -1677,24 +1678,25 @@ fn main() {
 
     if matches.opt_present("h") {
         print_usage(&program, opts);
-        return;
-    }
+		return;
+	}
 
-    let data_path = &args[1];
-    let city: &str = &args[2];
+	let data_file = args[1].clone();
+	let data_path = Path::new(&data_file);
+	let city = args[2].clone();
 
-    let file = File::open(data_path).unwrap();
-    let mut rdr = csv::Reader::from_reader(file);
+	let file = File::open(data_path).unwrap();
+	let mut rdr = csv::Reader::from_reader(file);
 
-    for row in rdr.decode::<Row>() {
-        let row = row.unwrap();
+	for row in rdr.decode::<Row>() {
+		let row = row.unwrap();
 
-        if row.city == city {
-            println!("{}, {}: {:?}",
-                row.city, row.country,
-                row.population.expect("population count"));
-        }
-    }
+		if row.city == city {
+			println!("{}, {}: {:?}",
+				row.city, row.country,
+				row.population.expect("population count"));
+		}
+	}
 }
 ```
 
@@ -1743,8 +1745,6 @@ Note that we opt to handle the possibility of a missing population count by
 simply ignoring that row.
 
 ```rust,ignore
-use std::path::Path;
-
 struct Row {
     // unchanged
 }
@@ -1782,26 +1782,27 @@ fn search<P: AsRef<Path>>(file_path: P, city: &str) -> Vec<PopulationCount> {
 }
 
 fn main() {
-    let args: Vec<String> = env::args().collect();
-    let program = &args[0];
+	let args: Vec<String> = env::args().collect();
+	let program = args[0].clone();
 
-    let mut opts = Options::new();
-    opts.optflag("h", "help", "Show this usage message.");
+	let mut opts = Options::new();
+	opts.optflag("h", "help", "Show this usage message.");
 
-    let matches = match opts.parse(&args[1..]) {
-        Ok(m)  => { m }
-        Err(e) => { panic!(e.to_string()) }
-    };
-    if matches.opt_present("h") {
-        print_usage(&program, opts);
-        return;
-    }
+	let matches = match opts.parse(&args[1..]) {
+		Ok(m)  => { m }
+		Err(e) => { panic!(e.to_string()) }
+	};
+	if matches.opt_present("h") {
+		print_usage(&program, opts);
+		return;
+	}
 
-    let data_path = &args[1];
-    let city = &args[2];
-    for pop in search(data_path, city) {
-        println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
-    }
+	let data_file = args[1].clone();
+	let data_path = Path::new(&data_file);
+	let city = args[2].clone();
+	for pop in search(&data_path, &city) {
+		println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
+	}
 }
 
 ```
@@ -1911,7 +1912,7 @@ First, here's the new usage:
 
 ```rust,ignore
 fn print_usage(program: &str, opts: Options) {
-    println!("{}", opts.usage(&format!("Usage: {} [options] <city>", program)));
+	println!("{}", opts.usage(&format!("Usage: {} [options] <city>", program)));
 }
 ```
 The next part is going to be only a little harder:
@@ -1923,16 +1924,16 @@ opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME"
 opts.optflag("h", "help", "Show this usage message.");
 ...
 let file = matches.opt_str("f");
-let data_file = &file.as_ref().map(Path::new);
+let data_file = file.as_ref().map(Path::new);
 
 let city = if !matches.free.is_empty() {
-    &matches.free[0]
+	matches.free[0].clone()
 } else {
-    print_usage(&program, opts);
-    return;
+	print_usage(&program, opts);
+	return;
 };
 
-match search(data_file, city) {
+match search(&data_file, &city) {
     Ok(pops) => {
         for pop in pops {
             println!("{}, {}: {:?}", pop.city, pop.country, pop.count);

branches/stable/src/liballoc/arc.rs

@@ -879,7 +879,7 @@ impl<T: ?Sized + fmt::Debug> fmt::Debug for Arc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> fmt::Pointer for Arc<T> {
+impl<T> fmt::Pointer for Arc<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&*self._ptr, f)
     }

branches/stable/src/liballoc/boxed.rs

@@ -442,7 +442,7 @@ impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> fmt::Pointer for Box<T> {
+impl<T> fmt::Pointer for Box<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // It's not possible to extract the inner Uniq directly from the Box,
         // instead we cast it to a *const which aliases the Unique

branches/stable/src/liballoc/rc.rs

@@ -688,7 +688,7 @@ impl<T: ?Sized + fmt::Debug> fmt::Debug for Rc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> fmt::Pointer for Rc<T> {
+impl<T> fmt::Pointer for Rc<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&*self._ptr, f)
     }

branches/stable/src/libbacktrace/ansidecl.h

@@ -1,4 +1,4 @@
-/* ANSI and traditional C compatibility macros
+/* ANSI and traditional C compatability macros
    Copyright (C) 1991-2015 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 

branches/stable/src/libcollections/btree/node.rs

@@ -28,7 +28,7 @@
 // }
 // ```
 //
-// Since Rust doesn't actually have dependent types and polymorphic recursion,
+// Since Rust doesn't acutally have dependent types and polymorphic recursion,
 // we make do with lots of unsafety.
 
 use alloc::heap;

branches/stable/src/libcollections/lib.rs

@@ -26,6 +26,7 @@
        issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
        test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
 
+#![allow(trivial_casts)]
 #![cfg_attr(test, allow(deprecated))] // rand
 #![cfg_attr(not(stage0), deny(warnings))]
 

branches/stable/src/libcollections/str.rs

@@ -1808,7 +1808,7 @@ impl str {
                 // Σ maps to σ, except at the end of a word where it maps to ς.
                 // This is the only conditional (contextual) but language-independent mapping
                 // in `SpecialCasing.txt`,
-                // so hard-code it rather than have a generic "condition" mechanism.
+                // so hard-code it rather than have a generic "condition" mechanim.
                 // See https://github.com/rust-lang/rust/issues/26035
                 map_uppercase_sigma(self, i, &mut s)
             } else {

branches/stable/src/libcollections/string.rs

@@ -193,7 +193,7 @@ use boxed::Box;
 /// mem::forget(story);
 ///
 /// // We can re-build a String out of ptr, len, and capacity. This is all
-/// // unsafe because we are responsible for making sure the components are
+/// // unsafe becuase we are responsible for making sure the components are
 /// // valid:
 /// let s = unsafe { String::from_raw_parts(ptr as *mut _, len, capacity) } ;
 ///
@@ -479,15 +479,16 @@ impl String {
         }
     }
 
-    /// Converts a slice of bytes to a string, including invalid characters.
+    /// Converts a slice of bytes to a `String`, including invalid characters.
     ///
-    /// Strings are made of bytes ([`u8`]), and a slice of bytes
-    /// ([`&[u8]`][byteslice]) is made of bytes, so this function converts
-    /// between the two. Not all byte slices are valid strings, however: strings
-    /// are required to be valid UTF-8. During this conversion,
+    /// A string slice ([`&str`]) is made of bytes ([`u8`]), and a slice of
+    /// bytes ([`&[u8]`][byteslice]) is made of bytes, so this function converts between
+    /// the two. Not all byte slices are valid string slices, however: [`&str`]
+    /// requires that it is valid UTF-8. During this conversion,
     /// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with
     /// `U+FFFD REPLACEMENT CHARACTER`, which looks like this: �
     ///
+    /// [`&str`]: ../primitive.str.html
     /// [`u8`]: ../primitive.u8.html
     /// [byteslice]: ../primitive.slice.html
     ///
@@ -498,13 +499,10 @@ impl String {
     ///
     /// [`from_utf8_unchecked()`]: struct.String.html#method.from_utf8_unchecked
     ///
-    /// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid
-    /// UTF-8, then we need to insert the replacement characters, which will
-    /// change the size of the string, and hence, require a `String`. But if
-    /// it's already valid UTF-8, we don't need a new allocation. This return
-    /// type allows us to handle both cases.
+    /// If you need a [`&str`] instead of a `String`, consider
+    /// [`str::from_utf8()`].
     ///
-    /// [`Cow<'a, str>`]: ../borrow/enum.Cow.html
+    /// [`str::from_utf8()`]: ../str/fn.from_utf8.html
     ///
     /// # Examples
     ///
@@ -514,7 +512,8 @@ impl String {
     /// // some bytes, in a vector
     /// let sparkle_heart = vec![240, 159, 146, 150];
     ///
-    /// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);
+    /// // We know these bytes are valid, so we'll use `unwrap()`.
+    /// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
     ///
     /// assert_eq!("💖", sparkle_heart);
     /// ```
@@ -1842,12 +1841,6 @@ impl fmt::Write for String {
 }
 
 /// A draining iterator for `String`.
-///
-/// This struct is created by the [`drain()`] method on [`String`]. See its
-/// documentation for more.
-///
-/// [`drain()`]: struct.String.html#method.drain
-/// [`String`]: struct.String.html
 #[stable(feature = "drain", since = "1.6.0")]
 pub struct Drain<'a> {
     /// Will be used as &'a mut String in the destructor

branches/stable/src/libcollections/vec_deque.rs

@@ -1968,39 +1968,7 @@ impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A: PartialEq> PartialEq for VecDeque<A> {
     fn eq(&self, other: &VecDeque<A>) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let (sa, sb) = self.as_slices();
-        let (oa, ob) = other.as_slices();
-        if sa.len() == oa.len() {
-            sa == oa && sb == ob
-        } else if sa.len() < oa.len() {
-            // Always divisible in three sections, for example:
-            // self:  [a b c|d e f]
-            // other: [0 1 2 3|4 5]
-            // front = 3, mid = 1,
-            // [a b c] == [0 1 2] && [d] == [3] && [e f] == [4 5]
-            let front = sa.len();
-            let mid = oa.len() - front;
-
-            let (oa_front, oa_mid) = oa.split_at(front);
-            let (sb_mid, sb_back) = sb.split_at(mid);
-            debug_assert_eq!(sa.len(), oa_front.len());
-            debug_assert_eq!(sb_mid.len(), oa_mid.len());
-            debug_assert_eq!(sb_back.len(), ob.len());
-            sa == oa_front && sb_mid == oa_mid && sb_back == ob
-        } else {
-            let front = oa.len();
-            let mid = sa.len() - front;
-
-            let (sa_front, sa_mid) = sa.split_at(front);
-            let (ob_mid, ob_back) = ob.split_at(mid);
-            debug_assert_eq!(sa_front.len(), oa.len());
-            debug_assert_eq!(sa_mid.len(), ob_mid.len());
-            debug_assert_eq!(sb.len(), ob_back.len());
-            sa_front == oa && sa_mid == ob_mid && sb == ob_back
-        }
+        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a.eq(b))
     }
 }
 

branches/stable/src/libcollectionstest/vec_deque.rs

@@ -624,33 +624,6 @@ fn test_hash_after_rotation() {
     }
 }
 
-#[test]
-fn test_eq_after_rotation() {
-    // test that two deques are equal even if elements are laid out differently
-    let len = 28;
-    let mut ring: VecDeque<i32> = (0..len as i32).collect();
-    let mut shifted = ring.clone();
-    for _ in 0..10 {
-        // shift values 1 step to the right by pop, sub one, push
-        ring.pop_front();
-        for elt in &mut ring {
-            *elt -= 1;
-        }
-        ring.push_back(len - 1);
-    }
-
-    // try every shift
-    for _ in 0..shifted.capacity() {
-        shifted.pop_front();
-        for elt in &mut shifted {
-            *elt -= 1;
-        }
-        shifted.push_back(len - 1);
-        assert_eq!(shifted, ring);
-        assert_eq!(ring, shifted);
-    }
-}
-
 #[test]
 fn test_ord() {
     let x = VecDeque::new();