---

yaml
---
r: 277993
b: refs/heads/auto
c: 12c4a19
h: refs/heads/master
i:
  277991: f3605d3

Author: oli-obk

[refs]

@@ -8,7 +8,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: 2e4474f890bd2a55f3efcfe17e411b902fbfb383
+refs/heads/auto: 12c4a1951e85925dbccc40efb163f4f179c30046
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/src/doc/book/getting-started.md

@@ -8,7 +8,7 @@ we’ll talk about Cargo, Rust’s build system and package manager.
 
 The first step to using Rust is to install it. Generally speaking, you’ll need
 an Internet connection to run the commands in this section, as we’ll be
-downloading Rust from the Internet.
+downloading Rust from the internet.
 
 We’ll be showing off a number of commands using a terminal, and those lines all
 start with `$`. We don't need to type in the `$`s, they are there to indicate
@@ -399,13 +399,13 @@ Let’s convert the Hello World program to Cargo. To Cargo-fy a project, you nee
 to do three things:
 
 1. Put your source file in the right directory.
-2. Get rid of the old executable (`main.exe` on Windows, `main` everywhere
-   else).
+2. Get rid of the old executable (`main.exe` on Windows, `main` everywhere else)
+   and make a new one.
 3. Make a Cargo configuration file.
 
 Let's get started!
 
-### Creating a Source Directory and Removing the Old Executable
+### Creating a new Executable and Source Directory
 
 First, go back to your terminal, move to your *hello_world* directory, and
 enter the following commands:

branches/auto/src/liballoc_jemalloc/lib.rs

@@ -41,28 +41,28 @@ use libc::{c_int, c_void, size_t};
 #[cfg(not(cargobuild))]
 extern {}
 
-// Note that the symbols here are prefixed by default on OSX and Windows (we
-// don't explicitly request it), and on Android and DragonFly we explicitly
-// request it as unprefixing cause segfaults (mismatches in allocators).
+// Note that the symbols here are prefixed by default on OSX (we don't
+// explicitly request it), and on Android and DragonFly we explicitly request
+// it as unprefixing cause segfaults (mismatches in allocators).
 extern {
     #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
-                   target_os = "dragonfly", target_os = "windows"),
+                   target_os = "dragonfly"),
                link_name = "je_mallocx")]
     fn mallocx(size: size_t, flags: c_int) -> *mut c_void;
     #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
-                   target_os = "dragonfly", target_os = "windows"),
+                   target_os = "dragonfly"),
                link_name = "je_rallocx")]
     fn rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
     #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
-                   target_os = "dragonfly", target_os = "windows"),
+                   target_os = "dragonfly"),
                link_name = "je_xallocx")]
     fn xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;
     #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
-                   target_os = "dragonfly", target_os = "windows"),
+                   target_os = "dragonfly"),
                link_name = "je_sdallocx")]
     fn sdallocx(ptr: *mut c_void, size: size_t, flags: c_int);
     #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
-                   target_os = "dragonfly", target_os = "windows"),
+                   target_os = "dragonfly"),
                link_name = "je_nallocx")]
     fn nallocx(size: size_t, flags: c_int) -> size_t;
 }

branches/auto/src/libcollections/fmt.rs

@@ -333,7 +333,7 @@
 //! precision := count | '*'
 //! type := identifier | ''
 //! count := parameter | integer
-//! parameter := argument '$'
+//! parameter := integer '$'
 //! ```
 //!
 //! # Formatting Parameters
@@ -403,12 +403,11 @@
 //! println!("Hello {:5}!", "x");
 //! println!("Hello {:1$}!", "x", 5);
 //! println!("Hello {1:0$}!", 5, "x");
-//! println!("Hello {:width$}!", "x", width = 5);
 //! ```
 //!
 //! Referring to an argument with the dollar syntax does not affect the "next
-//! argument" counter, so it's usually a good idea to refer to arguments by
-//! position, or use named arguments.
+//! argument" counter, so it's usually a good idea to refer to all arguments by
+//! their position explicitly.
 //!
 //! ## Precision
 //!
@@ -427,7 +426,7 @@
 //!
 //!    the integer `N` itself is the precision.
 //!
-//! 2. An integer or name followed by dollar sign `.N$`:
+//! 2. An integer followed by dollar sign `.N$`:
 //!
 //!    use format *argument* `N` (which must be a `usize`) as the precision.
 //!
@@ -457,10 +456,6 @@
 //! // Hello {next arg (x)} is {arg 2 (0.01) with precision
 //! //                          specified in its predecessor (5)}
 //! println!("Hello {} is {2:.*}",   "x", 5, 0.01);
-//!
-//! // Hello {next arg (x)} is {arg "number" (0.01) with precision specified
-//! //                          in arg "prec" (5)}
-//! println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01);
 //! ```
 //!
 //! All print the same thing:

