Remove the newly introduced trait impls for fixed-size arrays and use &b"..."[..] instead.

2 files changed, 18 insertions, 22 deletions

diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index 882ddb1f783..365f5e37b0b 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -11,7 +11,6 @@
 use prelude::v1::*;
 use io::prelude::*;
 
-use core::array::FixedSizeArray;
 use cmp;
 use io::{self, SeekFrom, Error, ErrorKind};
 use iter::repeat;
@@ -73,7 +72,7 @@ macro_rules! seek {
         fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
             let pos = match style {
                 SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
-                SeekFrom::End(n) => self.inner.as_slice().len() as i64 + n,
+                SeekFrom::End(n) => self.inner.len() as i64 + n,
                 SeekFrom::Current(n) => self.pos as i64 + n,
             };
 
@@ -95,7 +94,6 @@ impl<'a> io::Seek for Cursor<&'a [u8]> { seek!(); }
 impl<'a> io::Seek for Cursor<&'a mut [u8]> { seek!(); }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl io::Seek for Cursor<Vec<u8>> { seek!(); }
-impl<'a, T: FixedSizeArray<u8>> io::Seek for Cursor<&'a T> { seek!(); }
 
 macro_rules! read {
     () => {
@@ -113,13 +111,12 @@ impl<'a> Read for Cursor<&'a [u8]> { read!(); }
 impl<'a> Read for Cursor<&'a mut [u8]> { read!(); }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Read for Cursor<Vec<u8>> { read!(); }
-impl<'a, T: FixedSizeArray<u8>> Read for Cursor<&'a T> { read!(); }
 
 macro_rules! buffer {
     () => {
         fn fill_buf(&mut self) -> io::Result<&[u8]> {
-            let amt = cmp::min(self.pos, self.inner.as_slice().len() as u64);
-            Ok(&self.inner.as_slice()[(amt as usize)..])
+            let amt = cmp::min(self.pos, self.inner.len() as u64);
+            Ok(&self.inner[(amt as usize)..])
         }
         fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
     }
@@ -131,7 +128,6 @@ impl<'a> BufRead for Cursor<&'a [u8]> { buffer!(); }
 impl<'a> BufRead for Cursor<&'a mut [u8]> { buffer!(); }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> BufRead for Cursor<Vec<u8>> { buffer!(); }
-impl<'a, T: FixedSizeArray<u8>> BufRead for Cursor<&'a T> { buffer!(); }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Write for Cursor<&'a mut [u8]> {
@@ -332,7 +328,7 @@ mod tests {
 
     #[test]
     fn test_read_char() {
-        let b = b"Vi\xE1\xBB\x87t";
+        let b = &b"Vi\xE1\xBB\x87t"[..];
         let mut c = Cursor::new(b).chars();
         assert_eq!(c.next(), Some(Ok('V')));
         assert_eq!(c.next(), Some(Ok('i')));
@@ -343,7 +339,7 @@ mod tests {
 
     #[test]
     fn test_read_bad_char() {
-        let b = b"\x80";
+        let b = &b"\x80"[..];
         let mut c = Cursor::new(b).chars();
         assert!(c.next().unwrap().is_err());
     }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index d1231f549bb..d9e8047104a 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -933,12 +933,12 @@ mod tests {
 
     #[test]
     fn read_until() {
-        let mut buf = Cursor::new(b"12");
+        let mut buf = Cursor::new(&b"12"[..]);
         let mut v = Vec::new();
         assert_eq!(buf.read_until(b'3', &mut v), Ok(2));
         assert_eq!(v, b"12");
 
-        let mut buf = Cursor::new(b"1233");
+        let mut buf = Cursor::new(&b"1233"[..]);
         let mut v = Vec::new();
         assert_eq!(buf.read_until(b'3', &mut v), Ok(3));
         assert_eq!(v, b"123");
@@ -952,12 +952,12 @@ mod tests {
 
     #[test]
     fn split() {
-        let buf = Cursor::new(b"12");
+        let buf = Cursor::new(&b"12"[..]);
         let mut s = buf.split(b'3');
         assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
         assert_eq!(s.next(), None);
 
-        let buf = Cursor::new(b"1233");
+        let buf = Cursor::new(&b"1233"[..]);
         let mut s = buf.split(b'3');
         assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
         assert_eq!(s.next(), Some(Ok(vec![])));
@@ -966,12 +966,12 @@ mod tests {
 
     #[test]
     fn read_line() {
-        let mut buf = Cursor::new(b"12");
+        let mut buf = Cursor::new(&b"12"[..]);
         let mut v = String::new();
         assert_eq!(buf.read_line(&mut v), Ok(2));
         assert_eq!(v, "12");
 
-        let mut buf = Cursor::new(b"12\n\n");
+        let mut buf = Cursor::new(&b"12\n\n"[..]);
         let mut v = String::new();
         assert_eq!(buf.read_line(&mut v), Ok(3));
         assert_eq!(v, "12\n");
@@ -985,12 +985,12 @@ mod tests {
 
     #[test]
     fn lines() {
-        let buf = Cursor::new(b"12");
+        let buf = Cursor::new(&b"12"[..]);
         let mut s = buf.lines();
         assert_eq!(s.next(), Some(Ok("12".to_string())));
         assert_eq!(s.next(), None);
 
-        let buf = Cursor::new(b"12\n\n");
+        let buf = Cursor::new(&b"12\n\n"[..]);
         let mut s = buf.lines();
         assert_eq!(s.next(), Some(Ok("12".to_string())));
         assert_eq!(s.next(), Some(Ok(String::new())));
@@ -999,12 +999,12 @@ mod tests {
 
     #[test]
     fn read_to_end() {
-        let mut c = Cursor::new(b"");
+        let mut c = Cursor::new(&b""[..]);
         let mut v = Vec::new();
         assert_eq!(c.read_to_end(&mut v), Ok(0));
         assert_eq!(v, []);
 
-        let mut c = Cursor::new(b"1");
+        let mut c = Cursor::new(&b"1"[..]);
         let mut v = Vec::new();
         assert_eq!(c.read_to_end(&mut v), Ok(1));
         assert_eq!(v, b"1");
@@ -1012,17 +1012,17 @@ mod tests {
 
     #[test]
     fn read_to_string() {
-        let mut c = Cursor::new(b"");
+        let mut c = Cursor::new(&b""[..]);
         let mut v = String::new();
         assert_eq!(c.read_to_string(&mut v), Ok(0));
         assert_eq!(v, "");
 
-        let mut c = Cursor::new(b"1");
+        let mut c = Cursor::new(&b"1"[..]);
         let mut v = String::new();
         assert_eq!(c.read_to_string(&mut v), Ok(1));
         assert_eq!(v, "1");
 
-        let mut c = Cursor::new(b"\xff");
+        let mut c = Cursor::new(&b"\xff"[..]);
         let mut v = String::new();
         assert!(c.read_to_string(&mut v).is_err());
     }