---

yaml
---
r: 232825
b: refs/heads/try
c: 4b571b0
h: refs/heads/master
i:
  232823: 7678034
v: v3

Author: jonas-schievink

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 09dd65c2f60ba635378d2e9afdb1ca4775d8e76c
+refs/heads/try: 4b571b055d8ac9c77d1337e2bda2652bfc024de9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/.travis.yml

@@ -20,7 +20,7 @@ sudo: false
 before_script:
   - ./configure --enable-ccache
 script:
-  - make tidy && make check -j4
+  - make tidy check -j4
 
 env:
   - CXX=/usr/bin/g++-4.7

branches/try/README.md

@@ -65,9 +65,6 @@ Read ["Installing Rust"] from [The Book].
    tools.
 
    ```sh
-   # Update package mirrors (may be needed if you have a fresh install of MSYS2)
-   $ pacman -Sy pacman-mirrors
-   
    # Choose one based on platform:
    $ pacman -S mingw-w64-i686-toolchain
    $ pacman -S mingw-w64-x86_64-toolchain

branches/try/src/doc/nomicon/leaking.md

@@ -155,6 +155,7 @@ impl<T> Rc<T> {
 impl<T> Drop for Rc<T> {
     fn drop(&mut self) {
         unsafe {
+            let inner = &mut ;
             (*self.ptr).ref_count -= 1;
             if (*self.ptr).ref_count == 0 {
                 // drop the data and then free it

branches/try/src/doc/trpl/ffi.md

@@ -496,11 +496,9 @@ strings are not terminated with `\0`. If you need a NUL-terminated string for
 interoperability with C, you should use the `CString` type in the `std::ffi`
 module.
 
-The [`libc` crate on crates.io][libc] includes type aliases and function
-definitions for the C standard library in the `libc` module, and Rust links
-against `libc` and `libm` by default.
-
-[libc]: https://crates.io/crates/libc
+The standard library includes type aliases and function definitions for the C
+standard library in the `libc` module, and Rust links against `libc` and `libm`
+by default.
 
 # The "nullable pointer optimization"
 

branches/try/src/doc/trpl/loops.md

@@ -134,7 +134,7 @@ Outputs:
 ```text
 0: Content of line one
 1: Content of line two
