---

yaml
---
r: 150742
b: refs/heads/try2
c: 545d471
h: refs/heads/master
v: v3

Author: alexcrichton

[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: ecc774f788ca3880ce76e4b87ac0d21a3a16d3ae
+refs/heads/try2: 545d4718c8e1b9e69474165a1cb38d873627183d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/runtest.rs

@@ -31,7 +31,6 @@ use std::io::timer;
 use std::io;
 use std::os;
 use std::str;
-use std::strbuf::StrBuf;
 use std::task;
 use std::slice;
 use test::MetricMap;
@@ -329,10 +328,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             }
 
             let args = split_maybe_args(&config.target_rustcflags);
-            let mut tool_path = StrBuf::new();
+            let mut tool_path:~str = ~"";
             for arg in args.iter() {
                 if arg.contains("android-cross-path=") {
-                    tool_path = StrBuf::from_str(arg.replace("android-cross-path=", ""));
+                    tool_path = arg.replace("android-cross-path=","");
                     break;
                 }
             }
@@ -349,7 +348,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
             let procsrv::Result{ out, err, status }=
                 procsrv::run("",
-                             gdb_path.as_slice(),
+                             gdb_path,
                              debugger_opts.as_slice(),
                              vec!((~"",~"")),
                              None)

branches/try2/src/doc/guide-ffi.md

