---

yaml
---
r: 277595
b: refs/heads/try
c: 84bd1ce
h: refs/heads/master
i:
  277593: 84e3cb1
  277591: 25cdf33

Author: birkenfeld

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 3157691f963a86776cb7e6a7842f566032890aba
+refs/heads/try: 84bd1ce9841dbefc30c2ade67964ac652856e8a3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/README.md

@@ -16,7 +16,7 @@ Read ["Installing Rust"] from [The Book].
 
 1. Make sure you have installed the dependencies:
 
-   * `g++` 4.7 or later or `clang++` 3.x
+   * `g++` 4.7 or `clang++` 3.x
    * `python` 2.7 (but not 3.x)
    * GNU `make` 3.81 or later
    * `curl`

branches/try/configure

@@ -1453,19 +1453,6 @@ then
     cd ${CFG_BUILD_DIR}
 fi
 
-# Do a sanity check that the submodule source exists. Because GitHub
-# automatically publishes broken tarballs that can't be disabled, and
-# people download them and try to use them.
-if [ ! -e "${CFG_SRC_DIR}/src/liblibc" ]; then
-    err "some submodules are missing. Is this a broken tarball?
-
-If you downloaded this tarball from the GitHub release pages at
-https://github.com/rust-lang/rust/releases,
-then please delete it and instead download the source from
-https://www.rust-lang.org/downloads.html"
-
-fi
-
 # Configure llvm, only if necessary
 step_msg "looking at LLVM"
 CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/

branches/try/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/try/src/libcollections/btree/map.rs

@@ -1654,15 +1654,6 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
             Vacant(entry) => entry.insert(default()),
         }
     }
-
-    /// Returns a reference to this entry's key.
-    #[unstable(feature = "map_entry_keys", issue = "32281")]
-    pub fn key(&self) -> &K {
-        match *self {
-            Occupied(ref entry) => entry.key(),
-            Vacant(ref entry) => entry.key(),
-        }
-    }
 }
 
 impl<'a, K: Ord, V> VacantEntry<'a, K, V> {

branches/try/src/libcollections/btree/set.rs

@@ -477,9 +477,9 @@ impl<T: Ord> BTreeSet<T> {
 
     /// Adds a value to the set.
     ///
-    /// If the set did not have this value present, `true` is returned.
+    /// If the set did not have a value present, `true` is returned.
     ///
-    /// If the set did have this value present, `false` is returned, and the
+    /// If the set did have this key present, `false` is returned, and the
     /// entry is not updated. See the [module-level documentation] for more.
     ///
     /// [module-level documentation]: index.html#insert-and-complex-keys

branches/try/src/libcollections/fmt.rs

@@ -333,7 +333,7 @@
 //! precision := count | '*'
 //! type := identifier | ''
 //! count := parameter | integer
-//! parameter := integer '$'
+//! parameter := argument '$'
 //! ```
 //!
 //! # Formatting Parameters
@@ -403,11 +403,12 @@
 //! 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 all arguments by
-//! their position explicitly.
+//! argument" counter, so it's usually a good idea to refer to arguments by
+//! position, or use named arguments.
 //!
 //! ## Precision
 //!
@@ -426,7 +427,7 @@
 //!
 //!    the integer `N` itself is the precision.
 //!
-//! 2. An integer followed by dollar sign `.N$`:
+//! 2. An integer or name followed by dollar sign `.N$`:
 //!
 //!    use format *argument* `N` (which must be a `usize`) as the precision.
 //!
@@ -456,6 +457,10 @@
 //! // 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/try/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/try/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/try/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/try/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/try/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/try/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/try/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 `..`
 }