auto merge of #20733 : alexcrichton/rust/rollup, r=alexcrichton

5 files changed, 64 insertions, 72 deletions

diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs
index 5803da1d335..d29a7a425c1 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.index(&(1..)).iter() {
+        for inst in c.insts[1..].iter() {
             match *inst {
                 OneChar(c, FLAG_EMPTY) => pre.push(c),
                 _ => break
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index c039abc9aff..d19ce3b460a 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -17,6 +17,7 @@
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![experimental = "use the crates.io `regex` library instead"]
+#![staged_api]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",
@@ -24,6 +25,7 @@
 
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 #![deny(missing_docs)]
 
 #[cfg(test)]
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index dd11d42b8aa..1cc2b271e9c 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -18,7 +18,6 @@ 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,8 +284,8 @@ impl<'a> Parser<'a> {
         match self.next_char() {
             true => Ok(()),
             false => {
-                self.err(format!("Expected {:?} but got EOF.",
-                                 expected).index(&FullRange))
+                self.err(&format!("Expected {:?} but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -294,11 +293,11 @@ impl<'a> Parser<'a> {
     fn expect(&mut self, expected: char) -> Result<(), Error> {
         match self.next_char() {
             true if self.cur() == expected => Ok(()),
-            true => self.err(format!("Expected '{:?}' but got '{:?}'.",
-                                     expected, self.cur()).index(&FullRange)),
+            true => self.err(&format!("Expected '{:?}' but got '{:?}'.",
+                                      expected, self.cur())[]),
             false => {
-                self.err(format!("Expected '{:?}' but got EOF.",
-                                 expected).index(&FullRange))
+                self.err(&format!("Expected '{:?}' but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -443,15 +442,15 @@ impl<'a> Parser<'a> {
                     match try!(self.parse_escape()) {
                         Literal(c3, _) => c2 = c3, // allow literal escapes below
                         ast =>
-                            return self.err(format!("Expected a literal, but got {:?}.",
-                                                    ast).index(&FullRange)),
+                            return self.err(&format!("Expected a literal, but got {:?}.",
+                                                     ast)[]),
                     }
                 }
                 if c2 < c {
-                    return self.err(format!("Invalid character class \
-                                             range '{}-{}'",
-                                            c,
-                                            c2).index(&FullRange))
+                    return self.err(&format!("Invalid character class \
+                                              range '{}-{}'",
+                                             c,
+                                             c2)[])
                 }
                 ranges.push((c, self.cur()))
             } else {
@@ -489,7 +488,7 @@ impl<'a> Parser<'a> {
                 FLAG_EMPTY
             };
         let name = self.slice(name_start, closer - 1);
-        match find_class(ASCII_CLASSES, name.index(&FullRange)) {
+        match find_class(ASCII_CLASSES, &name[]) {
             None => None,
             Some(ranges) => {
                 self.chari = closer;
@@ -511,21 +510,21 @@ impl<'a> Parser<'a> {
             match self.pos('}') {
                 Some(i) => i,
                 None => {
-                    return self.err(format!("No closing brace for counted \
-                                             repetition starting at position \
-                                             {:?}.",
-                                            start).index(&FullRange))
+                    return self.err(&format!("No closing brace for counted \
+                                              repetition starting at position \
+                                              {:?}.",
+                                             start)[])
                 }
             };
         self.chari = closer;
         let greed = try!(self.get_next_greedy());
-        let inner = self.chars.index(&((start+1)..closer)).iter().cloned()
+        let inner = self.chars[(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.index(&FullRange)));
+            min = try!(self.parse_uint(&inner[]));
             max = Some(min);
         } else {
             let pieces: Vec<&str> = inner.splitn(1, ',').collect();
@@ -545,21 +544,21 @@ impl<'a> Parser<'a> {
 
         // Do some bounds checking and make sure max >= min.
         if min > MAX_REPEAT {
-            return self.err(format!(
+            return self.err(&format!(
                 "{} exceeds maximum allowed repetitions ({})",
-                min, MAX_REPEAT).index(&FullRange));
+                min, MAX_REPEAT)[]);
         }
         if max.is_some() {
             let m = max.unwrap();
             if m > MAX_REPEAT {
-                return self.err(format!(
+                return self.err(&format!(
                     "{} exceeds maximum allowed repetitions ({})",
-                    m, MAX_REPEAT).index(&FullRange));
+                    m, MAX_REPEAT)[]);
             }
             if m < min {
-                return self.err(format!(
+                return self.err(&format!(
                     "Max repetitions ({}) cannot be smaller than min \
-                     repetitions ({}).", m, min).index(&FullRange));
+                     repetitions ({}).", m, min)[]);
             }
         }
 
@@ -623,7 +622,7 @@ impl<'a> Parser<'a> {
                 Ok(AstClass(ranges, flags))
             }
             _ => {
-                self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
+                self.err(&format!("Invalid escape sequence '\\\\{}'", c)[])
             }
         }
     }
@@ -641,9 +640,9 @@ impl<'a> Parser<'a> {
             let closer =
                 match self.pos('}') {
                     Some(i) => i,
-                    None => return self.err(format!(
+                    None => return self.err(&format!(
                         "Missing '}}' for unclosed '{{' at position {}",
-                        self.chari).index(&FullRange)),
+                        self.chari)[]),
                 };
             if closer - self.chari + 1 == 0 {
                 return self.err("No Unicode class name found.")
@@ -657,10 +656,10 @@ impl<'a> Parser<'a> {
             name = self.slice(self.chari + 1, self.chari + 2);
             self.chari += 1;
         }
-        match find_class(UNICODE_CLASSES, name.index(&FullRange)) {
+        match find_class(UNICODE_CLASSES, &name[]) {
             None => {
-                return self.err(format!("Could not find Unicode class '{}'",
-                                        name).index(&FullRange))
+                return self.err(&format!("Could not find Unicode class '{}'",
+                                        name)[])
             }
             Some(ranges) => {
                 Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
@@ -683,11 +682,11 @@ impl<'a> Parser<'a> {
             }
         }
         let s = self.slice(start, end);
-        match num::from_str_radix::<u32>(s.index(&FullRange), 8) {
+        match num::from_str_radix::<u32>(&s[], 8) {
             Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
             None => {
-                self.err(format!("Could not parse '{:?}' as octal number.",
-                                 s).index(&FullRange))
+                self.err(&format!("Could not parse '{:?}' as octal number.",
+                                 s)[])
             }
         }
     }
@@ -703,14 +702,14 @@ impl<'a> Parser<'a> {
         let closer =
             match self.pos('}') {
                 None => {
-                    return self.err(format!("Missing '}}' for unclosed \
+                    return self.err(&format!("Missing '}}' for unclosed \
                                              '{{' at position {}",
-                                            start).index(&FullRange))
+                                            start)[])
                 }
                 Some(i) => i,
             };
         self.chari = closer;
-        self.parse_hex_digits(self.slice(start, closer).index(&FullRange))
+        self.parse_hex_digits(&self.slice(start, closer)[])
     }
 
     // Parses a two-digit hex number.
@@ -730,7 +729,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).index(&FullRange))
+                self.err(&format!("Could not parse '{}' as hex number.", s)[])
             }
         }
     }
@@ -755,8 +754,8 @@ impl<'a> Parser<'a> {
                 "Capture names can only have underscores, letters and digits.")
         }
         if self.names.contains(&name) {
-            return self.err(format!("Duplicate capture group name '{}'.",
-                                    name).index(&FullRange))
+            return self.err(&format!("Duplicate capture group name '{}'.",
+                                    name)[])
         }
         self.names.push(name.clone());
         self.chari = closer;
@@ -788,9 +787,9 @@ impl<'a> Parser<'a> {
                 'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true},
                 '-' => {
                     if sign < 0 {
-                        return self.err(format!(
+                        return self.err(&format!(
                             "Cannot negate flags twice in '{}'.",
-                            self.slice(start, self.chari + 1)).index(&FullRange))
+                            self.slice(start, self.chari + 1))[])
                     }
                     sign = -1;
                     saw_flag = false;
@@ -799,9 +798,9 @@ impl<'a> Parser<'a> {
                 ':' | ')' => {
                     if sign < 0 {
                         if !saw_flag {
-                            return self.err(format!(
+                            return self.err(&format!(
                                 "A valid flag does not follow negation in '{}'",
-                                self.slice(start, self.chari + 1)).index(&FullRange))
+                                self.slice(start, self.chari + 1))[])
                         }
                         flags = flags ^ flags;
                     }
@@ -812,8 +811,8 @@ impl<'a> Parser<'a> {
                     self.flags = flags;
                     return Ok(())
                 }
-                _ => return self.err(format!(
-                    "Unrecognized flag '{}'.", self.cur()).index(&FullRange)),
+                _ => return self.err(&format!(
+                    "Unrecognized flag '{}'.", self.cur())[]),
             }
         }
     }
@@ -910,8 +909,8 @@ impl<'a> Parser<'a> {
         match s.parse::<uint>() {
             Some(i) => Ok(i),
             None => {
-                self.err(format!("Expected an unsigned integer but got '{}'.",
-                                 s).index(&FullRange))
+                self.err(&format!("Expected an unsigned integer but got '{}'.",
+                                 s)[])
             }
         }
     }
@@ -920,8 +919,8 @@ impl<'a> Parser<'a> {
         match char::from_u32(n) {
             Some(c) => Ok(c),
             None => {
-                self.err(format!("Could not decode '{}' to unicode \
-                                  character.", n).index(&FullRange))
+                self.err(&format!("Could not decode '{}' to unicode \
+                                  character.", n)[])
             }
         }
     }
@@ -954,7 +953,7 @@ impl<'a> Parser<'a> {
     }
 
     fn slice(&self, start: uint, end: uint) -> String {
-        self.chars.index(&(start..end)).iter().cloned().collect()
+        self.chars[start..end].iter().cloned().collect()
     }
 }
 
diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index 37f9869f3bf..16dd32b6be2 100644
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -90,15 +90,6 @@ impl Clone for ExNative {
     }
 }
 
-#[cfg(stage0)]
-//FIXME: remove after stage0 snapshot
-impl fmt::Show for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_str(), f)
-    }
-}
-
 impl fmt::String for Regex {
     /// Shows the original regular expression.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -247,19 +238,19 @@ impl Regex {
             }
 
             let (s, e) = cap.pos(0).unwrap(); // captures only reports matches
-            new.push_str(text.index(&(last_match..s)));
-            new.push_str(rep.reg_replace(&cap).index(&FullRange));
+            new.push_str(&text[last_match..s]);
+            new.push_str(&rep.reg_replace(&cap)[]);
             last_match = e;
         }
-        new.push_str(text.index(&(last_match..text.len())));
+        new.push_str(&text[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.index(&FullRange),
-            Native(ExNative { ref original, .. }) => original.index(&FullRange),
+            Dynamic(ExDynamic { ref original, .. }) => &original[],
+            Native(ExNative { ref original, .. }) => &original[],
         }
     }
 
@@ -356,13 +347,13 @@ impl<'r, 't> Iterator for RegexSplits<'r, 't> {
                 if self.last >= text.len() {
                     None
                 } else {
-                    let s = text.index(&(self.last..text.len()));
+                    let s = &text[self.last..text.len()];
                     self.last = text.len();
                     Some(s)
                 }
             }
             Some((s, e)) => {
-                let matched = text.index(&(self.last..s));
+                let matched = &text[self.last..s];
                 self.last = e;
                 Some(matched)
             }
@@ -393,7 +384,7 @@ impl<'r, 't> Iterator for RegexSplitsN<'r, 't> {
         } else {
             self.cur += 1;
             if self.cur >= self.limit {
-                Some(text.index(&(self.splits.last..text.len())))
+                Some(&text[self.splits.last..text.len()])
             } else {
                 self.splits.next()
             }
@@ -526,7 +517,7 @@ impl<'t> Captures<'t> {
             })
         });
         let re = Regex::new(r"\$\$").unwrap();
-        re.replace_all(text.index(&FullRange), NoExpand("$"))
+        re.replace_all(&text[], NoExpand("$"))
     }
 
     /// Returns the number of captured groups.
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index 04c430da4d2..9605536a052 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().index(&(self.ic..));
+                    let haystack = &self.input.as_bytes()[self.ic..];
                     match find_prefix(needle, haystack) {
                         None => break,
                         Some(i) => {