---

yaml
---
r: 180182
b: refs/heads/tmp
c: f9a1087
h: refs/heads/master
v: v3

Author: pnkfelix

[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: 9492275106dd4d564a036517ff4726feacaf0720
+refs/heads/tmp: f9a1087f2730ab021d5356a5df703baeccffc020

branches/tmp/mk/docs.mk

@@ -87,7 +87,7 @@ endif
 
 # Check for xelatex
 
-ifneq ($(CFG_XELATEX),)
+ifeq ($(CFG_XELATEX),)
     CFG_LATEX := $(CFG_XELATEX)
     XELATEX = 1
   else

branches/tmp/src/compiletest/compiletest.rs

@@ -14,6 +14,7 @@
 #![feature(collections)]
 #![feature(int_uint)]
 #![feature(io)]
+#![feature(os)]
 #![feature(path)]
 #![feature(rustc_private)]
 #![feature(slicing_syntax, unboxed_closures)]
@@ -47,7 +48,8 @@ pub mod common;
 pub mod errors;
 
 pub fn main() {
-    let config = parse_config(env::args().collect());
+    let args = env::args().map(|s| s.into_string().unwrap()).collect();;
+    let config = parse_config(args);
 
     if config.valgrind_path.is_none() && config.force_valgrind {
         panic!("Can't find Valgrind to run Valgrind tests");

branches/tmp/src/compiletest/util.rs

@@ -40,7 +40,7 @@ pub fn make_new_path(path: &str) -> String {
 
     // Windows just uses PATH as the library search path, so we have to
     // maintain the current value while adding our own
-    match env::var(lib_path_env_var()) {
+    match env::var_string(lib_path_env_var()) {
       Ok(curr) => {
         format!("{}{}{}", path, path_div(), curr)
       }

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/liballoc/lib.rs

@@ -71,6 +71,7 @@
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]
 #![feature(unboxed_closures)]
+#![feature(unsafe_no_drop_flag)]
 #![feature(core)]
 #![feature(hash)]
 #![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")),

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();