syntax: better error message for missing repetition quantifier

Author: christianrondeau

regex-syntax/src/ast/mod.rs

@@ -153,6 +153,9 @@ pub enum ErrorKind {
     /// The range provided in a counted repetition operator is invalid. The
     /// range is invalid if the start is greater than the end.
     RepetitionCountInvalid,
+    /// An opening `{` was not followed by a valid decimal value.
+    /// For example, `x{}` or `x{]}` would fail.
+    RepetitionQuantifierDecimalMissing,
     /// An opening `{` was found with no corresponding closing `}`.
     RepetitionCountUnclosed,
     /// A repetition operator was applied to a missing sub-expression. This
@@ -307,6 +310,9 @@ impl fmt::Display for ErrorKind {
                 write!(f, "invalid repetition count range, \
                            the start must be <= the end")
             }
+            RepetitionQuantifierDecimalMissing => {
+                write!(f, "Repetition quantifier expects a valid decimal")
+            }
             RepetitionCountUnclosed => {
                 write!(f, "unclosed counted repetition")
             }

regex-syntax/src/ast/parse.rs

@@ -1113,7 +1113,15 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
                 ast::ErrorKind::RepetitionCountUnclosed,
             ));
         }
-        let count_start = self.parse_decimal()?;
+        let count_start = match self.parse_decimal() {
+            Err(ast::Error {kind: ast::ErrorKind::DecimalEmpty, span, pattern}) => return Err(ast::Error {
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
+                pattern,
+                span,
+            }),
+            Err(e) => return Err(e),
+            Ok(value) => value,
+        };
         let mut range = ast::RepetitionRange::Exactly(count_start);
         if self.is_eof() {
             return Err(self.error(
@@ -1129,7 +1137,15 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
                 ));
             }
             if self.char() != '}' {
-                let count_end = self.parse_decimal()?;
+                let count_end = match self.parse_decimal() {
+                    Err(ast::Error {kind: ast::ErrorKind::DecimalEmpty, span, pattern}) => return Err(ast::Error {
+                        kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
+                        pattern,
+                        span,
+                    }),
+                    Err(e) => return Err(e),
+                    Ok(value) => value,
+                };
                 range = ast::RepetitionRange::Bounded(count_start, count_end);
             } else {
                 range = ast::RepetitionRange::AtLeast(count_start);
@@ -3143,6 +3159,18 @@ bar
                 span: span(4..4),
                 kind: ast::ErrorKind::RepetitionMissing,
             });
+        assert_eq!(
+            parser(r"a{]}").parse().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
+            });
+        assert_eq!(
+            parser(r"a{1,]}").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
+            });
         assert_eq!(
             parser(r"a{").parse().unwrap_err(),
             TestError {
@@ -3153,13 +3181,13 @@ bar
             parser(r"a{}").parse().unwrap_err(),
             TestError {
                 span: span(2..2),
-                kind: ast::ErrorKind::DecimalEmpty,
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
             });
         assert_eq!(
             parser(r"a{a").parse().unwrap_err(),
             TestError {
                 span: span(2..2),
-                kind: ast::ErrorKind::DecimalEmpty,
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
             });
         assert_eq!(
             parser(r"a{9999999999}").parse().unwrap_err(),
@@ -3177,7 +3205,7 @@ bar
             parser(r"a{9,a").parse().unwrap_err(),
             TestError {
                 span: span(4..4),
-                kind: ast::ErrorKind::DecimalEmpty,
+                kind: ast::ErrorKind::RepetitionQuantifierDecimalMissing,
             });
         assert_eq!(
             parser(r"a{9,9999999999}").parse().unwrap_err(),