---

yaml
---
r: 180174
b: refs/heads/tmp
c: 2f48651
h: refs/heads/master
v: v3

Author: nagisa

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 5bcf2a921287cc9a07c413cfaae56ee349a305e1
+refs/heads/tmp: 2f486511112afcfe6894d16fd1c5e7eec38ebc6c

branches/tmp/src/doc/reference.md

@@ -3196,7 +3196,6 @@ stands for a *single* data field, whereas a wildcard `..` stands for *all* the
 fields of a particular variant. For example:
 
 ```
-#![feature(box_patterns)]
 #![feature(box_syntax)]
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
@@ -3260,7 +3259,6 @@ the inside of the match.
 An example of a `match` expression:
 
 ```
-#![feature(box_patterns)]
 #![feature(box_syntax)]
 # fn process_pair(a: i32, b: i32) { }
 # fn process_ten() { }
@@ -3296,7 +3294,6 @@ Subpatterns can also be bound to variables by the use of the syntax `variable @
 subpattern`. For example:
 
 ```
-#![feature(box_patterns)]
 #![feature(box_syntax)]
 
 enum List { Nil, Cons(uint, Box<List>) }

branches/tmp/src/libarena/lib.rs

@@ -42,7 +42,6 @@ use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
-use std::marker;
 use std::mem;
 use std::num::{Int, UnsignedInt};
 use std::ptr;
@@ -89,29 +88,27 @@ impl Chunk {
 /// than objects without destructors. This reduces overhead when initializing
 /// plain-old-data (`Copy` types) and means we don't need to waste time running
 /// their destructors.
-pub struct Arena<'longer_than_self> {
+pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to access the
     // head.
     head: RefCell<Chunk>,
     copy_head: RefCell<Chunk>,
     chunks: RefCell<Vec<Chunk>>,
-    _invariant: marker::InvariantLifetime<'longer_than_self>,
 }
 
-impl<'a> Arena<'a> {
+impl Arena {
     /// Allocates a new Arena with 32 bytes preallocated.
-    pub fn new() -> Arena<'a> {
+    pub fn new() -> Arena {
         Arena::new_with_size(32)
     }
 
     /// Allocates a new Arena with `initial_size` bytes preallocated.
-    pub fn new_with_size(initial_size: usize) -> Arena<'a> {
+    pub fn new_with_size(initial_size: usize) -> Arena {
         Arena {
             head: RefCell::new(chunk(initial_size, false)),
             copy_head: RefCell::new(chunk(initial_size, true)),
             chunks: RefCell::new(Vec::new()),
-            _invariant: marker::InvariantLifetime,
         }
     }
 }
@@ -125,7 +122,7 @@ fn chunk(size: usize, is_copy: bool) -> Chunk {
 }
 
 #[unsafe_destructor]
-impl<'longer_than_self> Drop for Arena<'longer_than_self> {
+impl Drop for Arena {
     fn drop(&mut self) {
         unsafe {
             destroy_chunk(&*self.head.borrow());
@@ -183,7 +180,7 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) {
     ((p & !1) as *const TyDesc, p & 1 == 1)
 }
 
-impl<'longer_than_self> Arena<'longer_than_self> {
+impl Arena {
     fn chunk_size(&self) -> usize {
         self.copy_head.borrow().capacity()
     }
@@ -296,7 +293,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
     /// Allocates a new item in the arena, using `op` to initialize the value,
     /// and returns a reference to it.
     #[inline]
-    pub fn alloc<T:'longer_than_self, F>(&self, op: F) -> &mut T where F: FnOnce() -> T {
+    pub fn alloc<T, F>(&self, op: F) -> &mut T where F: FnOnce() -> T {
         unsafe {
             if intrinsics::needs_drop::<T>() {
                 self.alloc_noncopy(op)
@@ -320,6 +317,20 @@ fn test_arena_destructors() {
     }
 }
 
+#[test]
+fn test_arena_alloc_nested() {
+    struct Inner { value: usize }
+    struct Outer<'a> { inner: &'a Inner }
+
+    let arena = Arena::new();
+
+    let result = arena.alloc(|| Outer {
+        inner: arena.alloc(|| Inner { value: 10 })
+    });
+
+    assert_eq!(result.inner.value, 10);
+}
+
 #[test]
 #[should_fail]
 fn test_arena_destructors_fail() {
@@ -354,10 +365,6 @@ pub struct TypedArena<T> {
 
     /// A pointer to the first arena segment.
     first: RefCell<*mut TypedArenaChunk<T>>,
-
-    /// Marker indicating that dropping the arena causes its owned
-    /// instances of `T` to be dropped.
-    _own: marker::PhantomData<T>,
 }
 
 struct TypedArenaChunk<T> {
@@ -453,7 +460,6 @@ impl<T> TypedArena<T> {
                 ptr: Cell::new((*chunk).start() as *const T),
                 end: Cell::new((*chunk).end() as *const T),
                 first: RefCell::new(chunk),
-                _own: marker::PhantomData,
             }
         }
     }
@@ -517,41 +523,6 @@ mod tests {
         z: i32,
     }
 
-    #[test]
-    fn test_arena_alloc_nested() {
-        struct Inner { value: u8 }
-        struct Outer<'a> { inner: &'a Inner }
-        enum EI<'e> { I(Inner), O(Outer<'e>) }
-
-        struct Wrap<'a>(TypedArena<EI<'a>>);
-
-        impl<'a> Wrap<'a> {
-            fn alloc_inner<F:Fn() -> Inner>(&self, f: F) -> &Inner {
-                let r: &EI = self.0.alloc(EI::I(f()));
-                if let &EI::I(ref i) = r {
-                    i
-                } else {
-                    panic!("mismatch");
-                }
-            }
-            fn alloc_outer<F:Fn() -> Outer<'a>>(&self, f: F) -> &Outer {
-                let r: &EI = self.0.alloc(EI::O(f()));
-                if let &EI::O(ref o) = r {
-                    o
-                } else {
-                    panic!("mismatch");
-                }
-            }
-        }
-
-        let arena = Wrap(TypedArena::new());
-
-        let result = arena.alloc_outer(|| Outer {
-            inner: arena.alloc_inner(|| Inner { value: 10 }) });
-
-        assert_eq!(result.inner.value, 10);
-    }
-
     #[test]
     pub fn test_copy() {
         let arena = TypedArena::new();

branches/tmp/src/libcollections/bench.rs

@@ -8,113 +8,103 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-macro_rules! map_insert_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut ::test::Bencher) {
-            use std::rand;
-            use std::rand::Rng;
-            use test::black_box;
-
-            let n: usize = $n;
-            let mut map = $map::new();
-            // setup
-            let mut rng = rand::weak_rng();
-
-            for _ in 0..n {
-                let i = rng.gen() % n;
-                map.insert(i, i);
-            }
-
-            // measure
-            b.iter(|| {
-                let k = rng.gen() % n;
-                map.insert(k, k);
-                map.remove(&k);
-            });
-            black_box(map);
-        }
-    )
+use prelude::*;
+use std::rand;
+use std::rand::Rng;
+use test::{Bencher, black_box};
+
+pub fn insert_rand_n<M, I, R>(n: usize,
+                              map: &mut M,
+                              b: &mut Bencher,
+                              mut insert: I,
+                              mut remove: R) where
+    I: FnMut(&mut M, usize),
+    R: FnMut(&mut M, usize),
+{
+    // setup
+    let mut rng = rand::weak_rng();
+
+    for _ in 0..n {
+        insert(map, rng.gen::<usize>() % n);
+    }
+
+    // measure
+    b.iter(|| {
+        let k = rng.gen::<usize>() % n;
+        insert(map, k);
+        remove(map, k);
+    });
+    black_box(map);
 }
 
-macro_rules! map_insert_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut ::test::Bencher) {
-            use test::black_box;
-
-            let mut map = $map::new();
-            let n: usize = $n;
-            // setup
-            for i in 0..n {
-                map.insert(i * 2, i * 2);
-            }
-
-            // measure
-            let mut i = 1;
-            b.iter(|| {
-                map.insert(i, i);
-                map.remove(&i);
-                i = (i + 2) % n;
-            });
-            black_box(map);
-        }
-    )
+pub fn insert_seq_n<M, I, R>(n: usize,
+                             map: &mut M,
+                             b: &mut Bencher,
+                             mut insert: I,
+                             mut remove: R) where
+    I: FnMut(&mut M, usize),
+    R: FnMut(&mut M, usize),
+{
+    // setup
+    for i in 0..n {
+        insert(map, i * 2);
+    }
+
+    // measure
+    let mut i = 1;
+    b.iter(|| {
+        insert(map, i);
+        remove(map, i);
+        i = (i + 2) % n;
+    });
+    black_box(map);
 }
 
-macro_rules! map_find_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut ::test::Bencher) {
-            use std::rand;
-            use std::rand::Rng;
-            use test::black_box;
-
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            let mut rng = rand::weak_rng();
-            let mut keys: Vec<_> = (0..n).map(|_| rng.gen() % n).collect();
-
-            for &k in &keys {
-                map.insert(k, k);
-            }
-
-            rng.shuffle(&mut keys);
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let t = map.get(&keys[i]);
-                i = (i + 1) % n;
-                black_box(t);
-            })
-        }
-    )
+pub fn find_rand_n<M, T, I, F>(n: usize,
+                               map: &mut M,
+                               b: &mut Bencher,
+                               mut insert: I,
+                               mut find: F) where
+    I: FnMut(&mut M, usize),
+    F: FnMut(&M, usize) -> T,
+{
+    // setup
+    let mut rng = rand::weak_rng();
+    let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
+
+    for k in &keys {
+        insert(map, *k);
+    }
+
+    rng.shuffle(&mut keys);
+
+    // measure
+    let mut i = 0;
+    b.iter(|| {
+        let t = find(map, keys[i]);
+        i = (i + 1) % n;
+        black_box(t);
+    })
 }
 
-macro_rules! map_find_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut ::test::Bencher) {
-            use test::black_box;
-
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            for i in 0..n {
-                map.insert(i, i);
-            }
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let x = map.get(&i);
-                i = (i + 1) % n;
-                black_box(x);
-            })
-        }
-    )
+pub fn find_seq_n<M, T, I, F>(n: usize,
+                              map: &mut M,
+                              b: &mut Bencher,
+                              mut insert: I,
+                              mut find: F) where
+    I: FnMut(&mut M, usize),
+    F: FnMut(&M, usize) -> T,
+{
+    // setup
+    for i in 0..n {
+        insert(map, i);
+    }
+
+    // measure
+    let mut i = 0;
+    b.iter(|| {
+        let x = find(map, i);
+        i = (i + 1) % n;
+        black_box(x);
+    })
 }