---

yaml
---
r: 106997
b: refs/heads/try
c: 0b714b4
h: refs/heads/master
i:
  106995: 584b056
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b8ef9fd9c9f642ce7b8aed82782a1ed745d08d64
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b8601a3d8b91ad3b653d143307611f2f5c75617e
-refs/heads/try: a0f943cd3a653064f8e25e408b6bf02e81bb4a1b
+refs/heads/try: 0b714b4ba6411c6997324d442a3df602e5920ff5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libstd/rc.rs

@@ -24,20 +24,18 @@ pointers, and then storing the parent pointers as `Weak` pointers.
 */
 
 use cast::transmute;
-use cell::Cell;
 use clone::Clone;
 use cmp::{Eq, Ord};
 use kinds::marker;
 use ops::{Deref, Drop};
 use option::{Option, Some, None};
 use ptr;
-use ptr::RawPtr;
 use rt::global_heap::exchange_free;
 
 struct RcBox<T> {
     value: T,
-    strong: Cell<uint>,
-    weak: Cell<uint>
+    strong: uint,
+    weak: uint
 }
 
 /// Immutable reference counted pointer type
@@ -58,11 +56,7 @@ impl<T> Rc<T> {
                 // destructor never frees the allocation while the
                 // strong destructor is running, even if the weak
                 // pointer is stored inside the strong one.
-                ptr: transmute(~RcBox {
-                    value: value,
-                    strong: Cell::new(1),
-                    weak: Cell::new(1)
-                }),
+                ptr: transmute(~RcBox { value: value, strong: 1, weak: 1 }),
                 nosend: marker::NoSend,
                 noshare: marker::NoShare
             }
