---

yaml
---
r: 130619
b: refs/heads/snap-stage3
c: c6633fd
h: refs/heads/master
i:
  130617: 2df4007
  130615: 0590e4d
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: ee72e46638f2b2ae92e99df2a7ea92690baa0d07
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ab7b1c896d5d929f3e150bf62c69b1459427a538
+refs/heads/snap-stage3: c6633fde5302be357014c9aa14461857d99d0075
 refs/heads/try: a2473a89da106f7dd3be86e9d52fe23f43d5bfa5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide.md

@@ -116,7 +116,7 @@ but also working properly. And printing information to the screen is a pretty
 common thing to do.
 
 The first thing that we need to do is make a file to put our code in. I like
-to make a `projects` directory in my home directory, and keep all my projects
+to make a projects directory in my home directory, and keep all my projects
 there. Rust does not care where your code lives.
 
 This actually leads to one other concern we should address: this tutorial will
@@ -765,7 +765,7 @@ This is a deliberate design decision. While full-program inference is possible,
 languages which have it, like Haskell, often suggest that documenting your
 types explicitly is a best-practice. We agree that forcing functions to declare
 types while allowing for inference inside of function bodies is a wonderful
-sweet spot between full inference and no inference.
+compromise between full inference and no inference.
 
 What about returning a value? Here's a function that adds one to an integer:
 

branches/snap-stage3/src/liballoc/heap.rs

@@ -14,7 +14,7 @@
 
 use core::ptr::RawPtr;
 #[cfg(not(test))] use core::raw;
-#[cfg(stage0, not(test))] use util;
+#[cfg(not(test))] use util;
 
 /// Returns a pointer to `size` bytes of memory.
 ///
@@ -119,7 +119,7 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
 }
 
 // FIXME: #7496
-#[cfg(stage0, not(test))]
+#[cfg(not(test))]
 #[lang="closure_exchange_malloc"]
 #[inline]
 #[allow(deprecated)]
@@ -134,21 +134,6 @@ unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
     alloc as *mut u8
 }
 