-2: Content of line three
+2: Content of line tree
 3: Content of line four
 ```
 

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

@@ -459,7 +459,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
                 }
             });
             match result {
-                Finished(ret) => return ret.map(|(_, v)| v),
+                Finished(ret) => return ret,
                 Continue(new_stack) => stack = new_stack
             }
         }
@@ -693,16 +693,16 @@ mod stack {
     impl<'a, K, V> SearchStack<'a, K, V, handle::KV, handle::Leaf> {
         /// Removes the key and value in the top element of the stack, then handles underflows as
         /// described in BTree's pop function.
-        fn remove_leaf(mut self) -> (K, V) {
+        fn remove_leaf(mut self) -> V {
             self.map.length -= 1;
 
             // Remove the key-value pair from the leaf that this search stack points to.
             // Then, note if the leaf is underfull, and promptly forget the leaf and its ptr
             // to avoid ownership issues.
-            let (key_val, mut underflow) = unsafe {
-                let key_val = self.top.from_raw_mut().remove_as_leaf();
+            let (value, mut underflow) = unsafe {
+                let (_, value) = self.top.from_raw_mut().remove_as_leaf();
                 let underflow = self.top.from_raw().node().is_underfull();
-                (key_val, underflow)
+                (value, underflow)
             };
 
             loop {
@@ -717,7 +717,7 @@ mod stack {
                             self.map.depth -= 1;
                             self.map.root.hoist_lone_child();
                         }
-                        return key_val;
+                        return value;
                     }
                     Some(mut handle) => {
                         if underflow {
@@ -728,7 +728,7 @@ mod stack {
                             }
                         } else {
                             // All done!
-                            return key_val;
+                            return value;
                         }
                     }
                 }
@@ -739,7 +739,7 @@ mod stack {
     impl<'a, K, V> SearchStack<'a, K, V, handle::KV, handle::LeafOrInternal> {
         /// Removes the key and value in the top element of the stack, then handles underflows as
         /// described in BTree's pop function.
-        pub fn remove(self) -> (K, V) {
+        pub fn remove(self) -> V {
             // Ensure that the search stack goes to a leaf. This is necessary to perform deletion
             // in a BTree. Note that this may put the tree in an inconsistent state (further
             // described in into_leaf's comments), but this is immediately fixed by the
@@ -1208,7 +1208,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
     /// Takes the value of the entry out of the map, and returns it.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn remove(self) -> V {
-        self.stack.remove().1
+        self.stack.remove()
     }
 }
 
@@ -1609,86 +1609,3 @@ impl<K: Ord, V> BTreeMap<K, V> {
         }
     }
 }
-
-impl<K, Q: ?Sized> super::Recover<Q> for BTreeMap<K, ()> where K: Borrow<Q> + Ord, Q: Ord {
-    type Key = K;
-
-    fn get(&self, key: &Q) -> Option<&K> {
-        let mut cur_node = &self.root;
-        loop {
-            match Node::search(cur_node, key) {
-                Found(handle) => return Some(handle.into_kv().0),
-                GoDown(handle) => match handle.force() {
-                    Leaf(_) => return None,
-                    Internal(internal_handle) => {
-                        cur_node = internal_handle.into_edge();
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-
-    fn take(&mut self, key: &Q) -> Option<K> {
-        // See `remove` for an explanation of this.
-
-        let mut stack = stack::PartialSearchStack::new(self);
-        loop {
-            let result = stack.with(move |pusher, node| {
-                match Node::search(node, key) {
-                    Found(handle) => {
-                        // Perfect match. Terminate the stack here, and remove the entry
-                        Finished(Some(pusher.seal(handle).remove()))
-                    },
-                    GoDown(handle) => {
-                        // We need to keep searching, try to go down the next edge
-                        match handle.force() {
-                            // We're at a leaf; the key isn't in here
-                            Leaf(_) => Finished(None),
-                            Internal(internal_handle) => Continue(pusher.push(internal_handle))
-                        }
-                    }
-                }
-            });
-            match result {
-                Finished(ret) => return ret.map(|(k, _)| k),
-                Continue(new_stack) => stack = new_stack
-            }
-        }
-    }
-
-    fn replace(&mut self, mut key: K) -> Option<K> {
-        // See `insert` for an explanation of this.
-
-        let mut stack = stack::PartialSearchStack::new(self);
-
-        loop {
-            let result = stack.with(move |pusher, node| {
-                match Node::search::<K, _>(node, &key) {
-                    Found(mut handle) => {
-                        mem::swap(handle.key_mut(), &mut key);
-                        Finished(Some(key))
-                    },
-                    GoDown(handle) => {
-                        match handle.force() {
-                            Leaf(leaf_handle) => {
-                                pusher.seal(leaf_handle).insert(key, ());
-                                Finished(None)
-                            }
-                            Internal(internal_handle) => {
-                                Continue((pusher.push(internal_handle), key, ()))
-                            }
-                        }
-                    }
-                }
-            });
-            match result {
-                Finished(ret) => return ret,
-                Continue((new_stack, renewed_key, _)) => {
-                    stack = new_stack;
-                    key = renewed_key;
-                }
-            }
-        }
-    }
-}

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

@@ -11,11 +11,3 @@
 mod node;
 pub mod map;
 pub mod set;
-
-trait Recover<Q: ?Sized> {
-    type Key;
-
-    fn get(&self, key: &Q) -> Option<&Self::Key>;
-    fn take(&mut self, key: &Q) -> Option<Self::Key>;
-    fn replace(&mut self, key: Self::Key) -> Option<Self::Key>;
-}

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

@@ -19,7 +19,6 @@ use core::ops::{BitOr, BitAnd, BitXor, Sub};
 
 use borrow::Borrow;
 use btree_map::{BTreeMap, Keys};
-use super::Recover;
 use Bound;
 
 // FIXME(conventions): implement bounded iterators
@@ -330,16 +329,6 @@ impl<T: Ord> BTreeSet<T> {
         self.map.contains_key(value)
     }
 
-    /// Returns a reference to the value in the set, if any, that is equal to the given value.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    #[unstable(feature = "set_recovery", issue = "28050")]
-    pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T> where T: Borrow<Q>, Q: Ord {
-        Recover::get(&self.map, value)
-    }
-
     /// Returns `true` if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty intersection.
     ///
@@ -447,13 +436,6 @@ impl<T: Ord> BTreeSet<T> {
         self.map.insert(value, ()).is_none()
     }
 
-    /// Adds a value to the set, replacing the existing value, if any, that is equal to the given
-    /// one. Returns the replaced value.
-    #[unstable(feature = "set_recovery", issue = "28050")]
-    pub fn replace(&mut self, value: T) -> Option<T> {
-        Recover::replace(&mut self.map, value)
-    }
-
     /// Removes a value from the set. Returns `true` if the value was
     /// present in the set.
     ///
@@ -476,16 +458,6 @@ impl<T: Ord> BTreeSet<T> {
     pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where T: Borrow<Q>, Q: Ord {
         self.map.remove(value).is_some()
     }
-
-    /// Removes and returns the value in the set, if any, that is equal to the given one.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    #[unstable(feature = "set_recovery", issue = "28050")]
-    pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where T: Borrow<Q>, Q: Ord {
-        Recover::take(&mut self.map, value)
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

branches/try/src/libcollections/fmt.rs

@@ -481,7 +481,6 @@ pub use core::fmt::{LowerHex, UpperHex, Pointer};
 pub use core::fmt::{LowerExp, UpperExp};
 pub use core::fmt::Error;
 pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt};
-pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
 
 use string;
 

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

@@ -211,52 +211,3 @@ fn test_extend_ref() {
     assert!(a.contains(&5));
     assert!(a.contains(&6));
 }
-
-#[test]
-fn test_recovery() {
-    use std::cmp::Ordering;
-
-    #[derive(Debug)]
-    struct Foo(&'static str, i32);
-
-    impl PartialEq for Foo {
-        fn eq(&self, other: &Self) -> bool {
-            self.0 == other.0
-        }
-    }
-
-    impl Eq for Foo {}
-
-    impl PartialOrd for Foo {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            self.0.partial_cmp(&other.0)
-        }
-    }
-
-    impl Ord for Foo {
-        fn cmp(&self, other: &Self) -> Ordering {
-            self.0.cmp(&other.0)
-        }
-    }
-
-    let mut s = BTreeSet::new();
-    assert_eq!(s.replace(Foo("a", 1)), None);
-    assert_eq!(s.len(), 1);
-    assert_eq!(s.replace(Foo("a", 2)), Some(Foo("a", 1)));
-    assert_eq!(s.len(), 1);
-
-    {
-        let mut it = s.iter();
-        assert_eq!(it.next(), Some(&Foo("a", 2)));
-        assert_eq!(it.next(), None);
-    }
-
-    assert_eq!(s.get(&Foo("a", 1)), Some(&Foo("a", 2)));
-    assert_eq!(s.take(&Foo("a", 1)), Some(Foo("a", 2)));
-    assert_eq!(s.len(), 0);
-
-    assert_eq!(s.get(&Foo("a", 1)), None);
-    assert_eq!(s.take(&Foo("a", 1)), None);
-
-    assert_eq!(s.iter().next(), None);
-}

branches/try/src/libcollectionstest/lib.rs

@@ -25,7 +25,6 @@
 #![feature(rand)]
 #![feature(range_inclusive)]
 #![feature(rustc_private)]
-#![feature(set_recovery)]
 #![feature(slice_bytes)]
 #![feature(slice_splits)]
 #![feature(split_off)]

branches/try/src/libcore/str/mod.rs

@@ -292,18 +292,6 @@ impl<'a> DoubleEndedIterator for Chars<'a> {
     }
 }
 
-impl<'a> Chars<'a> {
-    /// View the underlying data as a subslice of the original data.
-    ///
-    /// This has the same lifetime as the original slice, and so the
-    /// iterator can continue to be used while this exists.
-    #[unstable(feature = "iter_to_slice", issue = "27775")]
-    #[inline]
-    pub fn as_str(&self) -> &'a str {
-        unsafe { from_utf8_unchecked(self.iter.as_slice()) }
-    }
-}
-
 /// Iterator for a string's characters and their byte offsets.
 #[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -351,18 +339,6 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> {
     }
 }
 
-impl<'a> CharIndices<'a> {
-    /// View the underlying data as a subslice of the original data.
-    ///
-    /// This has the same lifetime as the original slice, and so the
-    /// iterator can continue to be used while this exists.
-    #[unstable(feature = "iter_to_slice", issue = "27775")]
-    #[inline]
-    pub fn as_str(&self) -> &'a str {
-        self.iter.as_str()
-    }
-}
-
 /// External iterator for a string's bytes.
 /// Use with the `std::iter` module.
 ///

branches/try/src/librustc/plugin/registry.rs

@@ -145,11 +145,6 @@ impl<'a> Registry<'a> {
     /// `Whitelisted` attributes will additionally not trigger the `unused_attribute`
     /// lint. `CrateLevel` attributes will not be allowed on anything other than a crate.
     pub fn register_attribute(&mut self, name: String, ty: AttributeType) {
-        if let AttributeType::Gated(..) = ty {
-            self.sess.span_err(self.krate_span, "plugin tried to register a gated \
-                                                 attribute. Only `Normal`, `Whitelisted`, \
-                                                 and `CrateLevel` attributes are allowed");
-        }
         self.attributes.push((name, ty));
     }
 }