auto merge of #14397 : nick29581/rust/coerce, r=pnkfelix

DST coercions and DST fields in structs

The commits are not quite stand alone, I should probably squash them together before landing. In particular if you review the individual commits, then you'll see some scrappy stuff that gets fixed in later commits. But reading the commits in order might be easier to get an overall idea of what is going on.

The first commit includes putting back time zone into our time library - @pcwalton removed that as part of his de-~str'ing, but I had already converted it to use StrBuf, so we may as well leave it in. Update: no longer, this is removed in a later commit.

10 files changed, 191 insertions, 132 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/path/posix.rs b/src/libstd/path/posix.rs
index 0a7817c3e00..06eab31d7bf 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -464,6 +464,7 @@ static dot_dot_static: &'static [u8] = b"..";
 mod tests {
     use prelude::*;
     use super::*;
+    use mem;
     use str;
     use str::StrSlice;
 
@@ -621,8 +622,10 @@ mod tests {
         macro_rules! t(
             (s: $path:expr, $op:ident, $exp:expr) => (
                 {
-                    let path = Path::new($path);
-                    assert!(path.$op() == ($exp).as_bytes());
+                    unsafe {
+                        let path = Path::new($path);
+                        assert!(path.$op() == mem::transmute(($exp).as_bytes()));
+                    }
                 }
             );
             (s: $path:expr, $op:ident, $exp:expr, opt) => (
@@ -634,9 +637,11 @@ mod tests {
             );
             (v: $path:expr, $op:ident, $exp:expr) => (
                 {
-                    let arg = $path;
-                    let path = Path::new(arg);
-                    assert!(path.$op() == $exp);
+                    unsafe {
+                        let arg = $path;
+                        let path = Path::new(arg);
+                        assert!(path.$op() == mem::transmute($exp));
+                    }
                 }
             );
         )
@@ -684,8 +689,9 @@ mod tests {
         t!(v: b"hi/there.txt", extension, Some(b"txt"));
         t!(v: b"hi/there\x80.txt", extension, Some(b"txt"));
         t!(v: b"hi/there.t\x80xt", extension, Some(b"t\x80xt"));
-        t!(v: b"hi/there", extension, None);
-        t!(v: b"hi/there\x80", extension, None);
+        let no: Option<&'static [u8]> = None;
+        t!(v: b"hi/there", extension, no);
+        t!(v: b"hi/there\x80", extension, no);
         t!(s: "hi/there.txt", extension, Some("txt"), opt);
         t!(s: "hi/there", extension, None, opt);
         t!(s: "there.txt", extension, Some("txt"), opt);
@@ -974,57 +980,62 @@ mod tests {
         macro_rules! t(
             (s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
                 {
-                    let path = $path;
-                    let filename = $filename;
-                    assert!(path.filename_str() == filename,
-                            "{}.filename_str(): Expected `{:?}`, found {:?}",
-                            path.as_str().unwrap(), filename, path.filename_str());
-                    let dirname = $dirname;
-                    assert!(path.dirname_str() == dirname,
-                            "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), dirname, path.dirname_str());
-                    let filestem = $filestem;
-                    assert!(path.filestem_str() == filestem,
-                            "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), filestem, path.filestem_str());
-                    let ext = $ext;
-                    assert!(path.extension_str() == ext,
-                            "`{}`.extension_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), ext, path.extension_str());
+                    unsafe {
+                        let path = $path;
+                        let filename = $filename;
+                        assert!(path.filename_str() == filename,
+                                "{}.filename_str(): Expected `{:?}`, found {:?}",
+                                path.as_str().unwrap(), filename, path.filename_str());
+                        let dirname = $dirname;
+                        assert!(path.dirname_str() == dirname,
+                                "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), dirname, path.dirname_str());
+                        let filestem = $filestem;
+                        assert!(path.filestem_str() == filestem,
+                                "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), filestem, path.filestem_str());
+                        let ext = $ext;
+                        assert!(path.extension_str() == mem::transmute(ext),
+                                "`{}`.extension_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), ext, path.extension_str());
+                    }
                 }
             );
             (v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
                 {
-                    let path = $path;
-                    assert!(path.filename() == $filename);
-                    assert!(path.dirname() == $dirname);
-                    assert!(path.filestem() == $filestem);
-                    assert!(path.extension() == $ext);
+                    unsafe {
+                        let path = $path;
+                        assert!(path.filename() == mem::transmute($filename));
+                        assert!(path.dirname() == mem::transmute($dirname));
+                        assert!(path.filestem() == mem::transmute($filestem));
+                        assert!(path.extension() == mem::transmute($ext));
+                    }
                 }
             )
         )
 
-        t!(v: Path::new(b"a/b/c"), Some(b"c"), b"a/b", Some(b"c"), None);
-        t!(v: Path::new(b"a/b/\xFF"), Some(b"\xFF"), b"a/b", Some(b"\xFF"), None);
+        let no: Option<&'static str> = None;
+        t!(v: Path::new(b"a/b/c"), Some(b"c"), b"a/b", Some(b"c"), no);
+        t!(v: Path::new(b"a/b/\xFF"), Some(b"\xFF"), b"a/b", Some(b"\xFF"), no);
         t!(v: Path::new(b"hi/there.\xFF"), Some(b"there.\xFF"), b"hi",
               Some(b"there"), Some(b"\xFF"));
-        t!(s: Path::new("a/b/c"), Some("c"), Some("a/b"), Some("c"), None);
-        t!(s: Path::new("."), None, Some("."), None, None);
-        t!(s: Path::new("/"), None, Some("/"), None, None);
-        t!(s: Path::new(".."), None, Some(".."), None, None);
-        t!(s: Path::new("../.."), None, Some("../.."), None, None);
+        t!(s: Path::new("a/b/c"), Some("c"), Some("a/b"), Some("c"), no);
+        t!(s: Path::new("."), None, Some("."), None, no);
+        t!(s: Path::new("/"), None, Some("/"), None, no);
+        t!(s: Path::new(".."), None, Some(".."), None, no);
+        t!(s: Path::new("../.."), None, Some("../.."), None, no);
         t!(s: Path::new("hi/there.txt"), Some("there.txt"), Some("hi"),
               Some("there"), Some("txt"));
-        t!(s: Path::new("hi/there"), Some("there"), Some("hi"), Some("there"), None);
+        t!(s: Path::new("hi/there"), Some("there"), Some("hi"), Some("there"), no);
         t!(s: Path::new("hi/there."), Some("there."), Some("hi"),
               Some("there"), Some(""));
-        t!(s: Path::new("hi/.there"), Some(".there"), Some("hi"), Some(".there"), None);
+        t!(s: Path::new("hi/.there"), Some(".there"), Some("hi"), Some(".there"), no);
         t!(s: Path::new("hi/..there"), Some("..there"), Some("hi"),
               Some("."), Some("there"));
-        t!(s: Path::new(b"a/b/\xFF"), None, Some("a/b"), None, None);
+        t!(s: Path::new(b"a/b/\xFF"), None, Some("a/b"), None, no);
         t!(s: Path::new(b"a/b/\xFF.txt"), None, Some("a/b"), None, Some("txt"));
-        t!(s: Path::new(b"a/b/c.\x80"), None, Some("a/b"), Some("c"), None);
-        t!(s: Path::new(b"\xFF/b"), Some("b"), None, Some("b"), None);
+        t!(s: Path::new(b"a/b/c.\x80"), None, Some("a/b"), Some("c"), no);
+        t!(s: Path::new(b"\xFF/b"), Some("b"), None, Some("b"), no);
     }
 
     #[test]
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index dd87e214c2c..d9864cfaa61 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -1141,6 +1141,7 @@ fn prefix_len(p: Option<PathPrefix>) -> uint {
 
 #[cfg(test)]
 mod tests {
+    use mem;
     use prelude::*;
     use super::*;
     use super::parse_prefix;
@@ -1383,9 +1384,11 @@ mod tests {
         macro_rules! t(
             (s: $path:expr, $op:ident, $exp:expr) => (
                 {
-                    let path = $path;
-                    let path = Path::new(path);
-                    assert!(path.$op() == Some($exp));
+                    unsafe {
+                        let path = $path;
+                        let path = Path::new(path);
+                        assert!(path.$op() == Some(mem::transmute($exp)));
+                    }
                 }
             );
             (s: $path:expr, $op:ident, $exp:expr, opt) => (
@@ -1398,9 +1401,11 @@ mod tests {
             );
             (v: $path:expr, $op:ident, $exp:expr) => (
                 {
-                    let path = $path;
-                    let path = Path::new(path);
-                    assert!(path.$op() == $exp);
+                    unsafe {
+                        let path = $path;
+                        let path = Path::new(path);
+                        assert!(path.$op() == mem::transmute($exp));
+                    }
                 }
             )
         )
@@ -1485,7 +1490,8 @@ mod tests {
         // filestem is based on filename, so we don't need the full set of prefix tests
 
         t!(v: b"hi\\there.txt", extension, Some(b"txt"));
-        t!(v: b"hi\\there", extension, None);
+        let no: Option<&'static [u8]> = None;
+        t!(v: b"hi\\there", extension, no);
         t!(s: "hi\\there.txt", extension_str, Some("txt"), opt);
         t!(s: "hi\\there", extension_str, None, opt);
         t!(s: "there.txt", extension_str, Some("txt"), opt);
@@ -1892,48 +1898,53 @@ mod tests {
         macro_rules! t(
             (s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
                 {
-                    let path = $path;
-                    let filename = $filename;
-                    assert!(path.filename_str() == filename,
-                            "`{}`.filename_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), filename, path.filename_str());
-                    let dirname = $dirname;
-                    assert!(path.dirname_str() == dirname,
-                            "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), dirname, path.dirname_str());
-                    let filestem = $filestem;
-                    assert!(path.filestem_str() == filestem,
-                            "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), filestem, path.filestem_str());
-                    let ext = $ext;
-                    assert!(path.extension_str() == ext,
-                            "`{}`.extension_str(): Expected `{:?}`, found `{:?}`",
-                            path.as_str().unwrap(), ext, path.extension_str());
+                    unsafe {
+                        let path = $path;
+                        let filename = $filename;
+                        assert!(path.filename_str() == filename,
+                                "`{}`.filename_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), filename, path.filename_str());
+                        let dirname = $dirname;
+                        assert!(path.dirname_str() == dirname,
+                                "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), dirname, path.dirname_str());
+                        let filestem = $filestem;
+                        assert!(path.filestem_str() == filestem,
+                                "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), filestem, path.filestem_str());
+                        let ext = $ext;
+                        assert!(path.extension_str() == mem::transmute(ext),
+                                "`{}`.extension_str(): Expected `{:?}`, found `{:?}`",
+                                path.as_str().unwrap(), ext, path.extension_str());
+                    }
                 }
             );
             (v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
                 {
-                    let path = $path;
-                    assert!(path.filename() == $filename);
-                    assert!(path.dirname() == $dirname);
-                    assert!(path.filestem() == $filestem);
-                    assert!(path.extension() == $ext);
+                    unsafe {
+                        let path = $path;
+                        assert!(path.filename() == mem::transmute($filename));
+                        assert!(path.dirname() == mem::transmute($dirname));
+                        assert!(path.filestem() == mem::transmute($filestem));
+                        assert!(path.extension() == mem::transmute($ext));
+                    }
                 }
             )
         )
 
-        t!(v: Path::new(b"a\\b\\c"), Some(b"c"), b"a\\b", Some(b"c"), None);
-        t!(s: Path::new("a\\b\\c"), Some("c"), Some("a\\b"), Some("c"), None);
-        t!(s: Path::new("."), None, Some("."), None, None);
-        t!(s: Path::new("\\"), None, Some("\\"), None, None);
-        t!(s: Path::new(".."), None, Some(".."), None, None);
-        t!(s: Path::new("..\\.."), None, Some("..\\.."), None, None);
+        let no: Option<&'static str> = None;
+        t!(v: Path::new(b"a\\b\\c"), Some(b"c"), b"a\\b", Some(b"c"), no);
+        t!(s: Path::new("a\\b\\c"), Some("c"), Some("a\\b"), Some("c"), no);
+        t!(s: Path::new("."), None, Some("."), None, no);
+        t!(s: Path::new("\\"), None, Some("\\"), None, no);
+        t!(s: Path::new(".."), None, Some(".."), None, no);
+        t!(s: Path::new("..\\.."), None, Some("..\\.."), None, no);
         t!(s: Path::new("hi\\there.txt"), Some("there.txt"), Some("hi"),
               Some("there"), Some("txt"));
-        t!(s: Path::new("hi\\there"), Some("there"), Some("hi"), Some("there"), None);
+        t!(s: Path::new("hi\\there"), Some("there"), Some("hi"), Some("there"), no);
         t!(s: Path::new("hi\\there."), Some("there."), Some("hi"),
               Some("there"), Some(""));
-        t!(s: Path::new("hi\\.there"), Some(".there"), Some("hi"), Some(".there"), None);
+        t!(s: Path::new("hi\\.there"), Some(".there"), Some("hi"), Some(".there"), no);
         t!(s: Path::new("hi\\..there"), Some("..there"), Some("hi"),
               Some("."), Some("there"));
 
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);
     }