Replace full slice notation with index calls

3 files changed, 80 insertions, 77 deletions

diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index b020164158c..021aae5a601 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,6 +68,7 @@ use fmt;
 use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
+use prelude::{FullRange, Index};
 use str;
 use str::StrExt;
 use string::{String, CowString};
@@ -351,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => name,
                     Some(1) if name == b".." => name,
-                    Some(pos) => name[..pos]
+                    Some(pos) => name.index(&(0..pos))
                 }
             })
         }
@@ -398,7 +399,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[pos+1..])
+                    Some(pos) => Some(name.index(&((pos+1)..)))
                 }
             }
         }
@@ -474,7 +475,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[..idx].to_vec()),
+                (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
@@ -483,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 
                     let mut v;
                     v = Vec::with_capacity(idx + extlen + 1);
-                    v.push_all(name[..idx]);
+                    v.push_all(name.index(&(0..idx)));
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
                     Some(v)
@@ -869,7 +870,7 @@ impl BytesContainer for String {
     }
     #[inline]
     fn container_as_str(&self) -> Option<&str> {
-        Some(self[])
+        Some(self.index(&FullRange))
     }
     #[inline]
     fn is_str(_: Option<&String>) -> bool { true }
@@ -885,7 +886,7 @@ impl BytesContainer for [u8] {
 impl BytesContainer for Vec<u8> {
     #[inline]
     fn container_as_bytes(&self) -> &[u8] {
-        self[]
+        self.index(&FullRange)
     }
 }
 
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index d9981ace030..7f37d3b23c8 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -16,6 +16,7 @@ use hash;
 use io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
+use prelude::v1::Index;
 use kinds::Sized;
 use option::Option::{self, Some, None};
 use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
@@ -119,7 +120,7 @@ impl GenericPathUnsafe for Path {
             None => {
                 self.repr = Path::normalize(filename);
             }
-            Some(idx) if self.repr[idx+1..] == b".." => {
+            Some(idx) if self.repr.index(&((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);
@@ -129,7 +130,7 @@ impl GenericPathUnsafe for Path {
             }
             Some(idx) => {
                 let mut v = Vec::with_capacity(idx + 1 + filename.len());
-                v.push_all(self.repr[..idx+1]);
+                v.push_all(self.repr.index(&(0..(idx+1))));
                 v.push_all(filename);
                 // FIXME: this is slow
                 self.repr = Path::normalize(v.as_slice());
@@ -170,9 +171,9 @@ impl GenericPath for Path {
         match self.sepidx {
             None if b".." == self.repr => self.repr.as_slice(),
             None => dot_static,
-            Some(0) => self.repr[..1],
-            Some(idx) if self.repr[idx+1..] == b".." => self.repr.as_slice(),
-            Some(idx) => self.repr[..idx]
+            Some(0) => self.repr.index(&(0..1)),
+            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(),
+            Some(idx) => self.repr.index(&(0..idx))
         }
     }
 
@@ -181,9 +182,9 @@ impl GenericPath for Path {
             None if b"." == self.repr ||
                 b".." == self.repr => None,
             None => Some(self.repr.as_slice()),
-            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..])
+            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None,
+            Some(0) if self.repr.index(&(1..)).is_empty() => None,
+            Some(idx) => Some(self.repr.index(&((idx+1)..)))
         }
     }
 
@@ -325,7 +326,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()[1..] } else { v.as_slice() };
+            let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() };
             let comps = normalize_helper(v_, is_abs);
             match comps {
                 None => None,
@@ -364,7 +365,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[1..]
+            self.repr.index(&(1..))
         } else { self.repr.as_slice() };
         let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr
         let mut ret = v.split(is_sep_byte);
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 4b5d793355b..d469bb4d767 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -24,6 +24,7 @@ use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option::{self, Some, None};
+use prelude::{FullRange, Index};
 use slice::{SliceExt, SliceConcatExt};
 use str::{SplitTerminator, FromStr, StrExt};
 use string::{String, ToString};
@@ -165,30 +166,30 @@ impl GenericPathUnsafe for Path {
                 s.push_str("..");
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s[]);
+                self.update_normalized(s.index(&FullRange));
             }
             None => {
                 self.update_normalized(filename);
             }
-            Some((_,idxa,end)) if self.repr[idxa..end] == ".." => {
+            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
                 let mut s = String::with_capacity(end + 1 + filename.len());
-                s.push_str(self.repr[0..end]);
+                s.push_str(self.repr.index(&(0..end)));
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s[]);
+                self.update_normalized(s.index(&FullRange));
             }
             Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
                 let mut s = String::with_capacity(idxb + filename.len());
