---

yaml
---
r: 152443
b: refs/heads/try2
c: 4fecc50
h: refs/heads/master
i:
  152441: a0460f2
  152439: 40e94ef
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: 4fdc27e55ec9cda0ab5315701a96d25e720ce2c3
+refs/heads/try2: 4fecc503ee6f4fcd97d0d9421bfed279dd67ac6c
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/docs.mk

@@ -273,18 +273,14 @@ LIB_DOC_DEP_$(1) = \
 	$$(RSINPUTS_$(1)) \
 	$$(RUSTDOC_EXE) \
 	$$(foreach dep,$$(RUST_DEPS_$(1)), \
-		$$(TLIB2_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.$$(dep) \
-		doc/$$(dep)/)
+		$$(TLIB2_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.$$(dep))
 else
 LIB_DOC_DEP_$(1) = $$(CRATEFILE_$(1)) $$(RSINPUTS_$(1))
 endif
 
-doc/$(1)/:
-	$$(Q)mkdir -p $$@
-
 $(2) += doc/$(1)/index.html
 doc/$(1)/index.html: CFG_COMPILER_HOST_TRIPLE = $(CFG_TARGET)
-doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
+doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1))
 	@$$(call E, rustdoc $$@)
 	$$(Q)$$(RUSTDOC) --cfg dox --cfg stage2 $$<
 endef

branches/try2/src/compiletest/compiletest.rs

@@ -292,7 +292,6 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         save_metrics: config.save_metrics.clone(),
         test_shard: config.test_shard.clone(),
         nocapture: false,
-        color: test::AutoColor,
     }
 }
 

branches/try2/src/compiletest/procsrv.rs

@@ -11,7 +11,7 @@
 use std::os;
 use std::str;
 use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
