Use temp vars for implicit coercion to ^[T]

8 files changed, 91 insertions, 54 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index b31baa88e0c..f7b23163dfe 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -609,11 +609,12 @@ mod tests {
     #[test]
     fn test_ascii_vec() {
         let test = &[40u8, 32u8, 59u8];
-        assert_eq!(test.to_ascii(), v2ascii!([40, 32, 59]));
-        assert_eq!("( ;".to_ascii(), v2ascii!([40, 32, 59]));
+        let b: &[_] = v2ascii!([40, 32, 59]);
+        assert_eq!(test.to_ascii(), b);
+        assert_eq!("( ;".to_ascii(), b);
         let v = vec![40u8, 32u8, 59u8];
-        assert_eq!(v.as_slice().to_ascii(), v2ascii!([40, 32, 59]));
-        assert_eq!("( ;".to_string().as_slice().to_ascii(), v2ascii!([40, 32, 59]));
+        assert_eq!(v.as_slice().to_ascii(), b);
+        assert_eq!("( ;".to_string().as_slice().to_ascii(), b);
 
         assert_eq!("abCDef&?#".to_ascii().to_lower().into_string(), "abcdef&?#".to_string());
         assert_eq!("abCDef&?#".to_ascii().to_upper().into_string(), "ABCDEF&?#".to_string());
@@ -688,13 +689,12 @@ mod tests {
         assert_eq!((test1).to_ascii_opt(), None);
 
         let v = [40u8, 32u8, 59u8];
-        let v2 = v2ascii!(&[40, 32, 59]);
+        let v2: &[_] = v2ascii!(&[40, 32, 59]);
         assert_eq!(v.to_ascii_opt(), Some(v2));
         let v = [127u8, 128u8, 255u8];
         assert_eq!(v.to_ascii_opt(), None);
 
         let v = "( ;";
-        let v2 = v2ascii!(&[40, 32, 59]);
         assert_eq!(v.to_ascii_opt(), Some(v2));
         assert_eq!("zoä华".to_ascii_opt(), None);
 
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]
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index ad666d70034..f452f8b23e7 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -295,7 +295,8 @@ pub fn env_as_bytes() -> Vec<(Vec<u8>,Vec<u8>)> {
             for p in input.iter() {
                 let mut it = p.as_slice().splitn(1, |b| *b == b'=');
                 let key = Vec::from_slice(it.next().unwrap());
-                let val = Vec::from_slice(it.next().unwrap_or(&[]));
+                let default: &[u8] = &[];
+                let val = Vec::from_slice(it.next().unwrap_or(default));
                 pairs.push((key, val));
             }
             pairs
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 38d04324fe4..50441cb534d 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -846,7 +846,10 @@ impl<'a, P: GenericPath> Display<'a, P> {
     pub fn as_maybe_owned(&self) -> MaybeOwned<'a> {
         String::from_utf8_lossy(if self.filename {
             match self.path.filename() {
-                None => &[],
+                None => {
+                    let result: &[u8] = &[];
+                    result
+                }
                 Some(v) => v
             }
         } else {
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index b7bf75e39a5..b9b7a02b62f 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -531,7 +531,8 @@ mod test {
         r.shuffle(empty);
         let mut one = [1i];
         r.shuffle(one);
-        assert_eq!(one.as_slice(), &[1]);
+        let b: &[_] = &[1];
+        assert_eq!(one.as_slice(), b);
 
         let mut two = [1i, 2];
         r.shuffle(two);
@@ -539,7 +540,8 @@ mod test {
 
         let mut x = [1i, 1, 1];
         r.shuffle(x);
-        assert_eq!(x.as_slice(), &[1, 1, 1]);
+        let b: &[_] = &[1, 1, 1];
+        assert_eq!(x.as_slice(), b);
     }
 
     #[test]
@@ -548,7 +550,8 @@ mod test {
         r.gen::<int>();
         let mut v = [1i, 1, 1];
         r.shuffle(v);
-        assert_eq!(v.as_slice(), &[1, 1, 1]);
+        let b: &[_] = &[1, 1, 1];
+        assert_eq!(v.as_slice(), b);
         assert_eq!(r.gen_range(0u, 1u), 0u);
     }