Replace full slice notation with index calls

5 files changed, 43 insertions, 41 deletions

diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs
index d29a7a425c1..5803da1d335 100644
--- a/src/libregex/compile.rs
+++ b/src/libregex/compile.rs
@@ -105,7 +105,7 @@ impl Program {
         // This is a bit hacky since we have to skip over the initial
         // 'Save' instruction.
         let mut pre = String::with_capacity(5);
-        for inst in c.insts[1..].iter() {
+        for inst in c.insts.index(&(1..)).iter() {
             match *inst {
                 OneChar(c, FLAG_EMPTY) => pre.push(c),
                 _ => break
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 07da86afcc9..2d46fa1143e 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -18,6 +18,7 @@ use std::cmp;
 use std::fmt;
 use std::iter;
 use std::num;
+use std::ops::Index;
 
 /// Static data containing Unicode ranges for general categories and scripts.
 use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
@@ -285,7 +286,7 @@ impl<'a> Parser<'a> {
             true => Ok(()),
             false => {
                 self.err(format!("Expected {} but got EOF.",
-                                 expected)[])
+                                 expected).index(&FullRange))
             }
         }
     }
@@ -294,10 +295,10 @@ impl<'a> Parser<'a> {
         match self.next_char() {
             true if self.cur() == expected => Ok(()),
             true => self.err(format!("Expected '{}' but got '{}'.",
-                                     expected, self.cur())[]),
+                                     expected, self.cur()).index(&FullRange)),
             false => {
                 self.err(format!("Expected '{}' but got EOF.",
-                                 expected)[])
+                                 expected).index(&FullRange))
             }
         }
     }
@@ -443,14 +444,14 @@ impl<'a> Parser<'a> {
                         Literal(c3, _) => c2 = c3, // allow literal escapes below
                         ast =>
                             return self.err(format!("Expected a literal, but got {}.",
-                                                    ast)[]),
+                                                    ast).index(&FullRange)),
                     }
                 }
                 if c2 < c {
                     return self.err(format!("Invalid character class \
                                              range '{}-{}'",
                                             c,
-                                            c2)[])
+                                            c2).index(&FullRange))
                 }
                 ranges.push((c, self.cur()))
             } else {
@@ -488,7 +489,7 @@ impl<'a> Parser<'a> {
                 FLAG_EMPTY
             };
         let name = self.slice(name_start, closer - 1);
-        match find_class(ASCII_CLASSES, name[]) {
+        match find_class(ASCII_CLASSES, name.index(&FullRange)) {
             None => None,
             Some(ranges) => {
                 self.chari = closer;
@@ -513,18 +514,18 @@ impl<'a> Parser<'a> {
                     return self.err(format!("No closing brace for counted \
                                              repetition starting at position \
                                              {}.",
-                                            start)[])
+                                            start).index(&FullRange))
                 }
             };
         self.chari = closer;
         let greed = try!(self.get_next_greedy());
-        let inner = self.chars[start+1..closer].iter().cloned()
+        let inner = self.chars.index(&((start+1)..closer)).iter().cloned()
                                                .collect::<String>();
 
         // Parse the min and max values from the regex.
         let (mut min, mut max): (uint, Option<uint>);
         if !inner.contains(",") {
-            min = try!(self.parse_uint(inner[]));
+            min = try!(self.parse_uint(inner.index(&FullRange)));
             max = Some(min);
         } else {
             let pieces: Vec<&str> = inner.splitn(1, ',').collect();
@@ -546,19 +547,19 @@ impl<'a> Parser<'a> {
         if min > MAX_REPEAT {
             return self.err(format!(
                 "{} exceeds maximum allowed repetitions ({})",
-                min, MAX_REPEAT)[]);
+                min, MAX_REPEAT).index(&FullRange));
         }
         if max.is_some() {
             let m = max.unwrap();
             if m > MAX_REPEAT {
                 return self.err(format!(
                     "{} exceeds maximum allowed repetitions ({})",
-                    m, MAX_REPEAT)[]);
+                    m, MAX_REPEAT).index(&FullRange));
             }
             if m < min {
                 return self.err(format!(
                     "Max repetitions ({}) cannot be smaller than min \
-                     repetitions ({}).", m, min)[]);
+                     repetitions ({}).", m, min).index(&FullRange));
             }
         }
 
