remove unnecessary parentheses from range notation

[rust.git] / src / libregex / parse.rs

diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index dd11d42b8aad60b0186701538d1554d1de626d52..a54db2654ab7a0224fd62e1d034f2ee7d7534cd8 100644 (file)
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -18,7 +18,6 @@
 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 @@ fn noteof(&mut self, expected: &str) -> Result<(), Error> {
         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 @@ fn noteof(&mut self, expected: &str) -> Result<(), Error> {
     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 @@ fn parse_class(&mut self) -> Result<(), Error> {
                     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 @@ fn try_parse_ascii(&mut self) -> Option<Ast> {
                 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 @@ fn parse_counted(&mut self) -> Result<(), Error> {
             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 @@ fn parse_counted(&mut self) -> Result<(), Error> {
 
         // 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 @@ fn parse_escape(&mut self) -> Result<Ast, Error> {
                 Ok(AstClass(ranges, flags))
             }
             _ => {
-                self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
+                self.err(&format!("Invalid escape sequence '\\\\{}'", c)[])
             }
         }
     }
@@ -641,9 +640,9 @@ fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
             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 @@ fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
             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 @@ fn parse_octal(&mut self) -> Result<Ast, Error> {
             }
         }
         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 @@ fn parse_hex(&mut self) -> Result<Ast, Error> {
         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 @@ fn parse_hex_digits(&self, s: &str) -> Result<Ast, Error> {
         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 @@ fn parse_named_capture(&mut self) -> Result<(), Error> {
                 "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 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                 '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 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                 ':' | ')' => {
                     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 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                     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 @@ fn parse_uint(&self, s: &str) -> Result<uint, Error> {
         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 @@ fn char_from_u32(&self, n: u32) -> Result<char, Error> {
         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 @@ fn cur(&self) -> char {
     }
 
     fn slice(&self, start: uint, end: uint) -> String {
-        self.chars.index(&(start..end)).iter().cloned().collect()
+        self.chars[start..end].iter().cloned().collect()
     }
 }