---

yaml
---
r: 236431
b: refs/heads/auto
c: 012f369
h: refs/heads/master
i:
  236429: b2adcca
  236427: 355f3b7
  236423: 7dabd74
  236415: 11b0f79
v: v3

Author: Manishearth

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: e7a73881e916d08c3edd97369c127e451b4717c8
+refs/heads/auto: 012f36947afb3362a686f3d85f6398c8886b9255
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/src/liballoc/arc.rs

@@ -214,9 +214,7 @@ impl<T> Arc<T> {
     #[stable(feature = "arc_unique", since = "1.4.0")]
     pub fn try_unwrap(this: Self) -> Result<T, Self> {
         // See `drop` for why all these atomics are like this
-        if this.inner().strong.compare_and_swap(1, 0, Release) != 1 {
-            return Err(this)
-        }
+        if this.inner().strong.compare_and_swap(1, 0, Release) != 1 { return Err(this) }
 
         atomic::fence(Acquire);
 
@@ -253,9 +251,7 @@ impl<T: ?Sized> Arc<T> {
             let cur = this.inner().weak.load(Relaxed);
 
             // check if the weak counter is currently "locked"; if so, spin.
-            if cur == usize::MAX {
-                continue
-            }
+            if cur == usize::MAX { continue }
 
             // NOTE: this code currently ignores the possibility of overflow
             // into usize::MAX; in general both Rc and Arc need to be adjusted
@@ -307,9 +303,7 @@ impl<T: ?Sized> Arc<T> {
 
         if self.inner().weak.fetch_sub(1, Release) == 1 {
             atomic::fence(Acquire);
-            deallocate(ptr as *mut u8,
-                       size_of_val(&*ptr),
-                       align_of_val(&*ptr))
+            deallocate(ptr as *mut u8, size_of_val(&*ptr), align_of_val(&*ptr))
         }
     }
 }
@@ -354,9 +348,7 @@ impl<T: ?Sized> Clone for Arc<T> {
         // We abort because such a program is incredibly degenerate, and we
         // don't care to support it.
         if old_size > MAX_REFCOUNT {
-            unsafe {
-                abort();
-            }
+            unsafe { abort(); }
         }
 
         Arc { _ptr: self._ptr }
@@ -564,9 +556,7 @@ impl<T: ?Sized> Drop for Arc<T> {
         // Because `fetch_sub` is already atomic, we do not need to synchronize
         // with other threads unless we are going to delete the object. This
         // same logic applies to the below `fetch_sub` to the `weak` count.
-        if self.inner().strong.fetch_sub(1, Release) != 1 {
-            return
-        }
+        if self.inner().strong.fetch_sub(1, Release) != 1 { return }
 
         // This fence is needed to prevent reordering of use of the data and
         // deletion of the data.  Because it is marked `Release`, the decreasing
@@ -588,7 +578,7 @@ impl<T: ?Sized> Drop for Arc<T> {
         atomic::fence(Acquire);
 
         unsafe {
-            self.drop_slow();
+            self.drop_slow()
         }
     }
 }
@@ -623,15 +613,11 @@ impl<T: ?Sized> Weak<T> {
             // "stale" read of 0 is fine), and any other value is
             // confirmed via the CAS below.
             let n = inner.strong.load(Relaxed);
-            if n == 0 {
-                return None
-            }
+            if n == 0 { return None }
 
             // Relaxed is valid for the same reason it is on Arc's Clone impl
             let old = inner.strong.compare_and_swap(n, n + 1, Relaxed);
-            if old == n {
-                return Some(Arc { _ptr: self._ptr })
-            }
+            if old == n { return Some(Arc { _ptr: self._ptr }) }
         }
     }
 
@@ -667,9 +653,7 @@ impl<T: ?Sized> Clone for Weak<T> {
 
         // See comments in Arc::clone() for why we do this (for mem::forget).
         if old_size > MAX_REFCOUNT {
-            unsafe {
-                abort();
-            }
+            unsafe { abort(); }
         }
 
         return Weak { _ptr: self._ptr }
@@ -721,11 +705,9 @@ impl<T: ?Sized> Drop for Weak<T> {
         // ref, which can only happen after the lock is released.
         if self.inner().weak.fetch_sub(1, Release) == 1 {
             atomic::fence(Acquire);
-            unsafe {
-                deallocate(ptr as *mut u8,
-                           size_of_val(&*ptr),
-                           align_of_val(&*ptr))
-            }
+            unsafe { deallocate(ptr as *mut u8,
+                                size_of_val(&*ptr),
+                                align_of_val(&*ptr)) }
         }
     }
 }
@@ -745,9 +727,7 @@ impl<T: ?Sized + PartialEq> PartialEq for Arc<T> {
     ///
     /// five == Arc::new(5);
     /// ```
-    fn eq(&self, other: &Arc<T>) -> bool {
-        *(*self) == *(*other)
-    }
+    fn eq(&self, other: &Arc<T>) -> bool { *(*self) == *(*other) }
 
     /// Inequality for two `Arc<T>`s.
     ///
@@ -762,9 +742,7 @@ impl<T: ?Sized + PartialEq> PartialEq for Arc<T> {
     ///
     /// five != Arc::new(5);
     /// ```
-    fn ne(&self, other: &Arc<T>) -> bool {
-        *(*self) != *(*other)
-    }
+    fn ne(&self, other: &Arc<T>) -> bool { *(*self) != *(*other) }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {
@@ -798,9 +776,7 @@ impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {
     ///
     /// five < Arc::new(5);
     /// ```
-    fn lt(&self, other: &Arc<T>) -> bool {
-        *(*self) < *(*other)
-    }
+    fn lt(&self, other: &Arc<T>) -> bool { *(*self) < *(*other) }
 
     /// 'Less-than or equal to' comparison for two `Arc<T>`s.
     ///
@@ -815,9 +791,7 @@ impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {
     ///
     /// five <= Arc::new(5);
     /// ```
-    fn le(&self, other: &Arc<T>) -> bool {
-        *(*self) <= *(*other)
-    }
+    fn le(&self, other: &Arc<T>) -> bool { *(*self) <= *(*other) }
 
     /// Greater-than comparison for two `Arc<T>`s.
     ///
@@ -832,9 +806,7 @@ impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {
     ///
     /// five > Arc::new(5);
     /// ```
-    fn gt(&self, other: &Arc<T>) -> bool {
-        *(*self) > *(*other)
-    }
+    fn gt(&self, other: &Arc<T>) -> bool { *(*self) > *(*other) }
 
     /// 'Greater-than or equal to' comparison for two `Arc<T>`s.
     ///
@@ -849,15 +821,11 @@ impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {
     ///
     /// five >= Arc::new(5);
     /// ```
-    fn ge(&self, other: &Arc<T>) -> bool {
-        *(*self) >= *(*other)
-    }
+    fn ge(&self, other: &Arc<T>) -> bool { *(*self) >= *(*other) }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized + Ord> Ord for Arc<T> {
-    fn cmp(&self, other: &Arc<T>) -> Ordering {
-        (**self).cmp(&**other)
-    }
+    fn cmp(&self, other: &Arc<T>) -> Ordering { (**self).cmp(&**other) }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized + Eq> Eq for Arc<T> {}
@@ -886,9 +854,7 @@ impl<T> fmt::Pointer for Arc<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Default> Default for Arc<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn default() -> Arc<T> {
-        Arc::new(Default::default())
-    }
+    fn default() -> Arc<T> { Arc::new(Default::default()) }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1049,7 +1015,7 @@ mod tests {
     #[test]
     fn weak_self_cyclic() {
         struct Cycle {
-            x: Mutex<Option<Weak<Cycle>>>,
+            x: Mutex<Option<Weak<Cycle>>>
         }
 
         let a = Arc::new(Cycle { x: Mutex::new(None) });
@@ -1129,9 +1095,7 @@ mod tests {
 
     // Make sure deriving works with Arc<T>
     #[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)]
-    struct Foo {
-        inner: Arc<i32>,
-    }
+    struct Foo { inner: Arc<i32> }
 
     #[test]
     fn test_unsized() {
@@ -1144,7 +1108,5 @@ mod tests {
 }
 
 impl<T: ?Sized> borrow::Borrow<T> for Arc<T> {
-    fn borrow(&self) -> &T {
-        &**self
-    }
+    fn borrow(&self) -> &T { &**self }
 }