Use temp vars for implicit coercion to ^[T]

4 files changed, 73 insertions, 43 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index a9b0b33c59a..1d638e498d4 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -415,21 +415,25 @@ mod test {
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
         assert_eq!(Ok(2), nread);
-        assert_eq!(buf.as_slice(), &[0, 1, 0]);
+        let b: &[_] = &[0, 1, 0];
+        assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0];
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!(buf.as_slice(), &[2]);
+        let b: &[_] = &[2];
+        assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!(buf.as_slice(), &[3, 0, 0]);
+        let b: &[_] = &[3, 0, 0];
+        assert_eq!(buf.as_slice(), b);
 
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!(buf.as_slice(), &[4, 0, 0]);
+        let b: &[_] = &[4, 0, 0];
+        assert_eq!(buf.as_slice(), b);
 
         assert!(reader.read(buf).is_err());
     }
@@ -440,35 +444,41 @@ mod test {
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
         writer.write([0, 1]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[]);
+        let b: &[_] = &[];
+        assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.write([2]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
+        let b: &[_] = &[0, 1];
+        assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.write([3]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
+        assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.flush().unwrap();
-        assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
+        let a: &[_] = &[0, 1, 2, 3];
+        assert_eq!(a, writer.get_ref().get_ref());
 
         writer.write([4]).unwrap();
         writer.write([5]).unwrap();
-        assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
+        assert_eq!(a, writer.get_ref().get_ref());
 
         writer.write([6]).unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5],
+        let a: &[_] = &[0, 1, 2, 3, 4, 5];
+        assert_eq!(a,
                    writer.get_ref().get_ref());
 
         writer.write([7, 8]).unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5, 6],
+        let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
+        assert_eq!(a,
                    writer.get_ref().get_ref());
 
         writer.write([9, 10, 11]).unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        assert_eq!(a,
                    writer.get_ref().get_ref());
 
         writer.flush().unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        assert_eq!(a,
                    writer.get_ref().get_ref());
     }
 