-use std::dynamic_lib::DynamicLibrary;
+use std::unstable::dynamic_lib::DynamicLibrary;
 
 fn target_env(lib_path: &str, prog: &str) -> Vec<(String, String)> {
     let prog = if cfg!(windows) {prog.slice_to(prog.len() - 4)} else {prog};

branches/try2/src/liballoc/arc.rs

@@ -184,7 +184,7 @@ impl<T: Share + Send> Drop for Arc<T> {
 
         // This fence is needed to prevent reordering of use of the data and
         // deletion of the data. Because it is marked `Release`, the
-        // decreasing of the reference count synchronizes with this `Acquire`
+        // decreasing of the reference count sychronizes with this `Acquire`
         // fence. This means that use of the data happens before decreasing
         // the refernce count, which happens before this fence, which
         // happens before the deletion of the data.

branches/try2/src/libarena/lib.rs

@@ -81,8 +81,8 @@ 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>,
+    head: Chunk,
+    copy_head: Chunk,
     chunks: RefCell<Vec<Chunk>>,
 }
 
@@ -95,8 +95,8 @@ impl Arena {
     /// Allocate a new Arena with `initial_size` bytes preallocated.
     pub fn new_with_size(initial_size: uint) -> Arena {
         Arena {
-            head: RefCell::new(chunk(initial_size, false)),
-            copy_head: RefCell::new(chunk(initial_size, true)),
+            head: chunk(initial_size, false),
+            copy_head: chunk(initial_size, true),
             chunks: RefCell::new(Vec::new()),
         }
     }
@@ -114,7 +114,7 @@ fn chunk(size: uint, is_copy: bool) -> Chunk {
 impl Drop for Arena {
     fn drop(&mut self) {
         unsafe {
-            destroy_chunk(&*self.head.borrow());
+            destroy_chunk(&self.head);
             for chunk in self.chunks.borrow().iter() {
                 if !chunk.is_copy.get() {
                     destroy_chunk(chunk);
@@ -171,40 +171,38 @@ fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
 
 impl Arena {
     fn chunk_size(&self) -> uint {
-        self.copy_head.borrow().capacity()
+        self.copy_head.capacity()
     }
-
     // Functions for the POD part of the arena
-    fn alloc_copy_grow(&self, n_bytes: uint, align: uint) -> *u8 {
+    fn alloc_copy_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
         let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
-        self.chunks.borrow_mut().push(self.copy_head.borrow().clone());
-
-        *self.copy_head.borrow_mut() =
+        self.chunks.borrow_mut().push(self.copy_head.clone());
+        self.copy_head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
 
         return self.alloc_copy_inner(n_bytes, align);
     }
 
     #[inline]
-    fn alloc_copy_inner(&self, n_bytes: uint, align: uint) -> *u8 {
-        let start = round_up(self.copy_head.borrow().fill.get(), align);
-
-        let end = start + n_bytes;
-        if end > self.chunk_size() {
-            return self.alloc_copy_grow(n_bytes, align);
-        }
+    fn alloc_copy_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
+        unsafe {
+            let start = round_up(self.copy_head.fill.get(), align);
+            let end = start + n_bytes;
+            if end > self.chunk_size() {
+                return self.alloc_copy_grow(n_bytes, align);
+            }
+            self.copy_head.fill.set(end);
 
-        let copy_head = self.copy_head.borrow();
-        copy_head.fill.set(end);
+            //debug!("idx = {}, size = {}, align = {}, fill = {}",
+            //       start, n_bytes, align, head.fill.get());
 
-        unsafe {
-            copy_head.as_ptr().offset(start as int)
+            self.copy_head.as_ptr().offset(start as int)
         }
     }
 
     #[inline]
-    fn alloc_copy<'a, T>(&'a self, op: || -> T) -> &'a T {
+    fn alloc_copy<'a, T>(&'a mut self, op: || -> T) -> &'a T {
         unsafe {
             let ptr = self.alloc_copy_inner(mem::size_of::<T>(),
                                             mem::min_align_of::<T>());
@@ -215,48 +213,42 @@ impl Arena {
     }
 
     // Functions for the non-POD part of the arena
-    fn alloc_noncopy_grow(&self, n_bytes: uint, align: uint) -> (*u8, *u8) {
+    fn alloc_noncopy_grow(&mut self, n_bytes: uint, align: uint)
+                         -> (*u8, *u8) {
         // Allocate a new chunk.
         let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
-        self.chunks.borrow_mut().push(self.head.borrow().clone());
-
-        *self.head.borrow_mut() =
+        self.chunks.borrow_mut().push(self.head.clone());
+        self.head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
 
         return self.alloc_noncopy_inner(n_bytes, align);
     }
 
     #[inline]
-    fn alloc_noncopy_inner(&self, n_bytes: uint, align: uint) -> (*u8, *u8) {
-        // Be careful to not maintain any `head` borrows active, because
-        // `alloc_noncopy_grow` borrows it mutably.
-        let (start, end, tydesc_start, head_capacity) = {
-            let head = self.head.borrow();
-            let fill = head.fill.get();
-
-            let tydesc_start = fill;
-            let after_tydesc = fill + mem::size_of::<*TyDesc>();
+    fn alloc_noncopy_inner(&mut self, n_bytes: uint, align: uint)
+                          -> (*u8, *u8) {
+        unsafe {
+            let tydesc_start = self.head.fill.get();
+            let after_tydesc = self.head.fill.get() + mem::size_of::<*TyDesc>();
             let start = round_up(after_tydesc, align);
             let end = start + n_bytes;
 
-            (start, end, tydesc_start, head.capacity())
-        };
+            if end > self.head.capacity() {
+                return self.alloc_noncopy_grow(n_bytes, align);
+            }
 
-        if end > head_capacity {
-            return self.alloc_noncopy_grow(n_bytes, align);
-        }
+            self.head.fill.set(round_up(end, mem::align_of::<*TyDesc>()));
 
-        let head = self.head.borrow();
-        head.fill.set(round_up(end, mem::align_of::<*TyDesc>()));
+            //debug!("idx = {}, size = {}, align = {}, fill = {}",
+            //       start, n_bytes, align, head.fill);
 
-        unsafe {
-            let buf = head.as_ptr();
+            let buf = self.head.as_ptr();
             return (buf.offset(tydesc_start as int), buf.offset(start as int));
         }
     }
 
     #[inline]
-    fn alloc_noncopy<'a, T>(&'a self, op: || -> T) -> &'a T {
+    fn alloc_noncopy<'a, T>(&'a mut self, op: || -> T) -> &'a T {
         unsafe {
             let tydesc = get_tydesc::<T>();
             let (ty_ptr, ptr) =
@@ -282,10 +274,12 @@ impl Arena {
     #[inline]
     pub fn alloc<'a, T>(&'a self, op: || -> T) -> &'a T {
         unsafe {
+            // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
+            let this: &mut Arena = mem::transmute::<&_, &mut _>(self);
             if intrinsics::needs_drop::<T>() {
-                self.alloc_noncopy(op)
+                this.alloc_noncopy(op)
             } else {
-                self.alloc_copy(op)
+                this.alloc_copy(op)
             }
         }
     }
@@ -304,20 +298,6 @@ fn test_arena_destructors() {
     }
 }
 
-#[test]
-fn test_arena_alloc_nested() {
-    struct Inner { value: uint }
-    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() {
@@ -345,20 +325,19 @@ fn test_arena_destructors_fail() {
 /// run again for these objects.
 pub struct TypedArena<T> {
     /// A pointer to the next object to be allocated.
-    ptr: Cell<*T>,
+    ptr: *T,
 
     /// A pointer to the end of the allocated area. When this pointer is
     /// reached, a new chunk is allocated.
-    end: Cell<*T>,
+    end: *T,
 
     /// A pointer to the first arena segment.
-    first: RefCell<TypedArenaChunkRef<T>>,
+    first: Option<Box<TypedArenaChunk<T>>>,
 }
-type TypedArenaChunkRef<T> = Option<Box<TypedArenaChunk<T>>>;
 
 struct TypedArenaChunk<T> {
     /// Pointer to the next arena segment.
-    next: TypedArenaChunkRef<T>,
+    next: Option<Box<TypedArenaChunk<T>>>,
 
     /// The number of elements that this chunk can hold.
     capacity: uint,
@@ -444,52 +423,53 @@ impl<T> TypedArena<T> {
     pub fn with_capacity(capacity: uint) -> TypedArena<T> {
         let chunk = TypedArenaChunk::<T>::new(None, capacity);
         TypedArena {
-            ptr: Cell::new(chunk.start() as *T),
-            end: Cell::new(chunk.end() as *T),
-            first: RefCell::new(Some(chunk)),
+            ptr: chunk.start() as *T,
+            end: chunk.end() as *T,
+            first: Some(chunk),
         }
     }
 
     /// Allocates an object in the TypedArena, returning a reference to it.
     #[inline]
     pub fn alloc<'a>(&'a self, object: T) -> &'a T {
-        if self.ptr == self.end {
-            self.grow()
-        }
+        unsafe {
+            // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
+            let this: &mut TypedArena<T> = mem::transmute::<&_, &mut _>(self);
+            if this.ptr == this.end {
+                this.grow()
+            }
 
-        let ptr: &'a T = unsafe {
-            let ptr: &'a mut T = mem::transmute(self.ptr);
+            let ptr: &'a mut T = mem::transmute(this.ptr);
             ptr::write(ptr, object);
-            self.ptr.set(self.ptr.get().offset(1));
+            this.ptr = this.ptr.offset(1);
+            let ptr: &'a T = ptr;
             ptr
-        };
-
-        ptr
+        }
     }
 
     /// Grows the arena.
     #[inline(never)]
-    fn grow(&self) {
-        let chunk = self.first.borrow_mut().take_unwrap();
+    fn grow(&mut self) {
+        let chunk = self.first.take_unwrap();
         let new_capacity = chunk.capacity.checked_mul(&2).unwrap();
         let chunk = TypedArenaChunk::<T>::new(Some(chunk), new_capacity);
-        self.ptr.set(chunk.start() as *T);
-        self.end.set(chunk.end() as *T);
-        *self.first.borrow_mut() = Some(chunk)
+        self.ptr = chunk.start() as *T;
+        self.end = chunk.end() as *T;
+        self.first = Some(chunk)
     }
 }
 
 #[unsafe_destructor]
 impl<T> Drop for TypedArena<T> {
     fn drop(&mut self) {
         // Determine how much was filled.
-        let start = self.first.borrow().get_ref().start() as uint;
-        let end = self.ptr.get() as uint;
+        let start = self.first.get_ref().start() as uint;
+        let end = self.ptr as uint;
         let diff = (end - start) / mem::size_of::<T>();
 
         // Pass that to the `destroy` method.
         unsafe {
-            self.first.borrow_mut().get_mut_ref().destroy(diff)
+            self.first.get_mut_ref().destroy(diff)
         }
     }
 }

branches/try2/src/libcollections/bitv.rs

@@ -13,7 +13,6 @@
 use core::prelude::*;
 
 use core::cmp;
-use core::default::Default;
 use core::fmt;
 use core::iter::{Enumerate, Repeat, Map, Zip};
 use core::ops;
@@ -699,11 +698,6 @@ pub struct BitvSet {
     bitv: BigBitv
 }
 
-impl Default for BitvSet {
-    #[inline]
-    fn default() -> BitvSet { BitvSet::new() }
-}
-
 impl BitvSet {
     /// Creates a new bit vector set with initially no contents
     pub fn new() -> BitvSet {

branches/try2/src/libcollections/dlist.rs

@@ -24,7 +24,6 @@
 use core::prelude::*;
 
 use alloc::owned::Box;
-use core::default::Default;
 use core::fmt;
 use core::iter;
 use core::mem;
@@ -263,11 +262,6 @@ impl<T> Deque<T> for DList<T> {
     }
 }
 
-impl<T> Default for DList<T> {
-    #[inline]
-    fn default() -> DList<T> { DList::new() }
-}
-
 impl<T> DList<T> {
     /// Create an empty DList
     #[inline]