Track Rust nightlies

Cargo.toml

@@ -19,7 +19,7 @@ exclude       = [
 ]
 
 [dev-dependencies]
-rand = "0.2.1"
+rand = "0.3.5"
 
 [[bench]]
 

src/byte_buf.rs

@@ -90,8 +90,9 @@ impl ByteBuf {
 
         unsafe {
             ptr::copy_nonoverlapping(
+                self.mem.ptr().offset(self.pos as isize),
                 dst.as_mut_ptr(),
-                self.mem.ptr().offset(self.pos as isize), len);
+                len);
         }
 
         self.pos += cnt;
@@ -241,8 +242,9 @@ impl MutByteBuf {
     fn write_ptr(&mut self, src: *const u8, len: u32) -> usize {
         unsafe {
             ptr::copy_nonoverlapping(
+                src,
                 self.buf.mem.ptr().offset(self.buf.pos as isize),
-                src, len as usize);
+                len as usize);
 
             self.buf.pos += len;
             len as usize

src/byte_str.rs

@@ -148,7 +148,7 @@ impl SmallByteStr {
         };
 
         // Copy the memory
-        bytes::copy_memory(&mut ret.bytes, bytes);
+        bytes::copy_memory(bytes, &mut ret.bytes);
 
         Some(ret)
     }

src/lib.rs

@@ -77,7 +77,7 @@ pub trait Buf {
                 cnt = cmp::min(src.len(), len - off);
 
                 ptr::copy_nonoverlapping(
-                    dst[off..].as_mut_ptr(), src.as_ptr(), cnt);
+                    src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
 
                 off += src.len();
             }
@@ -159,7 +159,9 @@ pub trait MutBuf : Sized {
                 cnt = cmp::min(dst.len(), len - off);
 
                 ptr::copy_nonoverlapping(
-                    dst.as_mut_ptr(), src[off..].as_ptr(), cnt);
+                    src[off..].as_ptr(),
+                    dst.as_mut_ptr(),
+                    cnt);
 
                 off += cnt;
             }
@@ -429,8 +431,8 @@ impl<'a> Source for &'a Bytes {
 
                 unsafe {
                     ptr::copy_nonoverlapping(
-                        d.as_mut_ptr(),
                         s.as_ptr(),
+                        d.as_mut_ptr(),
                         l);
                 }
             }

src/ring.rs

@@ -102,12 +102,12 @@ impl Clone for RingBuf {
             let to = self.pos + self.len;
 
             if to > self.cap {
-                ptr::copy(ret.ptr, self.ptr as *const u8, to % self.cap);
+                ptr::copy(self.ptr as *const u8, ret.ptr, to % self.cap);
             }
 
             ptr::copy(
-                ret.ptr.offset(self.pos as isize),
                 self.ptr.offset(self.pos as isize) as *const u8,
+                ret.ptr.offset(self.pos as isize),
                 cmp::min(self.len, self.cap - self.pos));
         }
 

test/test_buf_fill.rs

@@ -30,7 +30,9 @@ impl io::Read for Chunked {
         let src = self.chunks[0];
         let len = cmp::min(src.len(), dst.len());
 
-        bytes::copy_memory(&mut dst[..len], &src[..len]);
+        bytes::copy_memory(
+            &src[..len],
+            &mut dst[..len]);
 
         if len < src.len() {
             self.chunks[0] = &src[len..];