use slicing sugar

7 files changed, 31 insertions, 33 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 74c503e6f2b..ba13bd05dc5 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -15,7 +15,7 @@
 use cmp;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::{IteratorExt, ExactSizeIterator};
-use ops::{Drop, Index};
+use ops::Drop;
 use option::Option;
 use option::Option::{Some, None};
 use result::Result::Ok;
@@ -97,7 +97,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
             self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
             self.pos = 0;
         }
-        Ok(self.buf.index(&(self.pos..self.cap)))
+        Ok(&self.buf[self.pos..self.cap])
     }
 
     fn consume(&mut self, amt: uint) {
@@ -114,7 +114,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.index(&(0..nread)));
+            slice::bytes::copy_memory(buf, &available[0..nread]);
             nread
         };
         self.pos += nread;
@@ -168,7 +168,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.index(&(0..self.pos)));
+            let ret = self.inner.as_mut().unwrap().write(&self.buf[0..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -260,9 +260,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.index(&(0..(i + 1)))));
+                try!(self.inner.write(&buf[0..(i + 1)]));
                 try!(self.inner.flush());
-                try!(self.inner.write(buf.index(&((i + 1)..))));
+                try!(self.inner.write(&buf[(i + 1)..]));
                 Ok(())
             }
             None => self.inner.write(buf),
@@ -510,7 +510,7 @@ mod test {
         assert_eq!(a, &w.get_ref()[]);
         let w = w.into_inner();
         let a: &[_] = &[0, 1];
-        assert_eq!(a, w.index(&FullRange));
+        assert_eq!(a, &w[]);
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -607,14 +607,14 @@ mod test {
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &buf[]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &buf[]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index bce097e17ef..b578f4d5adc 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -13,7 +13,6 @@ use cmp;
 use sync::mpsc::{Sender, Receiver};
 use io;
 use option::Option::{None, Some};
-use ops::Index;
 use result::Result::{Ok, Err};
 use slice::{bytes, SliceExt};
 use super::{Buffer, Reader, Writer, IoResult};
@@ -91,7 +90,7 @@ impl Reader for ChanReader {
                 Some(src) => {
                     let dst = buf.slice_from_mut(num_read);
                     let count = cmp::min(src.len(), dst.len());
-                    bytes::copy_memory(dst, src.index(&(0..count)));
+                    bytes::copy_memory(dst, &src[0..count]);
                     count
                 },
                 None => 0,
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index eadca8e42e5..dbccc81c4cc 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -889,7 +889,7 @@ mod test {
             let mut read_buf = [0; 1028];
             let read_str = match check!(read_stream.read(&mut read_buf)) {
                 -1|0 => panic!("shouldn't happen"),
-                n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string()
+                n => str::from_utf8(&read_buf[0..n]).unwrap().to_string()
             };
             assert_eq!(read_str.as_slice(), message);
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 9a6ad04fdbc..c5e289398e0 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -13,7 +13,6 @@
 //! Readers and Writers for in-memory buffers
 
 use cmp::min;
-use ops::Index;
 use option::Option::None;
 use result::Result::{Err, Ok};
 use io;
@@ -160,7 +159,7 @@ impl Reader for MemReader {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -188,7 +187,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.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -205,7 +204,7 @@ impl<'a> Reader for &'a [u8] {
 
         let write_len = min(buf.len(), self.len());
         {
-            let input = self.index(&(0..write_len));
+            let input = &self[0..write_len];
             let output = buf.slice_to_mut(write_len);
             slice::bytes::copy_memory(output, input);
         }
@@ -228,7 +227,7 @@ impl<'a> Buffer for &'a [u8] {
 
     #[inline]
     fn consume(&mut self, amt: uint) {
-        *self = self.index(&(amt..));
+        *self = &self[amt..];
     }
 }
 
@@ -287,7 +286,7 @@ impl<'a> Writer for BufWriter<'a> {
 
             Ok(())
         } else {
-            slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
+            slice::bytes::copy_memory(dst, &src[0..dst_len]);
 
             self.pos += dst_len;
 
@@ -350,7 +349,7 @@ impl<'a> Reader for BufReader<'a> {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -378,7 +377,7 @@ impl<'a> Buffer for BufReader<'a> {
     #[inline]
     fn fill_buf(&mut self) -> IoResult<&[u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -393,7 +392,7 @@ mod test {
     extern crate "test" as test_crate;
     use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
     use prelude::v1::{Ok, Err, range,  Vec, Buffer,  AsSlice, SliceExt};
-    use prelude::v1::{IteratorExt, Index};
+    use prelude::v1::IteratorExt;
     use io;
     use iter::repeat;
     use self::test_crate::Bencher;
@@ -499,7 +498,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut 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));
@@ -525,7 +524,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = &mut in_buf.as_slice();
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -552,7 +551,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 2595a3c44a8..c71ab514695 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -236,7 +236,7 @@ use int;
 use iter::{Iterator, IteratorExt};
 use marker::Sized;
 use mem::transmute;
-use ops::{FnOnce, Index};
+use ops::FnOnce;
 use option::Option;
 use option::Option::{Some, None};
 use os;
@@ -1069,7 +1069,7 @@ pub trait Writer {
     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.index(&(0..n)))
+        self.write(&buf[0..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1454,7 +1454,7 @@ pub trait Buffer: Reader {
                 };
                 match available.iter().position(|&b| b == byte) {
                     Some(i) => {
-                        res.push_all(available.index(&(0..(i + 1))));
+                        res.push_all(&available[0..(i + 1)]);
                         used = i + 1;
                         break
                     }
@@ -1493,7 +1493,7 @@ pub trait Buffer: Reader {
                 }
             }
         }
-        match str::from_utf8(buf.index(&(0..width))).ok() {
+        match str::from_utf8(&buf[0..width]).ok() {
             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 b9f653f86c2..d09afea94dc 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -22,7 +22,7 @@ use fmt;
 use io::{self, IoResult, IoError};
 use io::net;
 use iter::{Iterator, IteratorExt};
-use ops::{FnOnce, FnMut, Index};
+use ops::{FnOnce, FnMut};
 use option::Option;
 use option::Option::{None, Some};
 use result::Result::{Ok, Err};
@@ -313,7 +313,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.index(&(0..head_size)), tail.index(&(0..tail_size))))
+        Some(ipv6_addr_from_head_tail(&head[0..head_size], &tail[0..tail_size]))
     }
 
     fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index c0254a3e7a2..5a7219495f5 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -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.index(&(0..cmp::min(amt.len(), self.limit)));
+        let buf = &amt[0..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
@@ -220,7 +220,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.index_mut(&(0..len))).map(|()| len)
+            self.writer.write(&mut buf[0..len]).map(|()| len)
         })
     }
 }
@@ -234,7 +234,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.index(&(0..len))));
+        try!(w.write(&buf[0..len]));
     }
 }