---

yaml
---
r: 160638
b: refs/heads/master
c: bbe1a9b
h: refs/heads/master
v: v3

Author: nrc

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 377d7524a897ae91dfd48e7e34847af88dac49cb
+refs/heads/master: bbe1a9b9c18d6dce6140ef16cbc9c29ad586564d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c9f6d696420107f82304b992cf623b806995fe18
 refs/heads/try: 225de0d60f8ca8dcc62ab2fd8818ebbda4b58cfe

trunk/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);

trunk/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]

trunk/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;
 }
 

trunk/src/libcore/str.rs

@@ -1277,19 +1277,14 @@ pub mod traits {
 }
 
 /// Any string that can be represented as a slice
-pub trait Str for Sized? {
+pub trait Str {
     /// Work with `self` as a slice.
     fn as_slice<'a>(&'a self) -> &'a str;
 }
 
-impl Str for str {
+impl<'a> Str for &'a str {
     #[inline]
-    fn as_slice<'a>(&'a self) -> &'a str { self }
-}
-
-impl<'a, Sized? S> Str for &'a S where S: Str {
-    #[inline]
-    fn as_slice(&self) -> &str { Str::as_slice(*self) }
+    fn as_slice<'a>(&'a self) -> &'a str { *self }
 }
 
 /// Methods for string slices

trunk/src/liblog/lib.rs

@@ -171,7 +171,7 @@
 
 extern crate regex;
 
-use std::cell::RefCell;
+use regex::Regex;
 use std::fmt;
 use std::io::LineBufferedWriter;
 use std::io;
@@ -181,8 +181,6 @@ use std::rt;
 use std::slice;
 use std::sync::{Once, ONCE_INIT};
 
-use regex::Regex;
-
 use directive::LOG_LEVEL_NAMES;
 
 pub mod macros;
@@ -215,9 +213,7 @@ pub const WARN: u32 = 2;
 /// Error log level
 pub const ERROR: u32 = 1;
 
-thread_local!(static LOCAL_LOGGER: RefCell<Option<Box<Logger + Send>>> = {
-    RefCell::new(None)
-})
+local_data_key!(local_logger: Box<Logger + Send>)
 
 /// A trait used to represent an interface to a task-local logger. Each task
 /// can have its own custom logger which can respond to logging messages
@@ -287,9 +283,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
     // Completely remove the local logger from TLS in case anyone attempts to
     // frob the slot while we're doing the logging. This will destroy any logger
     // set during logging.
-    let mut logger = LOCAL_LOGGER.with(|s| {
-        s.borrow_mut().take()
-    }).unwrap_or_else(|| {
+    let mut logger = local_logger.replace(None).unwrap_or_else(|| {
         box DefaultLogger { handle: io::stderr() } as Box<Logger + Send>
     });
     logger.log(&LogRecord {
@@ -299,7 +293,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
         module_path: loc.module_path,
         line: loc.line,
     });
-    set_logger(logger);
+    local_logger.replace(Some(logger));
 }
 
 /// Getter for the global log level. This is a function so that it can be called
@@ -311,10 +305,7 @@ pub fn log_level() -> u32 { unsafe { LOG_LEVEL } }
 /// Replaces the task-local logger with the specified logger, returning the old
 /// logger.
 pub fn set_logger(logger: Box<Logger + Send>) -> Option<Box<Logger + Send>> {
-    let mut l = Some(logger);
-    LOCAL_LOGGER.with(|slot| {
-        mem::replace(&mut *slot.borrow_mut(), l.take())
-    })
+    local_logger.replace(Some(logger))
 }
 
 /// A LogRecord is created by the logging macros, and passed as the only

trunk/src/librustc/util/common.rs

@@ -10,7 +10,7 @@
 
 #![allow(non_camel_case_types)]
 
-use std::cell::{RefCell, Cell};
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::Show;
 use std::hash::{Hash, Hasher};
@@ -26,14 +26,11 @@ use syntax::visit::Visitor;
 pub struct ErrorReported;
 
 pub fn time<T, U>(do_it: bool, what: &str, u: U, f: |U| -> T) -> T {
-    thread_local!(static DEPTH: Cell<uint> = Cell::new(0));
+    local_data_key!(depth: uint);
     if !do_it { return f(u); }
 
-    let old = DEPTH.with(|slot| {
-        let r = slot.get();
-        slot.set(r + 1);
-        r
-    });
+    let old = depth.get().map(|d| *d).unwrap_or(0);
+    depth.replace(Some(old + 1));
 
     let mut u = Some(u);
     let mut rv = None;
@@ -44,7 +41,7 @@ pub fn time<T, U>(do_it: bool, what: &str, u: U, f: |U| -> T) -> T {
 
     println!("{}time: {}.{:03} \t{}", "  ".repeat(old),
              dur.num_seconds(), dur.num_milliseconds() % 1000, what);
-    DEPTH.with(|slot| slot.set(old));
+    depth.replace(Some(old));
 
     rv
 }

trunk/src/librustc_trans/save/recorder.rs

@@ -171,7 +171,7 @@ impl<'a> FmtStrs<'a> {
 
         let pairs = fields.iter().zip(values);
         let mut strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape(
-            if *f == "qualname" {
+            if *f == "qualname" && v.len() > 0 {
                 let mut n = self.krate.clone();
                 n.push_str("::");
                 n.push_str(v);