branches/auto/src/libcore/intrinsics.rs

@@ -192,8 +192,11 @@ extern "rust-intrinsic" {
 
     /// The size of a type in bytes.
     ///
-    /// More specifically, this is the offset in bytes between successive
-    /// items of the same type, including alignment padding.
+    /// This is the exact number of bytes in memory taken up by a
+    /// value of the given type. In other words, a memset of this size
+    /// would *exactly* overwrite a value. When laid out in vectors
+    /// and structures there may be additional padding between
+    /// elements.
     pub fn size_of<T>() -> usize;
 
     /// Moves a value to an uninitialized memory location.

branches/auto/src/libcore/iter/mod.rs

@@ -541,23 +541,6 @@ impl<A, B> Iterator for Chain<A, B> where
         }
     }
 
-    #[inline]
-    fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
-        P: FnMut(&Self::Item) -> bool,
-    {
-        match self.state {
-            ChainState::Both => match self.a.find(&mut predicate) {
-                None => {
-                    self.state = ChainState::Back;
-                    self.b.find(predicate)
-                }
-                v => v
-            },
-            ChainState::Front => self.a.find(predicate),
-            ChainState::Back => self.b.find(predicate),
-        }
-    }
-
     #[inline]
     fn last(self) -> Option<A::Item> {
         match self.state {

branches/auto/src/libcore/mem.rs

@@ -117,9 +117,6 @@ pub fn forget<T>(t: T) {
 
 /// Returns the size of a type in bytes.
 ///
-/// More specifically, this is the offset in bytes between successive
-/// items of the same type, including alignment padding.
-///
 /// # Examples
 ///
 /// ```

branches/auto/src/libcore/num/int_macros.rs

@@ -10,7 +10,6 @@
 
 #![doc(hidden)]
 
-#[cfg(stage0)]
 macro_rules! int_module { ($T:ty, $bits:expr) => (
 
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
@@ -26,15 +25,3 @@ pub const MIN: $T = (-1 as $T) << ($bits - 1);
 pub const MAX: $T = !MIN;
 
 ) }
-
-#[cfg(not(stage0))]
-macro_rules! int_module { ($T:ident, $bits:expr) => (
-
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
-pub const MIN: $T = $T::min_value();
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
-pub const MAX: $T = $T::max_value();
-
-) }

branches/auto/src/libcore/num/uint_macros.rs

@@ -10,7 +10,6 @@
 
 #![doc(hidden)]
 
-#[cfg(stage0)]
 macro_rules! uint_module { ($T:ty, $bits:expr) => (
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -21,15 +20,3 @@ pub const MIN: $T = 0 as $T;
 pub const MAX: $T = !0 as $T;
 
 ) }
-
-#[cfg(not(stage0))]
-macro_rules! uint_module { ($T:ident, $bits:expr) => (
-
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
-pub const MIN: $T = $T::min_value();
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
-pub const MAX: $T = $T::max_value();
-
-) }

branches/auto/src/libcoretest/iter.rs

@@ -133,19 +133,6 @@ fn test_iterator_chain_count() {
     assert_eq!(zs.iter().chain(&ys).count(), 4);
 }
 
-#[test]
-fn test_iterator_chain_find() {
-    let xs = [0, 1, 2, 3, 4, 5];
-    let ys = [30, 40, 50, 60];
-    let mut iter = xs.iter().chain(&ys);
-    assert_eq!(iter.find(|&&i| i == 4), Some(&4));
-    assert_eq!(iter.next(), Some(&5));
-    assert_eq!(iter.find(|&&i| i == 40), Some(&40));
-    assert_eq!(iter.next(), Some(&50));
-    assert_eq!(iter.find(|&&i| i == 100), None);
-    assert_eq!(iter.next(), None);
-}
-
 #[test]
 fn test_filter_map() {
     let it = (0..).step_by(1).take(10)

branches/auto/src/librustc/diagnostics.rs

@@ -635,17 +635,7 @@ fn foo(x: u8) -> u8 {
 ```
 
 It is advisable to find out what the unhandled cases are and check for them,
-returning an appropriate value or panicking if necessary. Check if you need
-to remove a semicolon from the last expression, like in this case:
-
-```ignore
-fn foo(x: u8) -> u8 {
-    inner(2*x + 1);
-}
-```
-
-The semicolon discards the return value of `inner`, instead of returning
-it from `foo`.
+returning an appropriate value or panicking if necessary.
 "##,
 
 E0270: r##"
@@ -1579,5 +1569,5 @@ register_diagnostics! {
     E0490, // a value of type `..` is borrowed for too long
     E0491, // in type `..`, reference has a longer lifetime than the data it...
     E0495, // cannot infer an appropriate lifetime due to conflicting requirements
-    E0525, // expected a closure that implements `..` but this closure only implements `..`
+    E0524, // expected a closure that implements `..` but this closure only implements `..`
 }