-// FIXME: #7496
-#[cfg(not(stage0), not(test))]
-#[lang="closure_exchange_malloc"]
-#[inline]
-#[allow(deprecated)]
-unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
-                                  align: uint) -> *mut u8 {
-    let p = allocate(size, align);
-
-    let alloc = p as *mut raw::Box<()>;
-    (*alloc).drop_glue = drop_glue;
-
-    alloc as *mut u8
-}
-
 #[cfg(jemalloc)]
 mod imp {
     use core::option::{None, Option};

branches/snap-stage3/src/libarena/lib.rs

@@ -39,18 +39,17 @@ use std::mem;
 use std::num;
 use std::ptr;
 use std::rc::Rc;
-use std::rt::heap::{allocate, deallocate};
+use std::rt::heap::allocate;
 
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
 // will always stay at 0.
 #[deriving(Clone, PartialEq)]
 struct Chunk {
-    data: Rc<RefCell<Vec<u8>>>,
+    data: Rc<RefCell<Vec<u8> >>,
     fill: Cell<uint>,
     is_copy: Cell<bool>,
 }
-
 impl Chunk {
     fn capacity(&self) -> uint {
         self.data.borrow().capacity()
@@ -358,37 +357,38 @@ pub struct TypedArena<T> {
     end: Cell<*const T>,
 
     /// A pointer to the first arena segment.
-    first: RefCell<*mut TypedArenaChunk<T>>,
+    first: RefCell<TypedArenaChunkRef<T>>,
 }
+type TypedArenaChunkRef<T> = Option<Box<TypedArenaChunk<T>>>;
 
 struct TypedArenaChunk<T> {
     /// Pointer to the next arena segment.
-    next: *mut TypedArenaChunk<T>,
+    next: TypedArenaChunkRef<T>,
 
     /// The number of elements that this chunk can hold.
     capacity: uint,
 
     // Objects follow here, suitably aligned.
 }
 
-fn calculate_size<T>(capacity: uint) -> uint {
-    let mut size = mem::size_of::<TypedArenaChunk<T>>();
-    size = round_up(size, mem::min_align_of::<T>());
-    let elem_size = mem::size_of::<T>();
-    let elems_size = elem_size.checked_mul(&capacity).unwrap();
-    size = size.checked_add(&elems_size).unwrap();
-    size
-}
-
 impl<T> TypedArenaChunk<T> {
     #[inline]
-    unsafe fn new(next: *mut TypedArenaChunk<T>, capacity: uint)
-           -> *mut TypedArenaChunk<T> {
-        let size = calculate_size::<T>(capacity);
-        let chunk = allocate(size, mem::min_align_of::<TypedArenaChunk<T>>())
-                    as *mut TypedArenaChunk<T>;
-        (*chunk).next = next;
-        (*chunk).capacity = capacity;
+    fn new(next: Option<Box<TypedArenaChunk<T>>>, capacity: uint)
+           -> Box<TypedArenaChunk<T>> {
+        let mut size = mem::size_of::<TypedArenaChunk<T>>();
+        size = round_up(size, mem::min_align_of::<T>());
+        let elem_size = mem::size_of::<T>();
+        let elems_size = elem_size.checked_mul(&capacity).unwrap();
+        size = size.checked_add(&elems_size).unwrap();
+
+        let mut chunk = unsafe {
+            let chunk = allocate(size, mem::min_align_of::<TypedArenaChunk<T>>());
+            let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
+            ptr::write(&mut chunk.next, next);
+            chunk
+        };
+
+        chunk.capacity = capacity;
         chunk
     }
 
@@ -406,13 +406,14 @@ impl<T> TypedArenaChunk<T> {
         }
 
         // Destroy the next chunk.
-        let next = self.next;
-        let size = calculate_size::<T>(self.capacity);
-        deallocate(self as *mut TypedArenaChunk<T> as *mut u8, size,
-                   mem::min_align_of::<TypedArenaChunk<T>>());
-        if next.is_not_null() {
-            let capacity = (*next).capacity;
-            (*next).destroy(capacity);
+        let next_opt = mem::replace(&mut self.next, None);
+        match next_opt {
+            None => {}
+            Some(mut next) => {
+                // We assume that the next chunk is completely filled.
+                let capacity = next.capacity;
+                next.destroy(capacity)
+            }
         }
     }
 
@@ -447,13 +448,11 @@ impl<T> TypedArena<T> {
     /// objects.
     #[inline]
     pub fn with_capacity(capacity: uint) -> TypedArena<T> {
-        unsafe {
-            let chunk = TypedArenaChunk::<T>::new(ptr::mut_null(), capacity);
-            TypedArena {
-                ptr: Cell::new((*chunk).start() as *const T),
-                end: Cell::new((*chunk).end() as *const T),
-                first: RefCell::new(chunk),
-            }
+        let chunk = TypedArenaChunk::<T>::new(None, capacity);
+        TypedArena {
+            ptr: Cell::new(chunk.start() as *const T),
+            end: Cell::new(chunk.end() as *const T),
+            first: RefCell::new(Some(chunk)),
         }
     }
 
@@ -477,28 +476,26 @@ impl<T> TypedArena<T> {
     /// Grows the arena.
     #[inline(never)]
     fn grow(&self) {
-        unsafe {
-            let chunk = *self.first.borrow_mut();
-            let new_capacity = (*chunk).capacity.checked_mul(&2).unwrap();
-            let chunk = TypedArenaChunk::<T>::new(chunk, new_capacity);
-            self.ptr.set((*chunk).start() as *const T);
-            self.end.set((*chunk).end() as *const T);
-            *self.first.borrow_mut() = chunk
-        }
+        let chunk = self.first.borrow_mut().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 *const T);
+        self.end.set(chunk.end() as *const T);
+        *self.first.borrow_mut() = Some(chunk)
     }
 }
 
 #[unsafe_destructor]
 impl<T> Drop for TypedArena<T> {
     fn drop(&mut self) {
-        unsafe {
-            // Determine how much was filled.
-            let start = self.first.borrow().as_ref().unwrap().start() as uint;
-            let end = self.ptr.get() as uint;
-            let diff = (end - start) / mem::size_of::<T>();
+        // Determine how much was filled.
+        let start = self.first.borrow().as_ref().unwrap().start() as uint;
+        let end = self.ptr.get() as uint;
+        let diff = (end - start) / mem::size_of::<T>();
 
-            // Pass that to the `destroy` method.
-            (**self.first.borrow_mut()).destroy(diff)
+        // Pass that to the `destroy` method.
+        unsafe {
+            self.first.borrow_mut().as_mut().unwrap().destroy(diff)
         }
     }
 }

branches/snap-stage3/src/libcore/num/mod.rs

@@ -406,7 +406,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.count_ones(), 3);
     /// ```
-    fn count_ones(self) -> uint;
+    fn count_ones(self) -> Self;
 
     /// Returns the number of zeros in the binary representation of the integer.
     ///
@@ -418,7 +418,7 @@ pub trait Int: Primitive
     /// assert_eq!(n.count_zeros(), 5);
     /// ```
     #[inline]
-    fn count_zeros(self) -> uint {
+    fn count_zeros(self) -> Self {
         (!self).count_ones()
     }
 
@@ -432,7 +432,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.leading_zeros(), 10);
     /// ```
-    fn leading_zeros(self) -> uint;
+    fn leading_zeros(self) -> Self;
 
     /// Returns the number of trailing zeros in the binary representation
     /// of the integer.
@@ -444,7 +444,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.trailing_zeros(), 3);
     /// ```
-    fn trailing_zeros(self) -> uint;
+    fn trailing_zeros(self) -> Self;
 
     /// Shifts the bits to the left by a specified amount amount, `n`, wrapping
     /// the truncated bits to the end of the resulting integer.
@@ -569,13 +569,13 @@ macro_rules! int_impl {
     ($T:ty, $BITS:expr, $ctpop:path, $ctlz:path, $cttz:path, $bswap:path) => {
         impl Int for $T {
             #[inline]
-            fn count_ones(self) -> uint { unsafe { $ctpop(self) as uint } }
+            fn count_ones(self) -> $T { unsafe { $ctpop(self) } }
 
             #[inline]
-            fn leading_zeros(self) -> uint { unsafe { $ctlz(self) as uint } }
+            fn leading_zeros(self) -> $T { unsafe { $ctlz(self) } }
 
             #[inline]
-            fn trailing_zeros(self) -> uint { unsafe { $cttz(self) as uint } }
+            fn trailing_zeros(self) -> $T { unsafe { $cttz(self) } }
 
             #[inline]
             fn rotate_left(self, n: uint) -> $T {
@@ -629,13 +629,13 @@ macro_rules! int_cast_impl {
     ($T:ty, $U:ty) => {
         impl Int for $T {
             #[inline]
-            fn count_ones(self) -> uint { (self as $U).count_ones() }
+            fn count_ones(self) -> $T { (self as $U).count_ones() as $T }
 
             #[inline]
-            fn leading_zeros(self) -> uint { (self as $U).leading_zeros() }
+            fn leading_zeros(self) -> $T { (self as $U).leading_zeros() as $T }
 
             #[inline]
-            fn trailing_zeros(self) -> uint { (self as $U).trailing_zeros() }
+            fn trailing_zeros(self) -> $T { (self as $U).trailing_zeros() as $T }
 
             #[inline]
             fn rotate_left(self, n: uint) -> $T { (self as $U).rotate_left(n) as $T }

branches/snap-stage3/src/libcore/slice.rs

@@ -806,12 +806,7 @@ impl<'a,T> MutableSlice<'a, T> for &'a mut [T] {
         let mut i: uint = 0;
         let ln = self.len();
         while i < ln / 2 {
-            // Unsafe swap to avoid the bounds check in safe swap.
-            unsafe {
-                let pa: *mut T = self.unsafe_mut_ref(i);
-                let pb: *mut T = self.unsafe_mut_ref(ln - i - 1);
-                ptr::swap(pa, pb);
-            }
+            self.swap(i, ln - i - 1);
             i += 1;
         }
     }

branches/snap-stage3/src/libcoretest/num/int_macros.rs

@@ -95,9 +95,9 @@ mod tests {
 
     #[test]
     fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS - 3);
-        assert!(B.count_zeros() == BITS - 2);
-        assert!(C.count_zeros() == BITS - 5);
+        assert!(A.count_zeros() == BITS as $T - 3);
+        assert!(B.count_zeros() == BITS as $T - 2);
+        assert!(C.count_zeros() == BITS as $T - 5);
     }
 
     #[test]

branches/snap-stage3/src/libcoretest/num/uint_macros.rs

@@ -55,9 +55,9 @@ mod tests {
 
     #[test]
     fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS - 3);
-        assert!(B.count_zeros() == BITS - 2);
-        assert!(C.count_zeros() == BITS - 5);
+        assert!(A.count_zeros() == BITS as $T - 3);
+        assert!(B.count_zeros() == BITS as $T - 2);
+        assert!(C.count_zeros() == BITS as $T - 5);
     }
 
     #[test]

branches/snap-stage3/src/liblibc/lib.rs

@@ -249,7 +249,7 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(windows)] pub use types::os::arch::extra::{LARGE_INTEGER, LPVOID, LONG};
 #[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED, LPCWSTR};
 #[cfg(windows)] pub use types::os::arch::extra::{LPOVERLAPPED, SIZE_T, LPDWORD};
-#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES, WIN32_FIND_DATAW};
+#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES};
 #[cfg(windows)] pub use funcs::c95::string::{wcslen};
 #[cfg(windows)] pub use funcs::posix88::stat_::{wstat, wutime, wchmod, wrmdir};
 #[cfg(windows)] pub use funcs::bsd43::{closesocket};
@@ -1638,22 +1638,6 @@ pub mod types {
                 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
 
                 pub type GROUP = c_uint;
-
-                #[repr(C)]
-                pub struct WIN32_FIND_DATAW {
-                    pub dwFileAttributes: DWORD,
-                    pub ftCreationTime: FILETIME,
-                    pub ftLastAccessTime: FILETIME,
-                    pub ftLastWriteTime: FILETIME,
-                    pub nFileSizeHigh: DWORD,
-                    pub nFileSizeLow: DWORD,
-                    pub dwReserved0: DWORD,
-                    pub dwReserved1: DWORD,
-                    pub cFileName: [wchar_t, ..260], // #define MAX_PATH 260
-                    pub cAlternateFileName: [wchar_t, ..14],
-                }
-
-                pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW;
             }
         }
     }
@@ -4779,7 +4763,7 @@ pub mod funcs {
                                                LPMEMORY_BASIC_INFORMATION,
                                                LPSYSTEM_INFO, HANDLE, LPHANDLE,
                                                LARGE_INTEGER, PLARGE_INTEGER,
-                                               LPFILETIME, LPWIN32_FIND_DATAW};
+                                               LPFILETIME};
 
             extern "system" {
                 pub fn GetEnvironmentVariableW(n: LPCWSTR,
@@ -4809,9 +4793,9 @@ pub mod funcs {
                                             -> DWORD;
                 pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
                 pub fn GetLastError() -> DWORD;
-                pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW)
+                pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: HANDLE)
                                       -> HANDLE;
-                pub fn FindNextFileW(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW)
+                pub fn FindNextFileW(findFile: HANDLE, findFileData: HANDLE)
                                      -> BOOL;
                 pub fn FindClose(findFile: HANDLE) -> BOOL;
                 pub fn DuplicateHandle(hSourceProcessHandle: HANDLE,