Use slice syntax instead of slice_to, etc.

25 files changed, 60 insertions, 71 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index d9543a06b35..754b440b0de 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -90,10 +90,10 @@ impl<R: Reader> BufferedReader<R> {
 impl<R: Reader> Buffer for BufferedReader<R> {
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos == self.cap {
-            self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
+            self.cap = try!(self.inner.read(self.buf[mut]));
             self.pos = 0;
         }
-        Ok(self.buf.slice(self.pos, self.cap))
+        Ok(self.buf[self.pos..self.cap])
     }
 
     fn consume(&mut self, amt: uint) {
@@ -107,7 +107,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
         let nread = {
             let available = try!(self.fill_buf());
             let nread = cmp::min(available.len(), buf.len());
-            slice::bytes::copy_memory(buf, available.slice_to(nread));
+            slice::bytes::copy_memory(buf, available[..nread]);
             nread
         };
         self.pos += nread;
@@ -162,7 +162,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.as_mut().unwrap().write(self.buf.slice_to(self.pos));
+            let ret = self.inner.as_mut().unwrap().write(self.buf[..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -195,7 +195,7 @@ impl<W: Writer> Writer for BufferedWriter<W> {
         if buf.len() > self.buf.len() {
             self.inner.as_mut().unwrap().write(buf)
         } else {
-            let dst = self.buf.slice_from_mut(self.pos);
+            let dst = self.buf[mut self.pos..];
             slice::bytes::copy_memory(dst, buf);
             self.pos += buf.len();
             Ok(())
@@ -250,9 +250,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == b'\n') {
             Some(i) => {
-                try!(self.inner.write(buf.slice_to(i + 1)));
+                try!(self.inner.write(buf[..i + 1]));
                 try!(self.inner.flush());
-                try!(self.inner.write(buf.slice_from(i + 1)));
+                try!(self.inner.write(buf[i + 1..]));
                 Ok(())
             }
             None => self.inner.write(buf),
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 0a969fc37c9..5bec131f222 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -15,8 +15,7 @@ use comm::{Sender, Receiver};
 use io;
 use option::{None, Option, Some};
 use result::{Ok, Err};
-use slice::{bytes, MutableSlice, ImmutableSlice, CloneableVector};
-use str::StrSlice;
+use slice::{bytes, CloneableVector};
 use super::{Reader, Writer, IoResult};
 use vec::Vec;
 
@@ -62,10 +61,10 @@ impl Reader for ChanReader {
         loop {
             match self.buf {
                 Some(ref prev) => {
-                    let dst = buf.slice_from_mut(num_read);
-                    let src = prev.slice_from(self.pos);
+                    let dst = buf[mut num_read..];
+                    let src = prev[self.pos..];
                     let count = cmp::min(dst.len(), src.len());
-                    bytes::copy_memory(dst, src.slice_to(count));
+                    bytes::copy_memory(dst, src[..count]);
                     num_read += count;
                     self.pos += count;
                 },
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 24cc53e784e..82494d41aa3 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -485,7 +485,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return update_err(Err(e), from, to)
         };
-        try!(writer.write(buf.slice_to(amt)));
+        try!(writer.write(buf[..amt]));
     }
 
     chmod(to, try!(update_err(from.stat(), from, to)).perm)
@@ -1014,7 +1014,7 @@ mod test {
             let mut read_buf = [0, .. 1028];
             let read_str = match check!(read_stream.read(read_buf)) {
                 -1|0 => fail!("shouldn't happen"),
-                n => str::from_utf8(read_buf.slice_to(n)).unwrap().to_string()
+                n => str::from_utf8(read_buf[..n]).unwrap().to_string()
             };
             assert_eq!(read_str.as_slice(), message);
         }
@@ -1061,11 +1061,11 @@ mod test {
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             {
-                let read_buf = read_mem.slice_mut(0, 4);
+                let read_buf = read_mem[mut 0..4];
                 check!(read_stream.read(read_buf));
             }
             {
-                let read_buf = read_mem.slice_mut(4, 8);
+                let read_buf = read_mem[mut 4..8];
                 check!(read_stream.read(read_buf));
             }
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index c826bd16715..ca9692ee158 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -19,7 +19,7 @@ use result::{Err, Ok};
 use io;
 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
 use slice;
-use slice::{Slice, ImmutableSlice, MutableSlice};
+use slice::Slice;
 use vec::Vec;
 
 static BUF_CAPACITY: uint = 128;
@@ -146,8 +146,8 @@ impl Reader for MemReader {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.slice_mut(0, write_len);
+            let input = self.buf[self.pos.. self.pos + write_len];
+            let output = buf[mut ..write_len];
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -174,7 +174,7 @@ impl Buffer for MemReader {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.slice_from(self.pos))
+            Ok(self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -232,7 +232,7 @@ impl<'a> Writer for BufWriter<'a> {
             })
         }
 
-        slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), buf);
+        slice::bytes::copy_memory(self.buf[mut self.pos..], buf);
         self.pos += buf.len();
         Ok(())
     }
@@ -292,8 +292,8 @@ impl<'a> Reader for BufReader<'a> {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.slice_mut(0, write_len);
+            let input = self.buf[self.pos.. self.pos + write_len];
+            let output = buf[mut ..write_len];
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -320,7 +320,7 @@ impl<'a> Buffer for BufReader<'a> {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.slice_from(self.pos))
+            Ok(self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -427,7 +427,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.slice(0, 3), b);
+        assert_eq!(buf[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));
@@ -454,7 +454,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.slice(0, 3), b);
+        assert_eq!(buf[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));
@@ -548,7 +548,7 @@ mod test {
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[1, 2, 3];
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
+        assert!(r.read_at_least(0, buf[mut ..0]).is_ok());
         assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[4, 5, 6];
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index e52a67cc32f..d279b88a1c5 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -235,7 +235,7 @@ use os;
 use boxed::Box;
 use result::{Ok, Err, Result};
 use rt::rtio;
-use slice::{Slice, MutableSlice, ImmutableSlice};
+use slice::{Slice, ImmutableSlice};
 use str::{Str, StrSlice};
 use str;
 use string::String;
@@ -575,7 +575,7 @@ pub trait Reader {
         while read < min {
             let mut zeroes = 0;
             loop {
-                match self.read(buf.slice_from_mut(read)) {
+                match self.read(buf[mut read..]) {
                     Ok(0) => {
                         zeroes += 1;
                         if zeroes >= NO_PROGRESS_LIMIT {
@@ -1111,8 +1111,8 @@ pub trait Writer {
     #[inline]
     fn write_char(&mut self, c: char) -> IoResult<()> {
         let mut buf = [0u8, ..4];
-        let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        self.write(buf.slice_to(n))
+        let n = c.encode_utf8(buf[mut]).unwrap_or(0);
+        self.write(buf[..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1496,7 +1496,7 @@ pub trait Buffer: Reader {
                 };
                 match available.iter().position(|&b| b == byte) {
                     Some(i) => {
-                        res.push_all(available.slice_to(i + 1));
+                        res.push_all(available[..i + 1]);
                         used = i + 1;
                         break
                     }
@@ -1528,14 +1528,14 @@ pub trait Buffer: Reader {
         {
             let mut start = 1;
             while start < width {
-                match try!(self.read(buf.slice_mut(start, width))) {
+                match try!(self.read(buf[mut start..width])) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }
                     _ => return Err(standard_error(InvalidInput)),
                 }
             }
         }
-        match str::from_utf8(buf.slice_to(width)) {
+        match str::from_utf8(buf[..width]) {
             Some(s) => Ok(s.char_at(0)),
             None => Err(standard_error(InvalidInput))
         }
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index 6eb7d1c02fb..5140159e4ea 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -21,7 +21,7 @@ use from_str::FromStr;
 use iter::Iterator;
 use option::{Option, None, Some};
 use str::StrSlice;
-use slice::{MutableCloneableSlice, ImmutableSlice, MutableSlice};
+use slice::{MutableCloneableSlice, MutableSlice};
 
 pub type Port = u16;
 
@@ -241,7 +241,7 @@ impl<'a> Parser<'a> {
             assert!(head.len() + tail.len() <= 8);
             let mut gs = [0u16, ..8];
             gs.clone_from_slice(head);
-            gs.slice_mut(8 - tail.len(), 8).clone_from_slice(tail);
+            gs[mut 8 - tail.len() .. 8].clone_from_slice(tail);
             Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
         }
 
@@ -303,7 +303,7 @@ impl<'a> Parser<'a> {
 
         let mut tail = [0u16, ..8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
-        Some(ipv6_addr_from_head_tail(head.slice(0, head_size), tail.slice(0, tail_size)))
+        Some(ipv6_addr_from_head_tail(head[..head_size], tail[..tail_size]))
     }
 
     fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 3ba8765fc3e..4dd6f448ee5 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -48,7 +48,7 @@ use rt::rtio;
 /// match socket.recv_from(buf) {
 ///     Ok((amt, src)) => {
 ///         // Send a reply to the socket we received data from
-///         let buf = buf.slice_to_mut(amt);
+///         let buf = buf[mut ..amt];
 ///         buf.reverse();
 ///         socket.send_to(buf, src);
 ///     }
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 16ac8c4c265..820ae931f32 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -47,7 +47,7 @@ impl<R: Reader> Reader for LimitReader<R> {
         }
 
         let len = cmp::min(self.limit, buf.len());
-        let res = self.inner.read(buf.slice_to_mut(len));
+        let res = self.inner.read(buf[mut ..len]);
         match res {
             Ok(len) => self.limit -= len,
             _ => {}
@@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> {
 impl<R: Buffer> Buffer for LimitReader<R> {
     fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
         let amt = try!(self.inner.fill_buf());
-        let buf = amt.slice_to(cmp::min(amt.len(), self.limit));
+        let buf = amt[..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
@@ -216,7 +216,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         self.reader.read(buf).and_then(|len| {
-            self.writer.write(buf.slice_to(len)).map(|()| len)
+            self.writer.write(buf[mut ..len]).map(|()| len)
         })
     }
 }
@@ -230,7 +230,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        try!(w.write(buf.slice_to(len)));
+        try!(w.write(buf[..len]));
     }
 }
 
diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs
index f5b2f31a127..9e4cc06f0a2 100644
--- a/src/libstd/num/i16.rs
+++ b/src/libstd/num/i16.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i16::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs
index 623a10725c8..54259fcad55 100644
--- a/src/libstd/num/i32.rs
+++ b/src/libstd/num/i32.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i32::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs
index ffb1307908c..b5fe6825ca4 100644
--- a/src/libstd/num/i64.rs
+++ b/src/libstd/num/i64.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i64::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs
index 4fbb7381238..7aa9a41e340 100644
--- a/src/libstd/num/i8.rs
+++ b/src/libstd/num/i8.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i8::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs
index 7821306f5fc..74ee61634c6 100644
--- a/src/libstd/num/int.rs
+++ b/src/libstd/num/int.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::int::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 3c01edf2339..62e609bb2e1 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -78,7 +78,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
         wr.tell().unwrap() as uint
     };
-    f(buf.slice(0, amt))
+    f(buf[..amt])
 }
 
 #[deprecated = "use fmt::radix"]
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b15f334e233..f97bbe0dc8e 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -730,7 +730,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+
         // parse remaining bytes as decimal integer,
         // skipping the exponent char
         let exp: Option<int> = from_str_bytes_common(
-            buf.slice(i+1, len), 10, true, false, false, ExpNone, false,
+            buf[i+1..len], 10, true, false, false, ExpNone, false,
             ignore_underscores);
 
         match exp {
diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs
index 0f00f99e980..c141ecc9cba 100644
--- a/src/libstd/num/u16.rs
+++ b/src/libstd/num/u16.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u16::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs
index e6c6bc377b7..8a8e2729a53 100644
--- a/src/libstd/num/u32.rs
+++ b/src/libstd/num/u32.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u32::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs
index 7eb9e1a082f..1b4f8bc433f 100644
--- a/src/libstd/num/u64.rs
+++ b/src/libstd/num/u64.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u64::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs
index 300dd3bcc01..28f22429235 100644
--- a/src/libstd/num/u8.rs
+++ b/src/libstd/num/u8.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u8::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 0adc22e3214..da328074453 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::uint::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index cfcaf0fa8da..a033308af16 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -79,7 +79,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
         wr.tell().unwrap() as uint
     };
-    f(buf.slice(0, amt))
+    f(buf[..amt])
 }
 
 #[deprecated = "use fmt::radix"]
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index d904e657e40..c6948cccafe 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -144,7 +144,7 @@ pub mod windows {
     use option::{None, Option};
     use option;
     use os::TMPBUF_SZ;
-    use slice::{MutableSlice, ImmutableSlice};
+    use slice::MutableSlice;
     use string::String;
     use str::StrSlice;
     use vec::Vec;
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 16552daae36..63c81695aff 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -357,7 +357,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => name,
                     Some(1) if name == b".." => name,
-                    Some(pos) => name.slice_to(pos)
+                    Some(pos) => name[..pos]
                 }
             })
         }
@@ -404,7 +404,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => None,
                     Some(1) if name == b".." => None,
-                    Some(pos) => Some(name.slice_from(pos+1))
+                    Some(pos) => Some(name[pos+1..])
                 }
             }
         }
@@ -480,7 +480,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             let extlen = extension.container_as_bytes().len();
             match (name.rposition_elem(&dot), extlen) {
                 (None, 0) | (Some(0), 0) => None,
-                (Some(idx), 0) => Some(name.slice_to(idx).to_vec()),
+                (Some(idx), 0) => Some(name[..idx].to_vec()),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
@@ -489,7 +489,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 
                     let mut v;
                     v = Vec::with_capacity(idx + extlen + 1);
-                    v.push_all(name.slice_to(idx));
+                    v.push_all(name[..idx]);
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
                     Some(v)
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 805db000686..2425b40fef4 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -165,7 +165,7 @@ impl GenericPathUnsafe for Path {
             None => {
                 self.repr = Path::normalize(filename);
             }
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => {
+            Some(idx) if self.repr[idx+1..] == b".." => {
                 let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
                 v.push_all(self.repr.as_slice());
                 v.push(SEP_BYTE);
@@ -175,7 +175,7 @@ impl GenericPathUnsafe for Path {
             }
             Some(idx) => {
                 let mut v = Vec::with_capacity(idx + 1 + filename.len());
-                v.push_all(self.repr.slice_to(idx+1));
+                v.push_all(self.repr[..idx+1]);
                 v.push_all(filename);
                 // FIXME: this is slow
                 self.repr = Path::normalize(v.as_slice());
@@ -216,9 +216,9 @@ impl GenericPath for Path {
         match self.sepidx {
             None if b".." == self.repr.as_slice() => self.repr.as_slice(),
             None => dot_static,
-            Some(0) => self.repr.slice_to(1),
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => self.repr.as_slice(),
-            Some(idx) => self.repr.slice_to(idx)
+            Some(0) => self.repr[..1],
+            Some(idx) if self.repr[idx+1..] == b".." => self.repr.as_slice(),
+            Some(idx) => self.repr[..idx]
         }
     }
 
@@ -227,9 +227,9 @@ impl GenericPath for Path {
             None if b"." == self.repr.as_slice() ||
                 b".." == self.repr.as_slice() => None,
             None => Some(self.repr.as_slice()),
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => None,
-            Some(0) if self.repr.slice_from(1).is_empty() => None,
-            Some(idx) => Some(self.repr.slice_from(idx+1))
+            Some(idx) if self.repr[idx+1..] == b".." => None,
+            Some(0) if self.repr[1..].is_empty() => None,
+            Some(idx) => Some(self.repr[idx+1..])
         }
     }
 
@@ -371,7 +371,7 @@ impl Path {
         // borrowck is being very picky
         let val = {
             let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
-            let v_ = if is_abs { v.as_slice().slice_from(1) } else { v.as_slice() };
+            let v_ = if is_abs { v.as_slice()[1..] } else { v.as_slice() };
             let comps = normalize_helper(v_, is_abs);
             match comps {
                 None => None,
@@ -410,7 +410,7 @@ impl Path {
     /// A path of "/" yields no components. A path of "." yields one component.
     pub fn components<'a>(&'a self) -> Components<'a> {
         let v = if self.repr[0] == SEP_BYTE {
-            self.repr.slice_from(1)
+            self.repr[1..]
         } else { self.repr.as_slice() };
         let mut ret = v.split(is_sep_byte);
         if v.is_empty() {
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 33f8713e1a1..e1925fc79d0 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -999,7 +999,7 @@ mod imp {
                 let bytes = cstr.as_bytes();
                 match cstr.as_str() {
                     Some(s) => try!(super::demangle(w, s)),
-                    None => try!(w.write(bytes.slice_to(bytes.len() - 1))),
+                    None => try!(w.write(bytes[..bytes.len()-1])),
                 }
             }
             try!(w.write(['\n' as u8]));