Move stray impls into appropriate file

src/buf/buf.rs

 use super::{Take, Reader, Iter, FromBuf};
 use byteorder::ByteOrder;
 
-use std::{cmp, ptr};
+use std::{cmp, io, ptr};
 
 /// Read bytes from a buffer.
 ///
@@ -566,3 +566,55 @@ pub trait Buf {
         super::iter::new(self)
     }
 }
+
+impl<'a, T: Buf + ?Sized> Buf for &'a mut T {
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        (**self).bytes()
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        (**self).advance(cnt)
+    }
+}
+
+impl<T: Buf + ?Sized> Buf for Box<T> {
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        (**self).bytes()
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        (**self).advance(cnt)
+    }
+}
+
+impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
+    fn remaining(&self) -> usize {
+        let len = self.get_ref().as_ref().len();
+        let pos = self.position();
+
+        if pos >= len as u64 {
+            return 0;
+        }
+
+        len - pos as usize
+    }
+
+    fn bytes(&self) -> &[u8] {
+        let pos = self.position() as usize;
+        &(self.get_ref().as_ref())[pos..]
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        let pos = self.position() as usize;
+        let pos = cmp::min(self.get_ref().as_ref().len(), pos + cnt);
+        self.set_position(pos as u64);
+    }
+}

src/buf/buf_mut.rs

 use super::{Source, Writer};
 use byteorder::ByteOrder;
 
-use std::{cmp, ptr};
+use std::{cmp, io, ptr, usize};
 
 /// A trait for values that provide sequential write access to bytes.
 ///
@@ -503,3 +503,87 @@ pub trait BufMut {
         super::writer::new(self)
     }
 }
+
+impl<'a, T: BufMut + ?Sized> BufMut for &'a mut T {
+    fn remaining_mut(&self) -> usize {
+        (**self).remaining_mut()
+    }
+
+    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
+        (**self).bytes_mut()
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        (**self).advance_mut(cnt)
+    }
+}
+
+impl<T: BufMut + ?Sized> BufMut for Box<T> {
+    fn remaining_mut(&self) -> usize {
+        (**self).remaining_mut()
+    }
+
+    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
+        (**self).bytes_mut()
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        (**self).advance_mut(cnt)
+    }
+}
+
+impl<T: AsMut<[u8]> + AsRef<[u8]>> BufMut for io::Cursor<T> {
+    fn remaining_mut(&self) -> usize {
+        use Buf;
+        self.remaining()
+    }
+
+    /// Advance the internal cursor of the BufMut
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        let pos = self.position() as usize;
+        let pos = cmp::min(self.get_mut().as_mut().len(), pos + cnt);
+        self.set_position(pos as u64);
+    }
+
+    /// Returns a mutable slice starting at the current BufMut position and of
+    /// length between 0 and `BufMut::remaining()`.
+    ///
+    /// The returned byte slice may represent uninitialized memory.
+    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
+        let pos = self.position() as usize;
+        &mut (self.get_mut().as_mut())[pos..]
+    }
+}
+
+impl BufMut for Vec<u8> {
+    fn remaining_mut(&self) -> usize {
+        usize::MAX - self.len()
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        let len = self.len() + cnt;
+
+        if len > self.capacity() {
+            // Reserve additional
+            // TODO: Should this case panic?
+            let cap = self.capacity();
+            self.reserve(cap - len);
+        }
+
+        self.set_len(len);
+    }
+
+    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
+        use std::slice;
+
+        if self.capacity() == self.len() {
+            self.reserve(64); // Grow the vec
+        }
+
+        let cap = self.capacity();
+        let len = self.len();
+
+        let ptr = self.as_mut_ptr();
+        &mut slice::from_raw_parts_mut(ptr, cap)[len..]
+    }
+}

src/buf/mod.rs

@@ -16,8 +16,6 @@
 //! [`Buf`]: trait.Buf.html
 //! [`BufMut`]: trait.BufMut.html
 
-use std::{cmp, io, usize};
-
 mod buf;
 mod buf_mut;
 mod from_buf;
@@ -37,144 +35,3 @@ pub use self::reader::Reader;
 pub use self::source::Source;
 pub use self::take::Take;
 pub use self::writer::Writer;
-
-/*
- *
- * ===== Buf impls =====
- *
- */
-
-impl<'a, T: Buf + ?Sized> Buf for &'a mut T {
-    fn remaining(&self) -> usize {
-        (**self).remaining()
-    }
-
-    fn bytes(&self) -> &[u8] {
-        (**self).bytes()
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        (**self).advance(cnt)
-    }
-}
-
-impl<'a, T: BufMut + ?Sized> BufMut for &'a mut T {
-    fn remaining_mut(&self) -> usize {
-        (**self).remaining_mut()
-    }
-
-    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
-        (**self).bytes_mut()
-    }
-
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        (**self).advance_mut(cnt)
-    }
-}
-
-impl<T: Buf + ?Sized> Buf for Box<T> {
-    fn remaining(&self) -> usize {
-        (**self).remaining()
-    }
-
-    fn bytes(&self) -> &[u8] {
-        (**self).bytes()
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        (**self).advance(cnt)
-    }
-}
-
-impl<T: BufMut + ?Sized> BufMut for Box<T> {
-    fn remaining_mut(&self) -> usize {
-        (**self).remaining_mut()
-    }
-
-    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
-        (**self).bytes_mut()
-    }
-
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        (**self).advance_mut(cnt)
-    }
-}
-
-impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
-    fn remaining(&self) -> usize {
-        let len = self.get_ref().as_ref().len();
-        let pos = self.position();
-
-        if pos >= len as u64 {
-            return 0;
-        }
-
-        len - pos as usize
-    }
-
-    fn bytes(&self) -> &[u8] {
-        let pos = self.position() as usize;
-        &(self.get_ref().as_ref())[pos..]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        let pos = self.position() as usize;
-        let pos = cmp::min(self.get_ref().as_ref().len(), pos + cnt);
-        self.set_position(pos as u64);
-    }
-}
-
-impl<T: AsMut<[u8]> + AsRef<[u8]>> BufMut for io::Cursor<T> {
-    fn remaining_mut(&self) -> usize {
-        self.remaining()
-    }
-
-    /// Advance the internal cursor of the BufMut
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        let pos = self.position() as usize;
-        let pos = cmp::min(self.get_mut().as_mut().len(), pos + cnt);
-        self.set_position(pos as u64);
-    }
-
-    /// Returns a mutable slice starting at the current BufMut position and of
-    /// length between 0 and `BufMut::remaining()`.
-    ///
-    /// The returned byte slice may represent uninitialized memory.
-    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
-        let pos = self.position() as usize;
-        &mut (self.get_mut().as_mut())[pos..]
-    }
-}
-
-impl BufMut for Vec<u8> {
-    fn remaining_mut(&self) -> usize {
-        usize::MAX - self.len()
-    }
-
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        let len = self.len() + cnt;
-
-        if len > self.capacity() {
-            // Reserve additional
-            // TODO: Should this case panic?
-            let cap = self.capacity();
-            self.reserve(cap - len);
-        }
-
-        self.set_len(len);
-    }
-
-    unsafe fn bytes_mut(&mut self) -> &mut [u8] {
-        use std::slice;
-
-        if self.capacity() == self.len() {
-            self.reserve(64); // Grow the vec
-        }
-
-        let cap = self.capacity();
-        let len = self.len();
-
-        let ptr = self.as_mut_ptr();
-        &mut slice::from_raw_parts_mut(ptr, cap)[len..]
-    }
-}