auto merge of #18282 : pczarn/rust/regex-parse, r=burntsushi

Fixes #18034

3 bugs fixed.

1 files changed, 27 insertions, 24 deletions

diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 1d1d1a0e9c5..35583be372c 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -374,16 +374,12 @@ impl<'a> Parser<'a> {
         let mut ranges: Vec<(char, char)> = vec!();
         let mut alts: Vec<Ast> = vec!();
 
-        if self.peek_is(1, ']') {
-            try!(self.expect(']'))
-            ranges.push((']', ']'))
-        }
         while self.peek_is(1, '-') {
-            try!(self.expect('-'))
+            try!(self.expect('-'));
             ranges.push(('-', '-'))
         }
         loop {
-            try!(self.noteof("a closing ']' or a non-empty character class)"))
+            try!(self.noteof("a closing ']' or a non-empty character class)"));
             let mut c = self.cur();
             match c {
                 '[' =>
@@ -411,10 +407,7 @@ impl<'a> Parser<'a> {
                         ast => fail!("Unexpected AST item '{}'", ast),
                     }
                 }
-                _ => {},
-            }
-            match c {
-                ']' => {
+                ']' if ranges.len() > 0 || alts.len() > 0 => {
                     if ranges.len() > 0 {
                         let flags = negated | (self.flags & FLAG_NOCASE);
                         let mut ast = AstClass(combine_ranges(ranges), flags);
@@ -431,22 +424,32 @@ impl<'a> Parser<'a> {
                     }
                     return Ok(())
                 }
-                c => {
-                    if self.peek_is(1, '-') && !self.peek_is(2, ']') {
-                        try!(self.expect('-'))
-                        try!(self.noteof("not a ']'"))
-                        let c2 = self.cur();
-                        if c2 < c {
-                            return self.err(format!("Invalid character class \
-                                                     range '{}-{}'",
-                                                    c,
-                                                    c2).as_slice())
-                        }
-                        ranges.push((c, self.cur()))
-                    } else {
-                        ranges.push((c, c))
+                _ => {}
+            }
+
+            if self.peek_is(1, '-') && !self.peek_is(2, ']') {
+                try!(self.expect('-'));
+                // The regex can't end here.
+                try!(self.noteof("not a ']'"));
+                // End the range with a single character or character escape.
+                let mut c2 = self.cur();
+                if c2 == '\\' {
+                    match try!(self.parse_escape()) {
+                        Literal(c3, _) => c2 = c3, // allow literal escapes below
+                        ast =>
+                            return self.err(format!("Expected a literal, but got {}.",
+                                                    ast).as_slice()),
                     }
                 }
+                if c2 < c {
+                    return self.err(format!("Invalid character class \
+                                             range '{}-{}'",
+                                            c,
+                                            c2).as_slice())
+                }
+                ranges.push((c, self.cur()))
+            } else {
+                ranges.push((c, c))
             }
         }
     }