@@ -476,9 +486,11 @@ mod test {
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
         w.write([0, 1]).unwrap();
-        assert_eq!(&[], w.get_ref().get_ref());
+        let a: &[_] = &[];
+        assert_eq!(a, w.get_ref().get_ref());
         let w = w.unwrap();
-        assert_eq!(&[0, 1], w.get_ref());
+        let a: &[_] = &[0, 1];
+        assert_eq!(a, w.get_ref());
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -519,20 +531,22 @@ mod test {
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
         writer.write([0]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[]);
+        let b: &[_] = &[];
+        assert_eq!(writer.get_ref().get_ref(), b);
         writer.write([1]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[]);
+        assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
-        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
+        let b: &[_] = &[0, 1];
+        assert_eq!(writer.get_ref().get_ref(), b);
         writer.write([0, b'\n', 1, b'\n', 2]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(),
-                   &[0, 1, 0, b'\n', 1, b'\n']);
+        let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
+        assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
-        assert_eq!(writer.get_ref().get_ref(),
-                   &[0, 1, 0, b'\n', 1, b'\n', 2]);
+        let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
+        assert_eq!(writer.get_ref().get_ref(), b);
         writer.write([3, b'\n']).unwrap();
-        assert_eq!(writer.get_ref().get_ref(),
-            &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
+        let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
+        assert_eq!(writer.get_ref().get_ref(), b);
     }
 
     #[test]
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 53b5fbe3894..1c8b047f56f 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -154,26 +154,29 @@ mod test {
         assert_eq!(Ok(0), reader.read([]));
 
         assert_eq!(Ok(3), reader.read(buf));
-        assert_eq!(&[1,2,3], buf.as_slice());
+        let a: &[u8] = &[1,2,3];
+        assert_eq!(a, buf.as_slice());
 
         assert_eq!(Ok(3), reader.read(buf));
-        assert_eq!(&[4,5,6], buf.as_slice());
+        let a: &[u8] = &[4,5,6];
+        assert_eq!(a, buf.as_slice());
 
         assert_eq!(Ok(2), reader.read(buf));
-        assert_eq!(&[7,8,6], buf.as_slice());
+        let a: &[u8] = &[7,8,6];
+        assert_eq!(a, buf.as_slice());
 
         match reader.read(buf.as_mut_slice()) {
             Ok(..) => fail!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
-        assert_eq!(&[7,8,6], buf.as_slice());
+        assert_eq!(a, buf.as_slice());
 
         // Ensure it continues to fail in the same way.
         match reader.read(buf.as_mut_slice()) {
             Ok(..) => fail!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
-        assert_eq!(&[7,8,6], buf.as_slice());
+        assert_eq!(a, buf.as_slice());
     }
 
     #[test]
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index ea9d08171e6..21ab9c1fdd4 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -346,7 +346,8 @@ mod test {
         writer.write([0]).unwrap();
         writer.write([1, 2, 3]).unwrap();
         writer.write([4, 5, 6, 7]).unwrap();
-        assert_eq!(writer.get_ref(), &[0, 1, 2, 3, 4, 5, 6, 7]);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(writer.get_ref(), b);
     }
 
     #[test]
@@ -363,7 +364,8 @@ mod test {
             writer.write([]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
         }
-        assert_eq!(buf.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7]);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(buf.as_slice(), b);
     }
 
     #[test]
@@ -391,7 +393,8 @@ mod test {
             assert_eq!(writer.tell(), Ok(8));
 
         }
-        assert_eq!(buf.as_slice(), &[1, 3, 2, 0, 0, 0, 0, 4]);
+        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
+        assert_eq!(buf.as_slice(), b);
     }
 
     #[test]
@@ -415,13 +418,16 @@ mod test {
         let mut buf = [0];
         assert_eq!(reader.read(buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
-        assert_eq!(buf.as_slice(), &[0]);
+        let b: &[_] = &[0];
+        assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
         assert_eq!(reader.read(buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
-        assert_eq!(buf.as_slice(), &[1, 2, 3, 4]);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
-        assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(buf.slice(0, 3), b);
         assert!(reader.read(buf).is_err());
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -439,13 +445,16 @@ mod test {
         let mut buf = [0];
         assert_eq!(reader.read(buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
-        assert_eq!(buf.as_slice(), &[0]);
+        let b: &[_] = &[0];
+        assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
         assert_eq!(reader.read(buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
-        assert_eq!(buf.as_slice(), &[1, 2, 3, 4]);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
-        assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(buf.slice(0, 3), b);
         assert!(reader.read(buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -537,13 +546,16 @@ mod test {
         let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
         let mut buf = [0, ..3];
         assert!(r.read_at_least(buf.len(), buf).is_ok());
-        assert_eq!(buf.as_slice(), &[1, 2, 3]);
+        let b: &[_] = &[1, 2, 3];
+        assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(0, buf.mut_slice_to(0)).is_ok());
-        assert_eq!(buf.as_slice(), &[1, 2, 3]);
+        assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(buf.len(), buf).is_ok());
-        assert_eq!(buf.as_slice(), &[4, 5, 6]);
+        let b: &[_] = &[4, 5, 6];
+        assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(buf.len(), buf).is_err());
-        assert_eq!(buf.as_slice(), &[7, 8, 6]);
+        let b: &[_] = &[7, 8, 6];
+        assert_eq!(buf.as_slice(), b);
     }
 
     fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index a69f6c10abf..03637079241 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -111,7 +111,8 @@ mod test {
             Ok(MemReader::new(vec!(0, 1, 2, 3)));
         let mut buf = [0, 0];
         reader.read(buf).unwrap();
-        assert_eq!(buf.as_slice(), &[0, 1]);
+        let b: &[_] = &[0, 1];
+        assert_eq!(buf.as_slice(), b);
     }
 
     #[test]