---

yaml
---
r: 162583
b: refs/heads/try
c: f1f6c12
h: refs/heads/master
i:
  162581: 40f838e
  162579: 28b7aa3
  162575: 616be87
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: 0c1d853fba0068f9fd34b43a565ded01b199506c
+refs/heads/try: f1f6c1286f24f6f762a9b195ac678b55d20c9a9b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/etc/emacs/rust-mode.el

@@ -31,6 +31,9 @@
     (modify-syntax-entry ?\" "\"" table)
     (modify-syntax-entry ?\\ "\\" table)
 
+    ;; _ is a word-char
+    (modify-syntax-entry ?_ "w" table)
+
     ;; Comments
     (modify-syntax-entry ?/  ". 124b" table)
     (modify-syntax-entry ?*  ". 23"   table)
@@ -394,7 +397,7 @@ This is written mainly to be used as `beginning-of-defun-function' for Rust.
 Don't move to the beginning of the line. `beginning-of-defun',
 which calls this, does that afterwards."
   (interactive "p")
-  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\_>")
+  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\b")
                       nil 'move (or arg 1)))
 
 (defun rust-end-of-defun ()

branches/try/src/libcollections/binary_heap.rs

@@ -160,7 +160,9 @@ use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
 use slice;
-use vec::{mod, Vec};
+use vec::Vec;
+
+// FIXME(conventions): implement into_iter
 
 /// A priority queue implemented with a binary heap.
 ///
@@ -241,27 +243,6 @@ impl<T: Ord> BinaryHeap<T> {
         Items { iter: self.data.iter() }
     }
 
-    /// Creates a consuming iterator, that is, one that moves each value out of
-    /// the binary heap in arbitrary order.  The binary heap cannot be used
-    /// after calling this.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let pq = BinaryHeap::from_vec(vec![1i, 2, 3, 4]);
-    ///
-    /// // Print 1, 2, 3, 4 in arbitrary order
-    /// for x in pq.into_iter() {
-    ///     // x has type int, not &int
-    ///     println!("{}", x);
-    /// }
-    /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn into_iter(self) -> MoveItems<T> {
-        MoveItems { iter: self.data.into_iter() }
-    }
-
     /// Returns the greatest item in a queue, or `None` if it is empty.
     ///
     /// # Example
@@ -567,26 +548,6 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
-/// An iterator that moves out of a `BinaryHeap`.
-pub struct MoveItems<T> {
-    iter: vec::MoveItems<T>,
-}
-
-impl<T> Iterator<T> for MoveItems<T> {
-    #[inline]
-    fn next(&mut self) -> Option<T> { self.iter.next() }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
-}
-
-impl<T> DoubleEndedIterator<T> for MoveItems<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
-}
-
-impl<T> ExactSize<T> for MoveItems<T> {}
-
 impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> BinaryHeap<T> {
         let vec: Vec<T> = iter.collect();
@@ -625,43 +586,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_move_iter() {
-        let data = vec!(5i, 9, 3);
-        let iterout = vec!(9i, 5, 3);
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<int> = pq.into_iter().collect();
-        assert_eq!(v, iterout);
-    }
-
-    #[test]
-    fn test_move_iter_size_hint() {
-        let data = vec!(5i, 9);
-        let pq = BinaryHeap::from_vec(data);
-
-        let mut it = pq.into_iter();
-
-        assert_eq!(it.size_hint(), (2, Some(2)));
-        assert_eq!(it.next(), Some(9i));
-
-        assert_eq!(it.size_hint(), (1, Some(1)));
-        assert_eq!(it.next(), Some(5i));
-
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_move_iter_reverse() {
-        let data = vec!(5i, 9, 3);
-        let iterout = vec!(3i, 5, 9);
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<int> = pq.into_iter().rev().collect();
-        assert_eq!(v, iterout);
-    }
-
     #[test]
     fn test_top_and_pop() {
         let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);

branches/try/src/libcollections/str.rs

@@ -163,7 +163,7 @@ impl<S: Str> StrVector for [S] {
     }
 }
 
-impl<S: Str, T: AsSlice<S>> StrVector for T {
+impl<S: Str> StrVector for Vec<S> {
     #[inline]
     fn concat(&self) -> String {
         self.as_slice().concat()
@@ -929,93 +929,54 @@ mod tests {
         assert_eq!("ะเทศไท", "ประเทศไทย中华Việt Nam".slice_chars(2, 8));
     }
 
-    struct S {
-        x: [String, .. 2]
-    }
-
-    impl AsSlice<String> for S {
-        fn as_slice<'a> (&'a self) -> &'a [String] {
-            &self.x
-        }
-    }
-
-    fn s(x: &str) -> String { x.into_string() }
-
-    macro_rules! test_concat {
-        ($expected: expr, $string: expr) => {
-            {
-                let s = $string.concat();
-                assert_eq!($expected, s.as_slice());
-            }
-        }
-    }
-
     #[test]
-    fn test_concat_for_different_types() {
-        test_concat!("ab", ["a", "b"]);
-        test_concat!("ab", [s("a"), s("b")]);
-        test_concat!("ab", vec!["a", "b"]);
-        test_concat!("ab", vec!["a", "b"].as_slice());
-        test_concat!("ab", vec![s("a"), s("b")]);
-
-        let mut v0 = ["a", "b"];
-        let mut v1 = [s("a"), s("b")];
-        unsafe {
-            use std::c_vec::CVec;
-
-            test_concat!("ab", CVec::new(v0.as_mut_ptr(), v0.len()));
-            test_concat!("ab", CVec::new(v1.as_mut_ptr(), v1.len()));
+    fn test_concat() {
+        fn t(v: &[String], s: &str) {
+            assert_eq!(v.concat().as_slice(), s);
         }
-
-        test_concat!("ab", S { x: [s("a"), s("b")] });
+        t(&[String::from_str("you"), String::from_str("know"),
+            String::from_str("I'm"),
+            String::from_str("no"), String::from_str("good")],
+          "youknowI'mnogood");
+        let v: &[String] = &[];
+        t(v, "");
+        t(&[String::from_str("hi")], "hi");
     }
 
     #[test]
-    fn test_concat_for_different_lengths() {
-        let empty: &[&str] = &[];
-        test_concat!("", empty);
-        test_concat!("a", ["a"]);
-        test_concat!("ab", ["a", "b"]);
-        test_concat!("abc", ["", "a", "bc"]);
-    }
-
-    macro_rules! test_connect {
-        ($expected: expr, $string: expr, $delim: expr) => {
-            {
-                let s = $string.connect($delim);
-                assert_eq!($expected, s.as_slice());
-            }
+    fn test_connect() {
+        fn t(v: &[String], sep: &str, s: &str) {
+            assert_eq!(v.connect(sep).as_slice(), s);
         }
+        t(&[String::from_str("you"), String::from_str("know"),
+            String::from_str("I'm"),
+            String::from_str("no"), String::from_str("good")],
+          " ", "you know I'm no good");
+        let v: &[String] = &[];
+        t(v, " ", "");
+        t(&[String::from_str("hi")], " ", "hi");
     }
 
     #[test]
-    fn test_connect_for_different_types() {
-        test_connect!("a-b", ["a", "b"], "-");
-        let hyphen = "-".into_string();
-        test_connect!("a-b", [s("a"), s("b")], hyphen.as_slice());
-        test_connect!("a-b", vec!["a", "b"], hyphen.as_slice());
-        test_connect!("a-b", vec!["a", "b"].as_slice(), "-");
-        test_connect!("a-b", vec![s("a"), s("b")], "-");
-
-        let mut v0 = ["a", "b"];
-        let mut v1 = [s("a"), s("b")];
-        unsafe {
-            use std::c_vec::CVec;
-
-            test_connect!("a-b", CVec::new(v0.as_mut_ptr(), v0.len()), "-");
-            test_connect!("a-b", CVec::new(v1.as_mut_ptr(), v1.len()), hyphen.as_slice());
+    fn test_concat_slices() {
+        fn t(v: &[&str], s: &str) {
+            assert_eq!(v.concat().as_slice(), s);
         }
-
-        test_connect!("a-b", S { x: [s("a"), s("b")] }, "-");
+        t(&["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
+        let v: &[&str] = &[];
+        t(v, "");
+        t(&["hi"], "hi");
     }
 
     #[test]
-    fn test_connect_for_different_lengths() {
-        let empty: &[&str] = &[];
-        test_connect!("", empty, "-");
-        test_connect!("a", ["a"], "-");
-        test_connect!("a-b", ["a", "b"], "-");
-        test_connect!("-a-bc", ["", "a", "bc"], "-");
+    fn test_connect_slices() {
+        fn t(v: &[&str], sep: &str, s: &str) {
+            assert_eq!(v.connect(sep).as_slice(), s);
+        }
+        t(&["you", "know", "I'm", "no", "good"],
+          " ", "you know I'm no good");
+        t(&[], " ", "");
+        t(&["hi"], " ", "hi");
     }
 
     #[test]

branches/try/src/libcollections/vec.rs

@@ -1248,14 +1248,18 @@ pub struct MoveItems<T> {
 impl<T> MoveItems<T> {
     #[inline]
     /// Drops all items that have not yet been moved and returns the empty vector.
-    pub fn unwrap(mut self) -> Vec<T> {
+    pub fn into_inner(mut self) -> Vec<T> {
         unsafe {
             for _x in self { }
             let MoveItems { allocation, cap, ptr: _ptr, end: _end } = self;
             mem::forget(self);
             Vec { ptr: allocation, cap: cap, len: 0 }
         }
     }
+
+    /// Deprecated, use into_inner() instead
+    #[deprecated = "renamed to into_inner()"]
+    pub fn unwrap(self) -> Vec<T> { self.into_inner() }
 }
 
 impl<T> Iterator<T> for MoveItems<T> {

branches/try/src/libcore/any.rs

@@ -88,7 +88,7 @@ use intrinsics::TypeId;
 #[stable]
 pub trait Any: 'static {
     /// Get the `TypeId` of `self`
-    #[experimental = "this method will likely be replaced by an associated static"]
+    #[stable]
     fn get_type_id(&self) -> TypeId;
 }
 

branches/try/src/libcore/cell.rs

@@ -256,15 +256,19 @@ impl<T> RefCell<T> {
     }
 
     /// Consumes the `RefCell`, returning the wrapped value.
-    #[unstable = "may be renamed, depending on global conventions"]
-    pub fn unwrap(self) -> T {
+    #[unstable = "recently renamed per RFC 430"]
+    pub fn into_inner(self) -> T {
         // Since this function takes `self` (the `RefCell`) by value, the
         // compiler statically verifies that it is not currently borrowed.
         // Therefore the following assertion is just a `debug_assert!`.
         debug_assert!(self.borrow.get() == UNUSED);
-        unsafe{self.value.unwrap()}
+        unsafe { self.value.into_inner() }
     }
 
+    /// Deprecated, use into_inner() instead
+    #[deprecated = "renamed to into_inner()"]
+    pub fn unwrap(self) -> T { self.into_inner() }
+
     /// Attempts to immutably borrow the wrapped value.
     ///
     /// The borrow lasts until the returned `Ref` exits scope. Multiple
@@ -518,5 +522,9 @@ impl<T> UnsafeCell<T> {
     #[inline]
     #[unstable = "conventions around the name `unwrap` are still under \
                   development"]
-    pub unsafe fn unwrap(self) -> T { self.value }
+    pub unsafe fn into_inner(self) -> T { self.value }
+
+    /// Deprecated, use into_inner() instead
+    #[deprecated = "renamed to into_inner()"]
+    pub unsafe fn unwrap(self) -> T { self.into_inner() }
 }