-                s.push_str(self.repr[0..idxb]);
+                s.push_str(self.repr.index(&(0..idxb)));
                 s.push_str(filename);
-                self.update_normalized(s[]);
+                self.update_normalized(s.index(&FullRange));
             }
             Some((idxb,_,_)) => {
                 let mut s = String::with_capacity(idxb + 1 + filename.len());
-                s.push_str(self.repr[0..idxb]);
+                s.push_str(self.repr.index(&(0..idxb)));
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s[]);
+                self.update_normalized(s.index(&FullRange));
             }
         }
     }
@@ -207,12 +208,12 @@ impl GenericPathUnsafe for Path {
         let path = path.container_as_str().unwrap();
         fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
             // assume prefix is Some(DiskPrefix)
-            let rest = path[prefix_len(prefix)..];
+            let rest = path.index(&(prefix_len(prefix)..));
             !rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
         }
         fn shares_volume(me: &Path, path: &str) -> bool {
             // path is assumed to have a prefix of Some(DiskPrefix)
-            let repr = me.repr[];
+            let repr = me.repr.index(&FullRange);
             match me.prefix {
                 Some(DiskPrefix) => {
                     repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
@@ -244,7 +245,7 @@ impl GenericPathUnsafe for Path {
                         else { None };
             let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
             let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
-            s.push_str(me.repr[]);
+            s.push_str(me.repr.index(&FullRange));
             let plen = me.prefix_len();
             // if me is "C:" we don't want to add a path separator
             match me.prefix {
@@ -256,9 +257,9 @@ impl GenericPathUnsafe for Path {
             }
             match path_ {
                 None => s.push_str(path),
-                Some(p) => s.push_str(p[]),
+                Some(p) => s.push_str(p.index(&FullRange)),
             };
-            me.update_normalized(s[])
+            me.update_normalized(s.index(&FullRange))
         }
 
         if !path.is_empty() {
@@ -266,7 +267,7 @@ impl GenericPathUnsafe for Path {
             match prefix {
                 Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
                     // cwd-relative path, self is on the same volume
-                    append_path(self, path[prefix_len(prefix)..]);
+                    append_path(self, path.index(&(prefix_len(prefix)..)));
                 }
                 Some(_) => {
                     // absolute path, or cwd-relative and self is not same volume
@@ -312,7 +313,7 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     #[inline]
     fn as_str<'a>(&'a self) -> Option<&'a str> {
-        Some(self.repr[])
+        Some(self.repr.index(&FullRange))
     }
 
     #[inline]
@@ -334,17 +335,17 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     fn dirname_str<'a>(&'a self) -> Option<&'a str> {
         Some(match self.sepidx_or_prefix_len() {
-            None if ".." == self.repr => self.repr[],
+            None if ".." == self.repr => self.repr.index(&FullRange),
             None => ".",
-            Some((_,idxa,end)) if self.repr[idxa..end] == ".." => self.repr[],
-            Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => self.repr[],
-            Some((0,idxa,_)) => self.repr[0..idxa],
+            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => self.repr.index(&FullRange),
+            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => self.repr.index(&FullRange),
+            Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
             Some((idxb,idxa,_)) => {
                 match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
-                        self.repr[0..idxa]
+                        self.repr.index(&(0..idxa))
                     }
-                    _ => self.repr[0..idxb]
+                    _ => self.repr.index(&(0..idxb))
                 }
             }
         })
@@ -358,13 +359,13 @@ impl GenericPath for Path {
     /// See `GenericPath::filename_str` for info.
     /// Always returns a `Some` value if `filename` returns a `Some` value.
     fn filename_str<'a>(&'a self) -> Option<&'a str> {
-        let repr = self.repr[];
+        let repr = self.repr.index(&FullRange);
         match self.sepidx_or_prefix_len() {
             None if "." == repr || ".." == repr => None,
             None => Some(repr),
-            Some((_,idxa,end)) if repr[idxa..end] == ".." => None,
+            Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
             Some((_,idxa,end)) if idxa == end => None,
-            Some((_,idxa,end)) => Some(repr[idxa..end])
+            Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
         }
     }
 
@@ -396,7 +397,7 @@ impl GenericPath for Path {
                 true
             }
             Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
-            Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => false,
+            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
             Some((idxb,idxa,_)) => {
                 let trunc = match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
@@ -416,15 +417,15 @@ impl GenericPath for Path {
         if self.prefix.is_some() {
             Some(Path::new(match self.prefix {
                 Some(DiskPrefix) if self.is_absolute() => {
-                    self.repr[0..self.prefix_len()+1]
+                    self.repr.index(&(0..(self.prefix_len()+1)))
                 }
                 Some(VerbatimDiskPrefix) => {
-                    self.repr[0..self.prefix_len()+1]
+                    self.repr.index(&(0..(self.prefix_len()+1)))
                 }
-                _ => self.repr[0..self.prefix_len()]
+                _ => self.repr.index(&(0..self.prefix_len()))
             }))
         } else if is_vol_relative(self) {
-            Some(Path::new(self.repr[0..1]))
+            Some(Path::new(self.repr.index(&(0..1))))
         } else {
             None
         }
@@ -443,7 +444,7 @@ impl GenericPath for Path {
     fn is_absolute(&self) -> bool {
         match self.prefix {
             Some(DiskPrefix) => {
-                let rest = self.repr[self.prefix_len()..];
+                let rest = self.repr.index(&(self.prefix_len()..));
                 rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
             }
             Some(_) => true,
@@ -618,15 +619,15 @@ impl Path {
     /// Does not distinguish between absolute and cwd-relative paths, e.g.
     /// C:\foo and C:foo.
     pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
-        let repr = self.repr[];
+        let repr = self.repr.index(&FullRange);
         let s = match self.prefix {
             Some(_) => {
                 let plen = self.prefix_len();
                 if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
-                    repr[plen+1..]
-                } else { repr[plen..] }
+                    repr.index(&((plen+1)..))
+                } else { repr.index(&(plen..)) }
             }
-            None if repr.as_bytes()[0] == SEP_BYTE => repr[1..],
+            None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
             None => repr
         };
         let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
@@ -646,8 +647,8 @@ impl Path {
     }
 
     fn equiv_prefix(&self, other: &Path) -> bool {
-        let s_repr = self.repr[];
-        let o_repr = other.repr[];
+        let s_repr = self.repr.index(&FullRange);
+        let o_repr = other.repr.index(&FullRange);
         match (self.prefix, other.prefix) {
             (Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
                 self.is_absolute() &&
@@ -664,14 +665,14 @@ impl Path {
                     o_repr.as_bytes()[4].to_ascii_lowercase()
             }
             (Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
-                s_repr[2..self.prefix_len()] == o_repr[8..other.prefix_len()]
+                s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
             }
             (Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
-                s_repr[8..self.prefix_len()] == o_repr[2..other.prefix_len()]
+                s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
             }
             (None, None) => true,
             (a, b) if a == b => {
-                s_repr[0..self.prefix_len()] == o_repr[0..other.prefix_len()]
+                s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
             }
             _ => false
         }
@@ -725,7 +726,7 @@ impl Path {
                         match prefix.unwrap() {
                             DiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s[0..len]);
+                                let mut s = String::from_str(s.index(&(0..len)));
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[0] = (*v)[0].to_ascii_uppercase();
@@ -740,7 +741,7 @@ impl Path {
                             }
                             VerbatimDiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s[0..len]);
+                                let mut s = String::from_str(s.index(&(0..len)));
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[4] = (*v)[4].to_ascii_uppercase();
@@ -750,14 +751,14 @@ impl Path {
                             _ => {
                                 let plen = prefix_len(prefix);
                                 if s.len() > plen {
-                                    Some(String::from_str(s[0..plen]))
+                                    Some(String::from_str(s.index(&(0..plen))))
                                 } else { None }
                             }
                         }
                     } else if is_abs && comps.is_empty() {
                         Some(repeat(SEP).take(1).collect())
                     } else {
-                        let prefix_ = s[0..prefix_len(prefix)];
+                        let prefix_ = s.index(&(0..prefix_len(prefix)));
                         let n = prefix_.len() +
                                 if is_abs { comps.len() } else { comps.len() - 1} +
                                 comps.iter().map(|v| v.len()).sum();
@@ -768,15 +769,15 @@ impl Path {
                                 s.push(':');
                             }
                             Some(VerbatimDiskPrefix) => {
-                                s.push_str(prefix_[0..4]);
+                                s.push_str(prefix_.index(&(0..4)));
                                 s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
-                                s.push_str(prefix_[5..]);
+                                s.push_str(prefix_.index(&(5..)));
                             }
                             Some(UNCPrefix(a,b)) => {
                                 s.push_str("\\\\");
-                                s.push_str(prefix_[2..a+2]);
+                                s.push_str(prefix_.index(&(2..(a+2))));
                                 s.push(SEP);
-                                s.push_str(prefix_[3+a..3+a+b]);
+                                s.push_str(prefix_.index(&((3+a)..(3+a+b))));
                             }
                             Some(_) => s.push_str(prefix_),
                             None => ()
@@ -801,8 +802,8 @@ impl Path {
 
     fn update_sepidx(&mut self) {
         let s = if self.has_nonsemantic_trailing_slash() {
-                    self.repr[0..self.repr.len()-1]
-                } else { self.repr[] };
+                    self.repr.index(&(0..(self.repr.len()-1)))
+                } else { self.repr.index(&FullRange) };
         let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
             is_sep
         } else {
@@ -881,17 +882,17 @@ pub fn is_verbatim(path: &Path) -> bool {
 /// non-verbatim, the non-verbatim version is returned.
 /// Otherwise, None is returned.
 pub fn make_non_verbatim(path: &Path) -> Option<Path> {
-    let repr = path.repr[];
+    let repr = path.repr.index(&FullRange);
     let new_path = match path.prefix {
         Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
         Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
         Some(VerbatimDiskPrefix) => {
             // \\?\D:\
-            Path::new(repr[4..])
+            Path::new(repr.index(&(4..)))
         }
         Some(VerbatimUNCPrefix(_,_)) => {
             // \\?\UNC\server\share
-            Path::new(format!(r"\{}", repr[7..]))
+            Path::new(format!(r"\{}", repr.index(&(7..))))
         }
     };
     if new_path.prefix.is_none() {
@@ -900,8 +901,8 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> {
         return None;
     }
     // now ensure normalization didn't change anything
-    if repr[path.prefix_len()..] ==
-        new_path.repr[new_path.prefix_len()..] {
+    if repr.index(&(path.prefix_len()..)) ==
+        new_path.repr.index(&(new_path.prefix_len()..)) {
         Some(new_path)
     } else {
         None
@@ -966,13 +967,13 @@ pub enum PathPrefix {
 fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
     if path.starts_with("\\\\") {
         // \\
-        path = path[2..];
+        path = path.index(&(2..));
         if path.starts_with("?\\") {
             // \\?\
-            path = path[2..];
+            path = path.index(&(2..));
             if path.starts_with("UNC\\") {
                 // \\?\UNC\server\share
-                path = path[4..];
+                path = path.index(&(4..));
                 let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
                     Some(x) => x,
                     None => (path.len(), 0)
@@ -993,7 +994,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             }
         } else if path.starts_with(".\\") {
             // \\.\path
-            path = path[2..];
+            path = path.index(&(2..));
             let idx = path.find('\\').unwrap_or(path.len());
             return Some(DeviceNSPrefix(idx));
         }
@@ -1018,7 +1019,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             None => return None,
             Some(x) => x
         };
-        path = path[idx_a+1..];
+        path = path.index(&((idx_a+1)..));
         let idx_b = path.find(f).unwrap_or(path.len());
         Some((idx_a, idx_b))
     }
@@ -1032,8 +1033,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option
         is_sep_verbatim
     };
     let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
-    let s_ = s[prefix_len(prefix)..];
-    let s_ = if is_abs { s_[1..] } else { s_ };
+    let s_ = s.index(&(prefix_len(prefix)..));
+    let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
 
     if is_abs && s_.is_empty() {
         return (is_abs, match prefix {