@@ -496,16 +496,3 @@ NUL-terminated string for interoperability with C, you should use the `c_str::to
 
 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"
-
-Certain types are defined to not be `null`. This includes references (`&T`,
-`&mut T`), owning pointers (`~T`), and function pointers (`extern "abi"
-fn()`). When interfacing with C, pointers that might be null are often used.
-As a special case, a generic `enum` that contains exactly two variants, one of
-which contains no data and the other containing a single field, is eligible
-for the "nullable pointer optimization". When such an enum is instantiated
-with one of the non-nullable types, it is represented as a single pointer,
-and the non-data variant is represented as the null pointer. So
-`Option<extern "C" fn(c_int) -> c_int>` is how one represents a nullable
-function pointer using the C ABI.

branches/try2/src/doc/guide-testing.md

@@ -170,7 +170,7 @@ runner.
 
 The type signature of a benchmark function differs from a unit test:
 it takes a mutable reference to type
-`test::Bencher`. Inside the benchmark function, any
+`test::BenchHarness`. Inside the benchmark function, any
 time-variable or "setup" code should execute first, followed by a call
 to `iter` on the benchmark harness, passing a closure that contains
 the portion of the benchmark you wish to actually measure the
@@ -189,16 +189,16 @@ For example:
 extern crate test;
 
 use std::slice;
-use test::Bencher;
+use test::BenchHarness;
 
 #[bench]
-fn bench_sum_1024_ints(b: &mut Bencher) {
+fn bench_sum_1024_ints(b: &mut BenchHarness) {
     let v = slice::from_fn(1024, |n| n);
     b.iter(|| {v.iter().fold(0, |old, new| old + *new);} );
 }
 
 #[bench]
-fn initialise_a_vector(b: &mut Bencher) {
+fn initialise_a_vector(b: &mut BenchHarness) {
     b.iter(|| {slice::from_elem(1024, 0u64);} );
     b.bytes = 1024 * 8;
 }
@@ -249,11 +249,11 @@ it entirely.
 ~~~
 # #[allow(unused_imports)];
 extern crate test;
-use test::Bencher;
+use test::BenchHarness;
 
 #[bench]
-fn bench_xor_1000_ints(b: &mut Bencher) {
-    b.iter(|| {
+fn bench_xor_1000_ints(bh: &mut BenchHarness) {
+    bh.iter(|| {
             range(0, 1000).fold(0, |old, new| old ^ new);
         });
 }

branches/try2/src/doc/tutorial.md

@@ -1579,8 +1579,6 @@ allocated memory on the heap. A unique vector owns the elements it contains, so
 the elements are mutable if the vector is mutable.
 
 ~~~
-use std::strbuf::StrBuf;
-
 // A dynamically sized vector (unique vector)
 let mut numbers = ~[1, 2, 3];
 numbers.push(4);
@@ -1591,7 +1589,7 @@ let more_numbers: ~[int] = numbers;
 
 // The original `numbers` value can no longer be used, due to move semantics.
 
-let mut string = StrBuf::from_str("fo");
+let mut string = ~"fo";
 string.push_char('o');
 ~~~
 

branches/try2/src/libarena/lib.rs

@@ -481,7 +481,9 @@ impl<T> Drop for TypedArena<T> {
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::Bencher;
+
+
+    use self::test::BenchHarness;
     use super::{Arena, TypedArena};
 
     struct Point {
@@ -503,9 +505,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy(b: &mut Bencher) {
+    pub fn bench_copy(bh: &mut BenchHarness) {
         let arena = TypedArena::new();
-        b.iter(|| {
+        bh.iter(|| {
             arena.alloc(Point {
                 x: 1,
                 y: 2,
@@ -515,8 +517,8 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy_nonarena(b: &mut Bencher) {
-        b.iter(|| {
+    pub fn bench_copy_nonarena(bh: &mut BenchHarness) {
+        bh.iter(|| {
             ~Point {
                 x: 1,
                 y: 2,
@@ -526,9 +528,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy_old_arena(b: &mut Bencher) {
+    pub fn bench_copy_old_arena(bh: &mut BenchHarness) {
         let arena = Arena::new();
-        b.iter(|| {
+        bh.iter(|| {
             arena.alloc(|| {
                 Point {
                     x: 1,
@@ -556,9 +558,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy(b: &mut Bencher) {
+    pub fn bench_noncopy(bh: &mut BenchHarness) {
         let arena = TypedArena::new();
-        b.iter(|| {
+        bh.iter(|| {
             arena.alloc(Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),
@@ -567,8 +569,8 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy_nonarena(b: &mut Bencher) {
-        b.iter(|| {
+    pub fn bench_noncopy_nonarena(bh: &mut BenchHarness) {
+        bh.iter(|| {
             ~Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),
@@ -577,9 +579,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy_old_arena(b: &mut Bencher) {
+    pub fn bench_noncopy_old_arena(bh: &mut BenchHarness) {
         let arena = Arena::new();
-        b.iter(|| {
+        bh.iter(|| {
             arena.alloc(|| Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),

branches/try2/src/libcollections/bitv.rs

@@ -15,9 +15,8 @@ use std::cmp;
 use std::iter::RandomAccessIterator;
 use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
 use std::ops;
-use std::slice;
-use std::strbuf::StrBuf;
 use std::uint;
+use std::slice;
 
 #[deriving(Clone)]
 struct SmallBitv {
@@ -500,15 +499,15 @@ impl Bitv {
      * character is either '0' or '1'.
      */
      pub fn to_str(&self) -> ~str {
-        let mut rs = StrBuf::new();
+        let mut rs = ~"";
         for i in self.iter() {
             if i {
                 rs.push_char('1');
             } else {
                 rs.push_char('0');
             }
         };
-        rs.into_owned()
+        rs
      }
 
 
@@ -940,7 +939,7 @@ impl<'a> Iterator<uint> for BitPositions<'a> {
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::Bencher;
+    use self::test::BenchHarness;
 
     use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
                from_bytes};
@@ -1557,7 +1556,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_uint_small(b: &mut Bencher) {
+    fn bench_uint_small(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
@@ -1567,7 +1566,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_small_bitv_small(b: &mut Bencher) {
+    fn bench_small_bitv_small(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = SmallBitv::new(uint::BITS);
         b.iter(|| {
@@ -1577,7 +1576,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_big_bitv_small(b: &mut Bencher) {
+    fn bench_big_bitv_small(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = BigBitv::new(vec!(0));
         b.iter(|| {
@@ -1587,7 +1586,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_big_bitv_big(b: &mut Bencher) {
+    fn bench_big_bitv_big(b: &mut BenchHarness) {
         let mut r = rng();
         let mut storage = vec!();
         storage.grow(BENCH_BITS / uint::BITS, &0u);
@@ -1599,7 +1598,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_big(b: &mut Bencher) {
+    fn bench_bitv_big(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
@@ -1609,7 +1608,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_small(b: &mut Bencher) {
+    fn bench_bitv_small(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = Bitv::new(uint::BITS, false);
         b.iter(|| {
@@ -1619,7 +1618,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_small(b: &mut Bencher) {
+    fn bench_bitv_set_small(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -1629,7 +1628,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big(b: &mut Bencher) {
+    fn bench_bitv_set_big(b: &mut BenchHarness) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -1639,7 +1638,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_big_union(b: &mut Bencher) {
+    fn bench_bitv_big_union(b: &mut BenchHarness) {
         let mut b1 = Bitv::new(BENCH_BITS, false);
         let b2 = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
@@ -1648,7 +1647,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_btv_small_iter(b: &mut Bencher) {
+    fn bench_btv_small_iter(b: &mut BenchHarness) {
         let bitv = Bitv::new(uint::BITS, false);
         b.iter(|| {
             let mut _sum = 0;
@@ -1659,7 +1658,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_big_iter(b: &mut Bencher) {
+    fn bench_bitv_big_iter(b: &mut BenchHarness) {
         let bitv = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
             let mut _sum = 0;
@@ -1670,7 +1669,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_iter(b: &mut Bencher) {
+    fn bench_bitvset_iter(b: &mut BenchHarness) {
         let bitv = BitvSet::from_bitv(from_fn(BENCH_BITS,
                                               |idx| {idx % 3 == 0}));
         b.iter(|| {