---

yaml
---
r: 212283
b: refs/heads/auto
c: b26a488
h: refs/heads/master
i:
  212281: ce6b1f0
  212279: 6f33cb1
v: v3

Author: brson

[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: 64d32b057edbf2e9223670c76df96f41e5bc1177
+refs/heads/auto: b26a48868c89f46260bea41e963d7e79482908a1
 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/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 {

branches/auto/src/libcore/option.rs

@@ -474,6 +474,7 @@ impl<T> Option<T> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
     /// let x = Some("foo");
     /// assert_eq!(x.ok_or(0), Ok("foo"));
     ///
@@ -495,6 +496,7 @@ impl<T> Option<T> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
     /// let x = Some("foo");
     /// assert_eq!(x.ok_or_else(|| 0), Ok("foo"));
     ///
@@ -536,6 +538,7 @@ impl<T> Option<T> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(core)]
     /// let mut x = Some(4);
     /// match x.iter_mut().next() {
     ///     Some(&mut ref mut v) => *v = 42,

branches/auto/src/test/debuginfo/gdb-pretty-struct-and-enums.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-test also broken on nightly linux distcheck. it's just broken!
 // ignore-windows failing on win32 bot
 // ignore-freebsd: output doesn't match
 // ignore-tidy-linelength