---

yaml
---
r: 151682
b: refs/heads/try2
c: 67fa90e
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 73a68cdba0d6e5ee28c9ef1ae80ec473f16cd9e9
+refs/heads/try2: 67fa90e48a313b4211e89f6bb893560ddabcc4cb
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/compiletest.rs

@@ -152,8 +152,7 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
             "(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
             !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
         lldb_python_dir: matches.opt_str("lldb-python-dir"),
-        test_shard: test::opt_shard(matches.opt_str("test-shard")
-                                           .map(|x| x.to_strbuf())),
+        test_shard: test::opt_shard(matches.opt_str("test-shard")),
         verbose: matches.opt_present("verbose")
     }
 }
@@ -236,10 +235,7 @@ pub fn run_tests(config: &Config) {
 
 pub fn test_opts(config: &Config) -> test::TestOpts {
     test::TestOpts {
-        filter: match config.filter {
-            None => None,
-            Some(ref filter) => Some(filter.to_strbuf()),
-        },
+        filter: config.filter.clone(),
         run_ignored: config.run_ignored,
         logfile: config.logfile.clone(),
         run_tests: true,
@@ -318,9 +314,7 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
         format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
-    test::DynTestName(format_strbuf!("[{}] {}",
-                                     config.mode,
-                                     shorten(testfile)))
+    test::DynTestName(format!("[{}] {}", config.mode, shorten(testfile)))
 }
 
 pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {

branches/try2/src/libarena/lib.rs

@@ -530,7 +530,7 @@ mod tests {
     }
 
     struct Noncopy {
-        string: StrBuf,
+        string: ~str,
         array: Vec<int> ,
     }
 
@@ -539,7 +539,7 @@ mod tests {
         let arena = TypedArena::new();
         for _ in range(0, 100000) {
             arena.alloc(Noncopy {
-                string: "hello world".to_strbuf(),
+                string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             });
         }
@@ -550,7 +550,7 @@ mod tests {
         let arena = TypedArena::new();
         b.iter(|| {
             arena.alloc(Noncopy {
-                string: "hello world".to_strbuf(),
+                string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             })
         })
@@ -560,7 +560,7 @@ mod tests {
     pub fn bench_noncopy_nonarena(b: &mut Bencher) {
         b.iter(|| {
             box Noncopy {
-                string: "hello world".to_strbuf(),
+                string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             }
         })
@@ -571,7 +571,7 @@ mod tests {
         let arena = Arena::new();
         b.iter(|| {
             arena.alloc(|| Noncopy {
-                string: "hello world".to_strbuf(),
+                string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             })
         })

branches/try2/src/libcollections/lru_cache.rs

@@ -270,23 +270,23 @@ mod tests {
 
     #[test]
     fn test_put_update() {
-        let mut cache: LruCache<StrBuf, Vec<u8>> = LruCache::new(1);
-        cache.put("1".to_strbuf(), vec![10, 10]);
-        cache.put("1".to_strbuf(), vec![10, 19]);
-        assert_opt_eq(cache.get(&"1".to_strbuf()), vec![10, 19]);
+        let mut cache: LruCache<~str, Vec<u8>> = LruCache::new(1);
+        cache.put("1".to_owned(), vec![10, 10]);
+        cache.put("1".to_owned(), vec![10, 19]);
+        assert_opt_eq(cache.get(&"1".to_owned()), vec![10, 19]);
         assert_eq!(cache.len(), 1);
     }
 
     #[test]
     fn test_expire_lru() {
-        let mut cache: LruCache<StrBuf, StrBuf> = LruCache::new(2);
-        cache.put("foo1".to_strbuf(), "bar1".to_strbuf());
-        cache.put("foo2".to_strbuf(), "bar2".to_strbuf());
-        cache.put("foo3".to_strbuf(), "bar3".to_strbuf());
-        assert!(cache.get(&"foo1".to_strbuf()).is_none());
-        cache.put("foo2".to_strbuf(), "bar2update".to_strbuf());
-        cache.put("foo4".to_strbuf(), "bar4".to_strbuf());
-        assert!(cache.get(&"foo3".to_strbuf()).is_none());
+        let mut cache: LruCache<~str, ~str> = LruCache::new(2);
+        cache.put("foo1".to_owned(), "bar1".to_owned());
+        cache.put("foo2".to_owned(), "bar2".to_owned());
+        cache.put("foo3".to_owned(), "bar3".to_owned());
+        assert!(cache.get(&"foo1".to_owned()).is_none());
+        cache.put("foo2".to_owned(), "bar2update".to_owned());
+        cache.put("foo4".to_owned(), "bar4".to_owned());
+        assert!(cache.get(&"foo3".to_owned()).is_none());
     }
 
     #[test]

branches/try2/src/libcore/cmp.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -217,29 +217,6 @@ mod impls {
     }
     impl<'a, T: TotalEq> TotalEq for &'a T {}
 
-    // &mut pointers
-    impl<'a, T: Eq> Eq for &'a mut T {
-        #[inline]
-        fn eq(&self, other: &&'a mut T) -> bool { **self == *(*other) }
-        #[inline]
-        fn ne(&self, other: &&'a mut T) -> bool { **self != *(*other) }
-    }
-    impl<'a, T: Ord> Ord for &'a mut T {
-        #[inline]
-        fn lt(&self, other: &&'a mut T) -> bool { **self < **other }
-        #[inline]
-        fn le(&self, other: &&'a mut T) -> bool { **self <= **other }
-        #[inline]
-        fn ge(&self, other: &&'a mut T) -> bool { **self >= **other }
-        #[inline]
-        fn gt(&self, other: &&'a mut T) -> bool { **self > **other }
-    }
-    impl<'a, T: TotalOrd> TotalOrd for &'a mut T {
-        #[inline]
-        fn cmp(&self, other: &&'a mut T) -> Ordering { (**self).cmp(*other) }
-    }
-    impl<'a, T: TotalEq> TotalEq for &'a mut T {}
-
     // @ pointers
     impl<T:Eq> Eq for @T {
         #[inline]
@@ -277,15 +254,6 @@ mod test {
         assert_eq!(12u.cmp(-5), Greater);
     }
 
-    #[test]
-    fn test_mut_int_totalord() {
-        assert_eq!((&mut 5u).cmp(&10), Less);
-        assert_eq!((&mut 10u).cmp(&5), Greater);
-        assert_eq!((&mut 5u).cmp(&5), Equal);
-        assert_eq!((&mut -5u).cmp(&12), Less);
-        assert_eq!((&mut 12u).cmp(-5), Greater);
-    }
-
     #[test]
     fn test_ordering_order() {
         assert!(Less < Equal);

branches/try2/src/libglob/lib.rs

@@ -310,7 +310,7 @@ impl Pattern {
      * brackets. The resulting string will, when compiled into a `Pattern`,
      * match the input string and nothing else.
      */
-    pub fn escape(s: &str) -> StrBuf {
+    pub fn escape(s: &str) -> ~str {
         let mut escaped = StrBuf::new();
         for c in s.chars() {
             match c {
@@ -325,7 +325,7 @@ impl Pattern {
                 }
             }
         }
-        escaped
+        escaped.into_owned()
     }
 
     /**
@@ -767,8 +767,8 @@ mod test {
     #[test]
     fn test_pattern_escape() {
         let s = "_[_]_?_*_!_";
-        assert_eq!(Pattern::escape(s), "_[[]_[]]_[?]_[*]_!_".to_strbuf());
-        assert!(Pattern::new(Pattern::escape(s).as_slice()).matches(s));
+        assert_eq!(Pattern::escape(s), "_[[]_[]]_[?]_[*]_!_".to_owned());
+        assert!(Pattern::new(Pattern::escape(s)).matches(s));
     }
 
     #[test]

branches/try2/src/libgraphviz/lib.rs

@@ -433,10 +433,10 @@ impl<'a> LabelText<'a> {
     }
 
     /// Renders text as string suitable for a label in a .dot file.
-    pub fn escape(&self) -> StrBuf {
+    pub fn escape(&self) -> ~str {
         match self {
-            &LabelStr(ref s) => s.as_slice().escape_default().to_strbuf(),
-            &EscStr(ref s) => LabelText::escape_str(s.as_slice()).to_strbuf(),
+            &LabelStr(ref s) => s.as_slice().escape_default(),
+            &EscStr(ref s) => LabelText::escape_str(s.as_slice()).into_owned(),
         }
     }
 }
@@ -661,14 +661,11 @@ mod tests {
         }
     }
 
-    fn test_input(g: LabelledGraph) -> IoResult<StrBuf> {
+    fn test_input(g: LabelledGraph) -> IoResult<~str> {
         let mut writer = MemWriter::new();
         render(&g, &mut writer).unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        match r.read_to_str() {
-            Ok(string) => Ok(string.to_strbuf()),
-            Err(err) => Err(err),
-        }
+        r.read_to_str()
     }
 
     // All of the tests use raw-strings as the format for the expected outputs,

branches/try2/src/libhexfloat/lib.rs

@@ -70,39 +70,30 @@ pub fn macro_registrar(register: |Name, SyntaxExtension|) {
 
 //Check if the literal is valid (as LLVM expects),
 //and return a descriptive error if not.
-fn hex_float_lit_err(s: &str) -> Option<(uint, StrBuf)> {
+fn hex_float_lit_err(s: &str) -> Option<(uint, ~str)> {
     let mut chars = s.chars().peekable();
     let mut i = 0;
     if chars.peek() == Some(&'-') { chars.next(); i+= 1 }
-    if chars.next() != Some('0') {
-        return Some((i, "Expected '0'".to_strbuf()));
-    } i+=1;
-    if chars.next() != Some('x') {
-        return Some((i, "Expected 'x'".to_strbuf()));
-    } i+=1;
+    if chars.next() != Some('0') { return Some((i, "Expected '0'".to_owned())); } i+=1;
+    if chars.next() != Some('x') { return Some((i, "Expected 'x'".to_owned())); } i+=1;
     let mut d_len = 0;
     for _ in chars.take_while(|c| c.is_digit_radix(16)) { chars.next(); i+=1; d_len += 1;}
-    if chars.next() != Some('.') {
-        return Some((i, "Expected '.'".to_strbuf()));
-    } i+=1;
+    if chars.next() != Some('.') { return Some((i, "Expected '.'".to_owned())); } i+=1;
     let mut f_len = 0;
     for _ in chars.take_while(|c| c.is_digit_radix(16)) { chars.next(); i+=1; f_len += 1;}
     if d_len == 0 && f_len == 0 {
-        return Some((i, "Expected digits before or after decimal \
-                         point".to_strbuf()));
+        return Some((i, "Expected digits before or after decimal point".to_owned()));
     }
-    if chars.next() != Some('p') {
-        return Some((i, "Expected 'p'".to_strbuf()));
-    } i+=1;
+    if chars.next() != Some('p') { return Some((i, "Expected 'p'".to_owned())); } i+=1;
     if chars.peek() == Some(&'-') { chars.next(); i+= 1 }
     let mut e_len = 0;
     for _ in chars.take_while(|c| c.is_digit()) { chars.next(); i+=1; e_len += 1}
     if e_len == 0 {
-        return Some((i, "Expected exponent digits".to_strbuf()));
+        return Some((i, "Expected exponent digits".to_owned()));
     }
     match chars.next() {
         None => None,
-        Some(_) => Some((i, "Expected end of string".to_strbuf()))
+        Some(_) => Some((i, "Expected end of string".to_owned()))
     }
 }
 

branches/try2/src/liblog/directive.rs

@@ -13,7 +13,7 @@ use std::cmp;
 
 #[deriving(Show, Clone)]
 pub struct LogDirective {
-    pub name: Option<StrBuf>,
+    pub name: Option<~str>,
     pub level: u32,
 }
 
@@ -64,7 +64,7 @@ pub fn parse_logging_spec(spec: &str) -> Vec<LogDirective> {
             }
         };
         dirs.push(LogDirective {
-            name: name.map(|s| s.to_strbuf()),
+            name: name.map(|s| s.to_owned()),
             level: log_level,
         });
     }
@@ -80,13 +80,13 @@ mod tests {
         let dirs = parse_logging_spec("crate1::mod1=1,crate1::mod2,crate2=4");
         let dirs = dirs.as_slice();
         assert_eq!(dirs.len(), 3);
-        assert_eq!(dirs[0].name, Some("crate1::mod1".to_strbuf()));
+        assert_eq!(dirs[0].name, Some("crate1::mod1".to_owned()));
         assert_eq!(dirs[0].level, 1);
 
-        assert_eq!(dirs[1].name, Some("crate1::mod2".to_strbuf()));
+        assert_eq!(dirs[1].name, Some("crate1::mod2".to_owned()));
         assert_eq!(dirs[1].level, ::MAX_LOG_LEVEL);
 
-        assert_eq!(dirs[2].name, Some("crate2".to_strbuf()));
+        assert_eq!(dirs[2].name, Some("crate2".to_owned()));
         assert_eq!(dirs[2].level, 4);
     }
 
@@ -96,7 +96,7 @@ mod tests {
         let dirs = parse_logging_spec("crate1::mod1=1=2,crate2=4");
         let dirs = dirs.as_slice();
         assert_eq!(dirs.len(), 1);
-        assert_eq!(dirs[0].name, Some("crate2".to_strbuf()));
+        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
         assert_eq!(dirs[0].level, 4);
     }
 
@@ -106,7 +106,7 @@ mod tests {
         let dirs = parse_logging_spec("crate1::mod1=noNumber,crate2=4");
         let dirs = dirs.as_slice();
         assert_eq!(dirs.len(), 1);
-        assert_eq!(dirs[0].name, Some("crate2".to_strbuf()));
+        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
         assert_eq!(dirs[0].level, 4);
     }
 
@@ -116,7 +116,7 @@ mod tests {
         let dirs = parse_logging_spec("crate1::mod1=wrong,crate2=warn");
         let dirs = dirs.as_slice();
         assert_eq!(dirs.len(), 1);
-        assert_eq!(dirs[0].name, Some("crate2".to_strbuf()));
+        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
         assert_eq!(dirs[0].level, ::WARN);
     }
 
@@ -128,7 +128,7 @@ mod tests {
         assert_eq!(dirs.len(), 2);
         assert_eq!(dirs[0].name, None);
         assert_eq!(dirs[0].level, 2);
-        assert_eq!(dirs[1].name, Some("crate2".to_strbuf()));
+        assert_eq!(dirs[1].name, Some("crate2".to_owned()));
         assert_eq!(dirs[1].level, 4);
     }
 }