---

yaml
---
r: 150743
b: refs/heads/try2
c: ab0d847
h: refs/heads/master
i:
  150741: fb798df
  150739: 78de0d2
  150735: ee6a659
v: v3

Author: bors

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

branches/try2/src/compiletest/runtest.rs

@@ -31,6 +31,7 @@ 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;
@@ -328,10 +329,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             }
 
             let args = split_maybe_args(&config.target_rustcflags);
-            let mut tool_path:~str = ~"";
+            let mut tool_path = StrBuf::new();
             for arg in args.iter() {
                 if arg.contains("android-cross-path=") {
-                    tool_path = arg.replace("android-cross-path=","");
+                    tool_path = StrBuf::from_str(arg.replace("android-cross-path=", ""));
                     break;
                 }
             }
@@ -348,7 +349,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,
+                             gdb_path.as_slice(),
                              debugger_opts.as_slice(),
                              vec!((~"",~"")),
                              None)

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

@@ -496,3 +496,16 @@ 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::BenchHarness`. Inside the benchmark function, any
+`test::Bencher`. 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::BenchHarness;
+use test::Bencher;
 
 #[bench]
-fn bench_sum_1024_ints(b: &mut BenchHarness) {
+fn bench_sum_1024_ints(b: &mut Bencher) {
     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 BenchHarness) {
+fn initialise_a_vector(b: &mut Bencher) {
     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::BenchHarness;
+use test::Bencher;
 
 #[bench]
-fn bench_xor_1000_ints(bh: &mut BenchHarness) {
-    bh.iter(|| {
+fn bench_xor_1000_ints(b: &mut Bencher) {
+    b.iter(|| {
             range(0, 1000).fold(0, |old, new| old ^ new);
         });
 }

branches/try2/src/doc/tutorial.md

@@ -1579,6 +1579,8 @@ 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);
@@ -1589,7 +1591,7 @@ let more_numbers: ~[int] = numbers;
 
 // The original `numbers` value can no longer be used, due to move semantics.
 
-let mut string = ~"fo";
+let mut string = StrBuf::from_str("fo");
 string.push_char('o');
 ~~~
 

branches/try2/src/libarena/lib.rs

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

branches/try2/src/libcollections/bitv.rs

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