---

yaml
---
r: 173991
b: refs/heads/batch
c: e46620a
h: refs/heads/master
i:
  173989: de530c7
  173987: 658b296
  173983: e3af19c
v: v3

Author: brson

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: d52398ef8cd93c6089ceacb176ae0dbe213d301e
+refs/heads/batch: e46620af45ecf1f6388dc29f5a4b5f0954cf6dd8
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928

branches/batch/src/liballoc/arc.rs

@@ -137,8 +137,8 @@ unsafe impl<T: Sync + Send> Send for Weak<T> { }
 unsafe impl<T: Sync + Send> Sync for Weak<T> { }
 
 struct ArcInner<T> {
-    strong: atomic::AtomicUsize,
-    weak: atomic::AtomicUsize,
+    strong: atomic::AtomicUint,
+    weak: atomic::AtomicUint,
     data: T,
 }
 
@@ -161,8 +161,8 @@ impl<T> Arc<T> {
         // Start the weak pointer count as 1 which is the weak pointer that's
         // held by all the strong pointers (kinda), see std/rc.rs for more info
         let x = box ArcInner {
-            strong: atomic::AtomicUsize::new(1),
-            weak: atomic::AtomicUsize::new(1),
+            strong: atomic::AtomicUint::new(1),
+            weak: atomic::AtomicUint::new(1),
             data: data,
         };
         Arc { _ptr: unsafe { NonZero::new(mem::transmute(x)) } }
@@ -619,7 +619,7 @@ mod tests {
     use super::{Arc, Weak, weak_count, strong_count};
     use std::sync::Mutex;
 
-    struct Canary(*mut atomic::AtomicUsize);
+    struct Canary(*mut atomic::AtomicUint);
 
     impl Drop for Canary
     {
@@ -743,16 +743,16 @@ mod tests {
 
     #[test]
     fn drop_arc() {
-        let mut canary = atomic::AtomicUsize::new(0);
-        let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
+        let mut canary = atomic::AtomicUint::new(0);
+        let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUint));
         drop(x);
         assert!(canary.load(Acquire) == 1);
     }
 
     #[test]
     fn drop_arc_weak() {
-        let mut canary = atomic::AtomicUsize::new(0);
-        let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
+        let mut canary = atomic::AtomicUint::new(0);
+        let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUint));
         let arc_weak = arc.downgrade();
         assert!(canary.load(Acquire) == 0);
         drop(arc);

branches/batch/src/libcollections/slice.rs

@@ -1631,7 +1631,7 @@ mod tests {
     #[test]
     fn test_slice_from() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(&vec[], vec);
+        assert_eq!(&vec[0..], vec);
         let b: &[int] = &[3, 4];
         assert_eq!(&vec[2..], b);
         let b: &[int] = &[];
@@ -1641,11 +1641,11 @@ mod tests {
     #[test]
     fn test_slice_to() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(&vec[..4], vec);
+        assert_eq!(&vec[0..4], vec);
         let b: &[int] = &[1, 2];
-        assert_eq!(&vec[..2], b);
+        assert_eq!(&vec[0..2], b);
         let b: &[int] = &[];
-        assert_eq!(&vec[..0], b);
+        assert_eq!(&vec[0..0], b);
     }
 
 
@@ -2538,15 +2538,15 @@ mod tests {
             let (left, right) = values.split_at_mut(2);
             {
                 let left: &[_] = left;
-                assert!(left[..left.len()] == [1, 2][]);
+                assert!(left[0..left.len()] == [1, 2][]);
             }
             for p in left.iter_mut() {
                 *p += 1;
             }
 
             {
                 let right: &[_] = right;
-                assert!(right[..right.len()] == [3, 4, 5][]);
+                assert!(right[0..right.len()] == [3, 4, 5][]);
             }
             for p in right.iter_mut() {
                 *p += 2;

branches/batch/src/libcollections/str.rs

@@ -807,7 +807,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// out of bounds.
     ///
     /// See also `slice`, `slice_from` and `slice_chars`.
-    #[unstable = "use slice notation [..a] instead"]
+    #[unstable = "use slice notation [0..a] instead"]
     fn slice_to(&self, end: uint) -> &str {
         core_str::StrExt::slice_to(&self[], end)
     }

branches/batch/src/libcollections/string.rs

@@ -168,7 +168,7 @@ impl String {
 
         if i > 0 {
             unsafe {
-                res.as_mut_vec().push_all(&v[..i])
+                res.as_mut_vec().push_all(&v[0..i])
             };
         }
 

branches/batch/src/libcollections/vec.rs

@@ -2199,7 +2199,7 @@ mod tests {
 
     #[test]
     fn test_map_in_place_zero_drop_count() {
-        use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+        use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};
 
         #[derive(Clone, PartialEq, Show)]
         struct Nothing;
@@ -2213,7 +2213,7 @@ mod tests {
             }
         }
         const NUM_ELEMENTS: uint = 2;
-        static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+        static DROP_COUNTER: AtomicUint = ATOMIC_UINT_INIT;
 
         let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();