---

yaml
---
r: 120638
b: refs/heads/dist-snap
c: f7ccae5
h: refs/heads/master
v: v3

Author: aochagavia

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 43f942f88656f6b6cb2ff143e496a8875ea157ac
+refs/heads/dist-snap: f7ccae5f158cbbb7b910e59befb293e262d3dc1b
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcollections/lru_cache.rs

@@ -92,7 +92,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ mem::transmute(box mem::uninitialized::<LruEntry<K, V>>()) },
+            head: unsafe{ mem::transmute(box mem::uninit::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;

branches/dist-snap/src/libcore/mem.rs

@@ -26,7 +26,7 @@ pub fn size_of<T>() -> uint {
 
 /// Returns the size of the type that `_val` points to in bytes.
 #[inline]
-#[stable]
+#[unstable = "the name of this function may change slightly before stabilizing"]
 pub fn size_of_val<T>(_val: &T) -> uint {
     size_of::<T>()
 }
@@ -64,7 +64,7 @@ pub fn min_align_of<T>() -> uint {
 /// Returns the ABI-required minimum alignment of the type of the value that
 /// `_val` points to
 #[inline]
-#[stable]
+#[unstable = "the name of this function may change slightly before stabilizing"]
 pub fn min_align_of_val<T>(_val: &T) -> uint {
     min_align_of::<T>()
 }
@@ -90,7 +90,7 @@ pub fn align_of<T>() -> uint {
 /// as trait objects (in the future), returning the alignment for an arbitrary
 /// value at runtime.
 #[inline]
-#[stable]
+#[unstable = "the name of this function may change slightly before stabilizing"]
 pub fn align_of_val<T>(_val: &T) -> uint {
     align_of::<T>()
 }
@@ -117,7 +117,7 @@ pub fn pref_align_of_val<T>(val: &T) -> uint { align_of_val(val) }
 ///
 /// This is useful for FFI functions sometimes, but should generally be avoided.
 #[inline]
-#[stable]
+#[unstable = "the name of this function is subject to change"]
 pub unsafe fn zeroed<T>() -> T {
     intrinsics::init()
 }
@@ -136,14 +136,7 @@ pub unsafe fn init<T>() -> T { zeroed() }
 ///
 /// This is useful for FFI functions sometimes, but should generally be avoided.
 #[inline]
-#[stable]
-pub unsafe fn uninitialized<T>() -> T {
-    intrinsics::uninit()
-}
-
-/// Deprecated, use `uninitialized` instead.
-#[inline]
-#[deprecated = "this function has been renamed to `uninitialized`"]
+#[unstable = "the name of this function is subject to change"]
 pub unsafe fn uninit<T>() -> T {
     intrinsics::uninit()
 }
@@ -155,7 +148,7 @@ pub unsafe fn uninit<T>() -> T {
 /// contained at the location `dst`. This could leak allocations or resources,
 /// so care must be taken to previously deallocate the value at `dst`.
 #[inline]
-#[stable]
+#[unstable = "the name of this function is subject to change"]
 pub unsafe fn overwrite<T>(dst: *mut T, src: T) {
     intrinsics::move_val_init(&mut *dst, src)
 }
@@ -322,7 +315,7 @@ pub fn from_be64(x: u64) -> u64 { x }
 pub fn swap<T>(x: &mut T, y: &mut T) {
     unsafe {
         // Give ourselves some scratch space to work with
-        let mut t: T = uninitialized();
+        let mut t: T = uninit();
 
         // Perform the swap, `&mut` pointers never alias
         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);

branches/dist-snap/src/libcore/ptr.rs

@@ -196,7 +196,7 @@ pub unsafe fn copy_memory<T>(dst: *mut T, src: *T, count: uint) {
 /// fn swap<T>(x: &mut T, y: &mut T) {
 ///     unsafe {
 ///         // Give ourselves some scratch space to work with
-///         let mut t: T = mem::uninitialized();
+///         let mut t: T = mem::uninit();
 ///
 ///         // Perform the swap, `&mut` pointers never alias
 ///         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
@@ -239,7 +239,7 @@ pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
 #[inline]
 pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
     // Give ourselves some scratch space to work with
-    let mut tmp: T = mem::uninitialized();
+    let mut tmp: T = mem::uninit();
     let t: *mut T = &mut tmp;
 
     // Perform the swap
@@ -263,7 +263,7 @@ pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
 /// Reads the value from `*src` and returns it.
 #[inline(always)]
 pub unsafe fn read<T>(src: *T) -> T {
-    let mut tmp: T = mem::uninitialized();
+    let mut tmp: T = mem::uninit();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
 }

branches/dist-snap/src/libnative/io/file_unix.rs

@@ -164,7 +164,7 @@ impl rtio::RtioFileStream for FileDesc {
     }
 
     fn fstat(&mut self) -> IoResult<io::FileStat> {
-        let mut stat: libc::stat = unsafe { mem::zeroed() };
+        let mut stat: libc::stat = unsafe { mem::uninit() };
         match retry(|| unsafe { libc::fstat(self.fd(), &mut stat) }) {
             0 => Ok(mkstat(&stat)),
             _ => Err(super::last_error()),
@@ -509,15 +509,15 @@ fn mkstat(stat: &libc::stat) -> io::FileStat {
 }
 
 pub fn stat(p: &CString) -> IoResult<io::FileStat> {
-    let mut stat: libc::stat = unsafe { mem::zeroed() };
+    let mut stat: libc::stat = unsafe { mem::uninit() };
     match retry(|| unsafe { libc::stat(p.with_ref(|p| p), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),
     }
 }
 
 pub fn lstat(p: &CString) -> IoResult<io::FileStat> {
-    let mut stat: libc::stat = unsafe { mem::zeroed() };
+    let mut stat: libc::stat = unsafe { mem::uninit() };
     match retry(|| unsafe { libc::lstat(p.with_ref(|p| p), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),

branches/dist-snap/src/libnative/io/file_win32.rs

@@ -195,7 +195,7 @@ impl rtio::RtioFileStream for FileDesc {
     }
 
     fn fstat(&mut self) -> IoResult<io::FileStat> {
-        let mut stat: libc::stat = unsafe { mem::zeroed() };
+        let mut stat: libc::stat = unsafe { mem::uninit() };
         match unsafe { libc::fstat(self.fd(), &mut stat) } {
             0 => Ok(mkstat(&stat)),
             _ => Err(super::last_error()),
@@ -510,7 +510,7 @@ fn mkstat(stat: &libc::stat) -> io::FileStat {
 }
 
 pub fn stat(p: &CString) -> IoResult<io::FileStat> {
-    let mut stat: libc::stat = unsafe { mem::zeroed() };
+    let mut stat: libc::stat = unsafe { mem::uninit() };
     as_utf16_p(p.as_str().unwrap(), |up| {
         match unsafe { libc::wstat(up, &mut stat) } {
             0 => Ok(mkstat(&stat)),

branches/dist-snap/src/libregex_macros/lib.rs

@@ -254,8 +254,8 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
                 // The idea here is to avoid initializing threads that never
                 // need to be initialized, particularly for larger regexs with
                 // a lot of instructions.
-                queue: unsafe { ::std::mem::uninitialized() },
-                sparse: unsafe { ::std::mem::uninitialized() },
+                queue: unsafe { ::std::mem::uninit() },
+                sparse: unsafe { ::std::mem::uninit() },
                 size: 0,
             }
         }

branches/dist-snap/src/libserialize/serialize.rs

@@ -171,6 +171,10 @@ pub trait Decodable<D:Decoder<E>, E> {
     fn decode(d: &mut D) -> Result<Self, E>;
 }
 
+macro_rules! try ( ($e:expr) => (
+    match $e { Ok(v) => v, Err(e) => return Err(e) }
+))
+
 impl<E, S:Encoder<E>> Encodable<S, E> for uint {
     fn encode(&self, s: &mut S) -> Result<(), E> {
         s.emit_uint(*self)

branches/dist-snap/src/libstd/ascii.rs

@@ -39,15 +39,29 @@ impl Ascii {
         self.chr as char
     }
 
-    /// Convert to lowercase.
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `to_lowercase`"]
     pub fn to_lower(self) -> Ascii {
+        self.to_lowercase()
+    }
+
+    /// Convert to lowercase.
+    #[inline]
+    pub fn to_lowercase(self) -> Ascii {
         Ascii{chr: ASCII_LOWER_MAP[self.chr as uint]}
     }
 
-    /// Convert to uppercase.
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `to_uppercase`"]
     pub fn to_upper(self) -> Ascii {
+        self.to_uppercase()
+    }
+
+    /// Convert to uppercase.
+    #[inline]
+    pub fn to_uppercase(self) -> Ascii {
         Ascii{chr: ASCII_UPPER_MAP[self.chr as uint]}
     }
 
@@ -59,9 +73,16 @@ impl Ascii {
 
     // the following methods are like ctype, and the implementation is inspired by musl
 
-    /// Check if the character is a letter (a-z, A-Z)
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `is_alphabetic`"]
     pub fn is_alpha(&self) -> bool {
+        self.is_alphabetic()
+    }
+
+    /// Check if the character is a letter (a-z, A-Z)
+    #[inline]
+    pub fn is_alphabetic(&self) -> bool {
         (self.chr >= 0x41 && self.chr <= 0x5A) || (self.chr >= 0x61 && self.chr <= 0x7A)
     }
 
@@ -71,9 +92,16 @@ impl Ascii {
         self.chr >= 0x30 && self.chr <= 0x39
     }
 
-    /// Check if the character is a letter or number
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `is_alphanumeric`"]
     pub fn is_alnum(&self) -> bool {
+        self.is_alphanumeric()
+    }
+
+    /// Check if the character is a letter or number
+    #[inline]
+    pub fn is_alphanumeric(&self) -> bool {
         self.is_alpha() || self.is_digit()
     }
 
@@ -101,15 +129,29 @@ impl Ascii {
         (self.chr - 0x20) < 0x5F
     }
 
-    /// Checks if the character is lowercase
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `is_lowercase`"]
     pub fn is_lower(&self) -> bool {
+        self.is_lowercase()
+    }
+
+    /// Checks if the character is lowercase
+    #[inline]
+    pub fn is_lowercase(&self) -> bool {
         (self.chr - 'a' as u8) < 26
     }
 
-    /// Checks if the character is uppercase
     #[inline]
+    #[allow(missing_doc)]
+    #[deprecated="renamed to `is_uppercase`"]
     pub fn is_upper(&self) -> bool {
+        self.is_uppercase()
+    }
+
+    /// Checks if the character is uppercase
+    #[inline]
+    pub fn is_uppercase(&self) -> bool {
         (self.chr - 'A' as u8) < 26
     }
 

branches/dist-snap/src/libstd/c_str.rs

@@ -377,7 +377,7 @@ impl<'a> ToCStr for &'a [u8] {
 // Unsafe function that handles possibly copying the &[u8] into a stack array.
 unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T {
     if v.len() < BUF_LEN {
-        let mut buf: [u8, .. BUF_LEN] = mem::uninitialized();
+        let mut buf: [u8, .. BUF_LEN] = mem::uninit();
         slice::bytes::copy_memory(buf, v);
         buf[v.len()] = 0;
 

branches/dist-snap/src/libstd/comm/mod.rs

@@ -600,22 +600,20 @@ impl<T: Send> Clone for Sender<T> {
         let (packet, sleeper) = match *unsafe { self.inner() } {
             Oneshot(ref p) => {
                 let a = Arc::new(Unsafe::new(shared::Packet::new()));
-                unsafe {
-                    (*a.get()).postinit_lock();
-                    match (*p.get()).upgrade(Receiver::new(Shared(a.clone()))) {
-                        oneshot::UpSuccess | oneshot::UpDisconnected => (a, None),
-                        oneshot::UpWoke(task) => (a, Some(task))
-                    }
+                match unsafe {
+                    (*p.get()).upgrade(Receiver::new(Shared(a.clone())))
+                } {
+                    oneshot::UpSuccess | oneshot::UpDisconnected => (a, None),
+                    oneshot::UpWoke(task) => (a, Some(task))
                 }
             }
             Stream(ref p) => {
                 let a = Arc::new(Unsafe::new(shared::Packet::new()));
-                unsafe {
-                    (*a.get()).postinit_lock();
-                    match (*p.get()).upgrade(Receiver::new(Shared(a.clone()))) {
-                        stream::UpSuccess | stream::UpDisconnected => (a, None),
-                        stream::UpWoke(task) => (a, Some(task)),
-                    }
+                match unsafe {
+                    (*p.get()).upgrade(Receiver::new(Shared(a.clone())))
+                } {
+                    stream::UpSuccess | stream::UpDisconnected => (a, None),
+                    stream::UpWoke(task) => (a, Some(task)),
                 }
             }
             Shared(ref p) => {

branches/dist-snap/src/libstd/comm/shared.rs

@@ -66,8 +66,7 @@ pub enum Failure {
 }
 
 impl<T: Send> Packet<T> {
-    // Creation of a packet *must* be followed by a call to postinit_lock
-    // and later by inherit_blocker
+    // Creation of a packet *must* be followed by a call to inherit_blocker
     pub fn new() -> Packet<T> {
         let p = Packet {
             queue: mpsc::Queue::new(),
@@ -79,18 +78,11 @@ impl<T: Send> Packet<T> {
             sender_drain: atomics::AtomicInt::new(0),
             select_lock: unsafe { NativeMutex::new() },
         };
+        // see comments in inherit_blocker about why we grab this lock
+        unsafe { p.select_lock.lock_noguard() }
         return p;
     }
 
-    // This function should be used after newly created Packet
-    // was wrapped with an Arc
-    // In other case mutex data will be duplicated while clonning
-    // and that could cause problems on platforms where it is
-    // represented by opaque data structure
-    pub fn postinit_lock(&mut self) {
-        unsafe { self.select_lock.lock_noguard() }
-    }
-
     // This function is used at the creation of a shared packet to inherit a
     // previously blocked task. This is done to prevent spurious wakeups of
     // tasks in select().

branches/dist-snap/src/libstd/os.rs

@@ -969,7 +969,7 @@ pub fn page_size() -> uint {
 pub fn page_size() -> uint {
     use mem;
     unsafe {
-        let mut info = mem::zeroed();
+        let mut info = mem::uninit();
         libc::GetSystemInfo(&mut info);
 
         return info.dwPageSize as uint;
@@ -1288,7 +1288,7 @@ impl MemoryMap {
     pub fn granularity() -> uint {
         use mem;
         unsafe {
-            let mut info = mem::zeroed();
+            let mut info = mem::uninit();
             libc::GetSystemInfo(&mut info);
 
             return info.dwAllocationGranularity as uint;

branches/dist-snap/src/libstd/rt/thread.rs

@@ -227,8 +227,8 @@ mod imp {
     pub type rust_thread_return = *u8;
 
     pub unsafe fn create(stack: uint, p: Box<proc():Send>) -> rust_thread {
-        let mut native: libc::pthread_t = mem::zeroed();
-        let mut attr: libc::pthread_attr_t = mem::zeroed();
+        let mut native: libc::pthread_t = mem::uninit();
+        let mut attr: libc::pthread_attr_t = mem::uninit();
         assert_eq!(pthread_attr_init(&mut attr), 0);
         assert_eq!(pthread_attr_setdetachstate(&mut attr,
                                                PTHREAD_CREATE_JOINABLE), 0);