---

yaml
---
r: 212287
b: refs/heads/auto
c: 93d01eb
h: refs/heads/master
i:
  212285: b09ba2a
  212283: f2dacac
  212279: 6f33cb1
  212271: 311dc16
  212255: 9b90a9a
  212223: 987c9a9
v: v3

Author: fitzgen

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 8f9f2fe97e78bd7dbdfc477b765d5e6dc930b9eb
+refs/heads/auto: 93d01eb443d0f871716c9d7faa3b69dc49662663
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/liballoc/arc.rs

@@ -98,6 +98,7 @@ use heap::deallocate;
 /// increase the reference counter.
 ///
 /// ```
+/// # #![feature(alloc, core)]
 /// use std::sync::Arc;
 /// use std::thread;
 ///
@@ -296,6 +297,7 @@ impl<T: ?Sized> Clone for Arc<T> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
@@ -390,6 +392,7 @@ impl<T: ?Sized> Drop for Arc<T> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// {

branches/auto/src/libcollections/str.rs

@@ -640,19 +640,16 @@ impl str {
     ///
     /// let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
     /// assert_eq!(v, ["lion", "tiger", "leopard"]);
-    ///
-    /// let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
-    /// assert_eq!(v, ["abc", "def", "ghi"]);
-    ///
-    /// let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
-    /// assert_eq!(v, ["lion", "tiger", "leopard"]);
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
     /// ```
-    /// let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
+    /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect();
     /// assert_eq!(v, ["abc", "def", "ghi"]);
+    ///
+    /// let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
+    /// assert_eq!(v, ["lion", "tiger", "leopard"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> {
@@ -694,11 +691,14 @@ impl str {
     /// assert_eq!(v, ["leopard", "tiger", "lion"]);
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
-    /// ```
-    /// let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
+    /// ```rust
+    /// let v: Vec<&str> = "abc1def2ghi".rsplit(|c: char| c.is_numeric()).collect();
     /// assert_eq!(v, ["ghi", "def", "abc"]);
+    ///
+    /// let v: Vec<&str> = "lionXtigerXleopard".rsplit(char::is_uppercase).collect();
+    /// assert_eq!(v, ["leopard", "tiger", "lion"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn rsplit<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplit<'a, P>
@@ -733,13 +733,22 @@ impl str {
     ///
     /// # Examples
     ///
+    /// Simple patterns:
+    ///
     /// ```
     /// let v: Vec<&str> = "A.B.".split_terminator('.').collect();
     /// assert_eq!(v, ["A", "B"]);
     ///
     /// let v: Vec<&str> = "A..B..".split_terminator(".").collect();
     /// assert_eq!(v, ["A", "", "B", ""]);
     /// ```
+    ///
+    /// More complex patterns with closures:
+    ///
+    /// ```
+    /// let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect();
+    /// assert_eq!(v, ["abc", "def", "ghi"]);
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> {
         core_str::StrExt::split_terminator(&self[..], pat)
@@ -769,13 +778,22 @@ impl str {
     ///
     /// # Examples
     ///
+    /// Simple patterns:
+    ///
     /// ```
     /// let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
     /// assert_eq!(v, ["B", "A"]);
     ///
     /// let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
     /// assert_eq!(v, ["", "B", "", "A"]);
     /// ```
+    ///
+    /// More complex patterns with closures:
+    ///
+    /// ```
+    /// let v: Vec<&str> = "abc1def2ghi3".rsplit_terminator(|c: char| c.is_numeric()).collect();
+    /// assert_eq!(v, ["ghi", "def", "abc"]);
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn rsplit_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplitTerminator<'a, P>
         where P::Searcher: ReverseSearcher<'a>
@@ -819,11 +837,11 @@ impl str {
     /// assert_eq!(v, [""]);
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
     /// ```
-    /// let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
-    /// assert_eq!(v, ["abc", "defXghi"]);
+    /// let v: Vec<&str> = "abc1def2ghi".splitn(2, |c: char| c.is_numeric()).collect();
+    /// assert_eq!(v, ["abc", "def2ghi"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> {
@@ -864,10 +882,10 @@ impl str {
     /// assert_eq!(v, ["leopard", "lion::tiger"]);
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
     /// ```
-    /// let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
+    /// let v: Vec<&str> = "abc1def2ghi".rsplitn(2, |c: char| c.is_numeric()).collect();
     /// assert_eq!(v, ["ghi", "abc1def"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -902,7 +920,7 @@ impl str {
     /// let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
     /// assert_eq!(v, ["abc", "abc", "abc"]);
     ///
-    /// let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
+    /// let v: Vec<&str> = "1abc2abc3".matches(|c: char| c.is_numeric()).collect();
     /// assert_eq!(v, ["1", "2", "3"]);
     /// ```
     #[unstable(feature = "collections",
@@ -935,7 +953,7 @@ impl str {
     /// let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
     /// assert_eq!(v, ["abc", "abc", "abc"]);
     ///
-    /// let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
+    /// let v: Vec<&str> = "1abc2abc3".rmatches(|c: char| c.is_numeric()).collect();
     /// assert_eq!(v, ["3", "2", "1"]);
     /// ```
     #[unstable(feature = "collections",
@@ -1181,16 +1199,15 @@ impl str {
     ///
     /// ```
     /// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
-    /// assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");
     ///
     /// let x: &[_] = &['1', '2'];
     /// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
     /// ```
-    /// assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
+    /// assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
@@ -1207,13 +1224,20 @@ impl str {
     ///
     /// # Examples
     ///
+    /// Simple patterns:
+    ///
     /// ```
     /// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
-    /// assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");
     ///
     /// let x: &[_] = &['1', '2'];
     /// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
     /// ```
+    ///
+    /// More complex patterns with closures:
+    ///
+    /// ```
+    /// assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {
         core_str::StrExt::trim_left_matches(&self[..], pat)
@@ -1231,16 +1255,14 @@ impl str {
     ///
     /// ```
     /// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
-    /// assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");
-    ///
     /// let x: &[_] = &['1', '2'];
     /// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
     /// ```
     ///
-    /// A more complex pattern, using a closure:
+    /// More complex patterns with closures:
     ///
     /// ```
-    /// assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");
+    /// assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
@@ -1477,7 +1499,7 @@ impl str {
     /// ```
     /// let s = "Löwe 老虎 Léopard";
     ///
-    /// assert_eq!(s.find(char::is_whitespace), Some(5));
+    /// assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5));
     /// assert_eq!(s.find(char::is_lowercase), Some(1));
     /// ```
     ///
@@ -1519,7 +1541,7 @@ impl str {
     /// ```
     /// let s = "Löwe 老虎 Léopard";
     ///
-    /// assert_eq!(s.rfind(char::is_whitespace), Some(12));
+    /// assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12));
     /// assert_eq!(s.rfind(char::is_lowercase), Some(20));
     /// ```
     ///

branches/auto/src/libcollections/string.rs

@@ -88,7 +88,7 @@ impl String {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(collections)]
+    /// # #![feature(collections, core)]
     /// let s = String::from_str("hello");
     /// assert_eq!(&s[..], "hello");
     /// ```

branches/auto/src/libcollections/vec.rs

@@ -840,7 +840,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(collections)]
+    /// # #![feature(collections, core)]
     /// let v = vec![0, 1, 2];
     /// let w = v.map_in_place(|i| i + 3);
     /// assert_eq!(&w[..], &[3, 4, 5]);

branches/auto/src/libcore/intrinsics.rs

@@ -308,6 +308,7 @@ extern "rust-intrinsic" {
     /// A safe swap function:
     ///
     /// ```
+    /// # #![feature(core)]
     /// use std::mem;
     /// use std::ptr;
     ///
@@ -347,6 +348,7 @@ extern "rust-intrinsic" {
     /// Efficiently create a Rust vector from an unsafe buffer:
     ///
     /// ```
+    /// # #![feature(core)]
     /// use std::ptr;
     ///
     /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: usize) -> Vec<T> {

branches/auto/src/libcore/iter.rs

@@ -326,6 +326,7 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
     /// let xs = [100, 200, 300];
     /// let mut it = xs.iter().cloned().peekable();
     /// assert_eq!(*it.peek().unwrap(), 100);
@@ -513,13 +514,15 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
+    ///
     /// let a = [1, 4, 2, 3, 8, 9, 6];
     /// let sum: i32 = a.iter()
     ///                 .map(|x| *x)
     ///                 .inspect(|&x| println!("filtering {}", x))
     ///                 .filter(|&x| x % 2 == 0)
     ///                 .inspect(|&x| println!("{} made it through", x))
-    ///                 .fold(0, |sum, i| sum + i);
+    ///                 .sum();
     /// println!("{}", sum);
     /// ```
     #[inline]
@@ -569,6 +572,7 @@ pub trait Iterator {
     /// do not.
     ///
     /// ```
+    /// # #![feature(core)]
     /// let vec = vec![1, 2, 3, 4];
     /// let (even, odd): (Vec<_>, Vec<_>) = vec.into_iter().partition(|&n| n % 2 == 0);
     /// assert_eq!(even, [2, 4]);
@@ -893,6 +897,7 @@ pub trait Iterator {
     ///
     /// ```
     /// # #![feature(core)]
+    ///
     /// let a = [-3_i32, 0, 1, 5, -10];
     /// assert_eq!(*a.iter().max_by(|x| x.abs()).unwrap(), -10);
     /// ```
@@ -921,6 +926,7 @@ pub trait Iterator {
     ///
     /// ```
     /// # #![feature(core)]
+    ///
     /// let a = [-3_i32, 0, 1, 5, -10];
     /// assert_eq!(*a.iter().min_by(|x| x.abs()).unwrap(), 0);
     /// ```
@@ -965,6 +971,7 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
     /// let a = [(1, 2), (3, 4)];
     /// let (left, right): (Vec<_>, Vec<_>) = a.iter().cloned().unzip();
     /// assert_eq!(left, [1, 3]);
@@ -1058,6 +1065,7 @@ pub trait Iterator {
     ///
     /// ```
     /// # #![feature(core)]
+    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let it = a.iter();
     /// assert_eq!(it.sum::<i32>(), 15);
@@ -1076,6 +1084,7 @@ pub trait Iterator {
     ///
     /// ```
     /// # #![feature(core)]
+    ///
     /// fn factorial(n: u32) -> u32 {
     ///     (1..).take_while(|&i| i <= n).product()
     /// }
@@ -2721,7 +2730,7 @@ impl<A: Step> ops::Range<A> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(step_by)]
+    /// # #![feature(step_by, core)]
     /// for i in (0..10).step_by(2) {
     ///     println!("{}", i);
     /// }

branches/auto/src/libcore/macros.rs

@@ -173,11 +173,12 @@ macro_rules! try {
 /// # Examples
 ///
 /// ```
+/// # #![allow(unused_must_use)]
 /// use std::io::Write;
 ///
 /// let mut w = Vec::new();
-/// write!(&mut w, "test").unwrap();
-/// write!(&mut w, "formatted {}", "arguments").unwrap();
+/// write!(&mut w, "test");
+/// write!(&mut w, "formatted {}", "arguments");
 /// ```
 #[macro_export]
 macro_rules! write {