@@ -73,11 +67,13 @@ impl<T> Rc<T> {
 impl<T> Rc<T> {
     /// Downgrade the reference-counted pointer to a weak reference
     pub fn downgrade(&self) -> Weak<T> {
-        self.inc_weak();
-        Weak {
-            ptr: self.ptr,
-            nosend: marker::NoSend,
-            noshare: marker::NoShare
+        unsafe {
+            (*self.ptr).weak += 1;
+            Weak {
+                ptr: self.ptr,
+                nosend: marker::NoSend,
+                noshare: marker::NoShare
+            }
         }
     }
 }
@@ -86,24 +82,24 @@ impl<T> Deref<T> for Rc<T> {
     /// Borrow the value contained in the reference-counted box
     #[inline(always)]
     fn deref<'a>(&'a self) -> &'a T {
-        &self.inner().value
+        unsafe { &(*self.ptr).value }
     }
 }
 
 #[unsafe_destructor]
 impl<T> Drop for Rc<T> {
     fn drop(&mut self) {
         unsafe {
-            if !self.ptr.is_null() {
-                self.dec_strong();
-                if self.strong() == 0 {
+            if self.ptr != 0 as *mut RcBox<T> {
+                (*self.ptr).strong -= 1;
+                if (*self.ptr).strong == 0 {
                     ptr::read(self.deref()); // destroy the contained object
 
                     // remove the implicit "strong weak" pointer now
                     // that we've destroyed the contents.
-                    self.dec_weak();
+                    (*self.ptr).weak -= 1;
 
-                    if self.weak() == 0 {
+                    if (*self.ptr).weak == 0 {
                         exchange_free(self.ptr as *u8)
                     }
                 }
@@ -115,8 +111,10 @@ impl<T> Drop for Rc<T> {
 impl<T> Clone for Rc<T> {
     #[inline]
     fn clone(&self) -> Rc<T> {
-        self.inc_strong();
-        Rc { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare }
+        unsafe {
+            (*self.ptr).strong += 1;
+            Rc { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare }
+        }
     }
 }
 
@@ -153,11 +151,13 @@ pub struct Weak<T> {
 impl<T> Weak<T> {
     /// Upgrade a weak reference to a strong reference
     pub fn upgrade(&self) -> Option<Rc<T>> {
-        if self.strong() == 0 {
-            None
-        } else {
-            self.inc_strong();
-            Some(Rc { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare })
+        unsafe {
+            if (*self.ptr).strong == 0 {
+                None
+            } else {
+                (*self.ptr).strong += 1;
+                Some(Rc { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare })
+            }
         }
     }
 }
@@ -166,11 +166,11 @@ impl<T> Weak<T> {
 impl<T> Drop for Weak<T> {
     fn drop(&mut self) {
         unsafe {
-            if !self.ptr.is_null() {
-                self.dec_weak();
+            if self.ptr != 0 as *mut RcBox<T> {
+                (*self.ptr).weak -= 1;
                 // the weak count starts at 1, and will only go to
                 // zero if all the strong pointers have disappeared.
-                if self.weak() == 0 {
+                if (*self.ptr).weak == 0 {
                     exchange_free(self.ptr as *u8)
                 }
             }
@@ -181,44 +181,13 @@ impl<T> Drop for Weak<T> {
 impl<T> Clone for Weak<T> {
     #[inline]
     fn clone(&self) -> Weak<T> {
-        self.inc_weak();
-        Weak { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare }
+        unsafe {
+            (*self.ptr).weak += 1;
+            Weak { ptr: self.ptr, nosend: marker::NoSend, noshare: marker::NoShare }
+        }
     }
 }
 
-#[allow(missing_doc)]
-trait RcBoxPtr<T> {
-    fn inner<'a>(&'a self) -> &'a RcBox<T>;
-
-    #[inline]
-    fn strong(&self) -> uint { self.inner().strong.get() }
-
-    #[inline]
-    fn inc_strong(&self) { self.inner().strong.set(self.strong() + 1); }
-
-    #[inline]
-    fn dec_strong(&self) { self.inner().strong.set(self.strong() - 1); }
-
-    #[inline]
-    fn weak(&self) -> uint { self.inner().weak.get() }
-
-    #[inline]
-    fn inc_weak(&self) { self.inner().weak.set(self.weak() + 1); }
-
-    #[inline]
-    fn dec_weak(&self) { self.inner().weak.set(self.weak() - 1); }
-}
-
-impl<T> RcBoxPtr<T> for Rc<T> {
-    #[inline(always)]
-    fn inner<'a>(&'a self) -> &'a RcBox<T> { unsafe { &(*self.ptr) } }
-}
-
-impl<T> RcBoxPtr<T> for Weak<T> {
-    #[inline(always)]
-    fn inner<'a>(&'a self) -> &'a RcBox<T> { unsafe { &(*self.ptr) } }
-}
-
 #[cfg(test)]
 mod tests {
     use prelude::*;

branches/try/src/libstd/rt/local_heap.rs

@@ -21,7 +21,7 @@ use rt::global_heap;
 use rt::local::Local;
 use rt::task::Task;
 use raw;
-use slice::ImmutableVector;
+use slice::{ImmutableVector, Vector};
 use vec::Vec;
 
 // This has no meaning with out rtdebug also turned on.

branches/try/src/libstd/str.rs

@@ -101,6 +101,7 @@ use ptr::RawPtr;
 use from_str::FromStr;
 use slice;
 use slice::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector};
+use slice::{Vector};
 use vec::Vec;
 use default::Default;
 use raw::Repr;

branches/try/src/libstd/vec.rs

@@ -28,7 +28,7 @@ use ptr;
 use rt::global_heap::{malloc_raw, realloc_raw};
 use raw::Slice;
 use slice::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
-use slice::{MutableTotalOrdVector};
+use slice::{MutableTotalOrdVector, Vector};
 
 /// An owned, growable vector.
 ///
@@ -534,22 +534,6 @@ impl<T> Vec<T> {
         self.len = len;
     }
 
-    /// Work with `self` as a slice.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// fn foo(slice: &[int]) {}
-    ///
-    /// let vec = vec!(1, 2);
-    /// foo(vec.as_slice());
-    /// ```
-    #[inline]
-    pub fn as_slice<'a>(&'a self) -> &'a [T] {
-        let slice = Slice { data: self.ptr as *T, len: self.len };
-        unsafe { transmute(slice) }
-    }
-
     /// Work with `self` as a mutable slice.
     ///
     /// # Example
@@ -1172,6 +1156,24 @@ impl<T:Eq> Vec<T> {
     }
 }
 
+impl<T> Vector<T> for Vec<T> {
+    /// Work with `self` as a slice.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// fn foo(slice: &[int]) {}
+    ///
+    /// let vec = vec!(1, 2);
+    /// foo(vec.as_slice());
+    /// ```
+    #[inline]
+    fn as_slice<'a>(&'a self) -> &'a [T] {
+        let slice = Slice { data: self.ptr as *T, len: self.len };
+        unsafe { transmute(slice) }
+    }
+}
+
 /// Iterates over the `second` vector, copying each element and appending it to
 /// the `first`. Afterwards, the `first` is then returned for use again.
 ///

branches/try/src/libsyntax/ast.rs

@@ -1156,6 +1156,14 @@ mod test {
     use codemap::*;
     use super::*;
 
+    fn is_freeze<T: Freeze>() {}
+
+    // Assert that the AST remains Freeze (#10693).
+    #[test]
+    fn ast_is_freeze() {
+        is_freeze::<Item>();
+    }
+
     // are ASTs encodable?
     #[test]
     fn check_asts_encodable() {