@@ -622,7 +623,7 @@ impl<'a> Parser<'a> {
                 Ok(AstClass(ranges, flags))
             }
             _ => {
-                self.err(format!("Invalid escape sequence '\\\\{}'", c)[])
+                self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
             }
         }
     }
@@ -642,7 +643,7 @@ impl<'a> Parser<'a> {
                     Some(i) => i,
                     None => return self.err(format!(
                         "Missing '}}' for unclosed '{{' at position {}",
-                        self.chari)[]),
+                        self.chari).index(&FullRange)),
                 };
             if closer - self.chari + 1 == 0 {
                 return self.err("No Unicode class name found.")
@@ -656,10 +657,10 @@ impl<'a> Parser<'a> {
             name = self.slice(self.chari + 1, self.chari + 2);
             self.chari += 1;
         }
-        match find_class(UNICODE_CLASSES, name[]) {
+        match find_class(UNICODE_CLASSES, name.index(&FullRange)) {
             None => {
                 return self.err(format!("Could not find Unicode class '{}'",
-                                        name)[])
+                                        name).index(&FullRange))
             }
             Some(ranges) => {
                 Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
@@ -682,11 +683,11 @@ impl<'a> Parser<'a> {
             }
         }
         let s = self.slice(start, end);
-        match num::from_str_radix::<u32>(s[], 8) {
+        match num::from_str_radix::<u32>(s.index(&FullRange), 8) {
             Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
             None => {
                 self.err(format!("Could not parse '{}' as octal number.",
-                                 s)[])
+                                 s).index(&FullRange))
             }
         }
     }
@@ -704,12 +705,12 @@ impl<'a> Parser<'a> {
                 None => {
                     return self.err(format!("Missing '}}' for unclosed \
                                              '{{' at position {}",
-                                            start)[])
+                                            start).index(&FullRange))
                 }
                 Some(i) => i,
             };
         self.chari = closer;
-        self.parse_hex_digits(self.slice(start, closer)[])
+        self.parse_hex_digits(self.slice(start, closer).index(&FullRange))
     }
 
     // Parses a two-digit hex number.
@@ -729,7 +730,7 @@ impl<'a> Parser<'a> {
         match num::from_str_radix::<u32>(s, 16) {
             Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
             None => {
-                self.err(format!("Could not parse '{}' as hex number.", s)[])
+                self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange))
             }
         }
     }
@@ -755,7 +756,7 @@ impl<'a> Parser<'a> {
         }
         if self.names.contains(&name) {
             return self.err(format!("Duplicate capture group name '{}'.",
-                                    name)[])
+                                    name).index(&FullRange))
         }
         self.names.push(name.clone());
         self.chari = closer;
@@ -789,7 +790,7 @@ impl<'a> Parser<'a> {
                     if sign < 0 {
                         return self.err(format!(
                             "Cannot negate flags twice in '{}'.",
-                            self.slice(start, self.chari + 1))[])
+                            self.slice(start, self.chari + 1)).index(&FullRange))
                     }
                     sign = -1;
                     saw_flag = false;
@@ -800,7 +801,7 @@ impl<'a> Parser<'a> {
                         if !saw_flag {
                             return self.err(format!(
                                 "A valid flag does not follow negation in '{}'",
-                                self.slice(start, self.chari + 1))[])
+                                self.slice(start, self.chari + 1)).index(&FullRange))
                         }
                         flags = flags ^ flags;
                     }
@@ -812,7 +813,7 @@ impl<'a> Parser<'a> {
                     return Ok(())
                 }
                 _ => return self.err(format!(
-                    "Unrecognized flag '{}'.", self.cur())[]),
+                    "Unrecognized flag '{}'.", self.cur()).index(&FullRange)),
             }
         }
     }
@@ -910,7 +911,7 @@ impl<'a> Parser<'a> {
             Some(i) => Ok(i),
             None => {
                 self.err(format!("Expected an unsigned integer but got '{}'.",
-                                 s)[])
+                                 s).index(&FullRange))
             }
         }
     }
@@ -920,7 +921,7 @@ impl<'a> Parser<'a> {
             Some(c) => Ok(c),
             None => {
                 self.err(format!("Could not decode '{}' to unicode \
-                                  character.", n)[])
+                                  character.", n).index(&FullRange))
             }
         }
     }
@@ -953,7 +954,7 @@ impl<'a> Parser<'a> {
     }
 
     fn slice(&self, start: uint, end: uint) -> String {
-        self.chars[start..end].iter().cloned().collect()
+        self.chars.index(&(start..end)).iter().cloned().collect()
     }
 }
 
diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index 1840a3343e6..cb2690ce80c 100644
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -238,19 +238,19 @@ impl Regex {
             }
 
             let (s, e) = cap.pos(0).unwrap(); // captures only reports matches
-            new.push_str(text[last_match..s]);
-            new.push_str(rep.reg_replace(&cap)[]);
+            new.push_str(text.index(&(last_match..s)));
+            new.push_str(rep.reg_replace(&cap).index(&FullRange));
             last_match = e;
         }
-        new.push_str(text[last_match..text.len()]);
+        new.push_str(text.index(&(last_match..text.len())));
         return new;
     }
 
     /// Returns the original string of this regex.
     pub fn as_str<'a>(&'a self) -> &'a str {
         match *self {
-            Dynamic(ExDynamic { ref original, .. }) => original[],
-            Native(ExNative { ref original, .. }) => original[],
+            Dynamic(ExDynamic { ref original, .. }) => original.index(&FullRange),
+            Native(ExNative { ref original, .. }) => original.index(&FullRange),
         }
     }
 
@@ -347,13 +347,13 @@ impl<'r, 't> Iterator for RegexSplits<'r, 't> {
                 if self.last >= text.len() {
                     None
                 } else {
-                    let s = text[self.last..text.len()];
+                    let s = text.index(&(self.last..text.len()));
                     self.last = text.len();
                     Some(s)
                 }
             }
             Some((s, e)) => {
-                let matched = text[self.last..s];
+                let matched = text.index(&(self.last..s));
                 self.last = e;
                 Some(matched)
             }
@@ -384,7 +384,7 @@ impl<'r, 't> Iterator for RegexSplitsN<'r, 't> {
         } else {
             self.cur += 1;
             if self.cur >= self.limit {
-                Some(text[self.splits.last..text.len()])
+                Some(text.index(&(self.splits.last..text.len())))
             } else {
                 self.splits.next()
             }
@@ -517,7 +517,7 @@ impl<'t> Captures<'t> {
             })
         });
         let re = Regex::new(r"\$\$").unwrap();
-        re.replace_all(text[], NoExpand("$"))
+        re.replace_all(text.index(&FullRange), NoExpand("$"))
     }
 
     /// Returns the number of captured groups.
diff --git a/src/libregex/test/matches.rs b/src/libregex/test/matches.rs
index 7508f4c50a2..b422ac668ca 100644
--- a/src/libregex/test/matches.rs
+++ b/src/libregex/test/matches.rs
@@ -121,7 +121,7 @@ mat!{match_basic_110, r"a[b-d]", r"aac", Some((1, 3))}
 mat!{match_basic_111, r"a[-b]", r"a-", Some((0, 2))}
 mat!{match_basic_112, r"a[b-]", r"a-", Some((0, 2))}
 mat!{match_basic_113, r"a]", r"a]", Some((0, 2))}
-mat!{match_basic_114, r"a[]]b", r"a]b", Some((0, 3))}
+mat!{match_basic_114, r"a.index(&FullRange)]b", r"a]b", Some((0, 3))}
 mat!{match_basic_115, r"a[^bc]d", r"aed", Some((0, 3))}
 mat!{match_basic_116, r"a[^-b]c", r"adc", Some((0, 3))}
 mat!{match_basic_117, r"a[^]b]c", r"adc", Some((0, 3))}
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index 914167019d2..04c430da4d2 100644
--- a/src/libregex/vm.rs
+++ b/src/libregex/vm.rs
@@ -152,7 +152,7 @@ impl<'r, 't> Nfa<'r, 't> {
                 // out early.
                 if self.prog.prefix.len() > 0 && clist.size == 0 {
                     let needle = self.prog.prefix.as_bytes();
-                    let haystack = self.input.as_bytes()[self.ic..];
+                    let haystack = self.input.as_bytes().index(&(self.ic..));
                     match find_prefix(needle, haystack) {
                         None => break,
                         Some(i) => {
@@ -503,7 +503,8 @@ impl Threads {
 
     #[inline]
     fn groups<'r>(&'r mut self, i: uint) -> &'r mut [Option<uint>] {
-        self.queue[i].groups.as_mut_slice()
+        let q = &mut self.queue[i];
+        q.groups.as_mut_slice()
     }
 }