Fixes from code review.

The big change here is the addition of a non-public variant in the
error enums. This will hint to users that one shouldn't exhaustively
match the enums in case new variants are added.

Author: BurntSushi

.gitignore

@@ -1,8 +1,4 @@
-/target
-/Cargo.lock
-/regex_macros/target
-/regex_macros/Cargo.lock
-/regex_syntax/target
-/regex_syntax/Cargo.lock
-/bench-log
+target
+Cargo.lock
+bench-log
 .*.swp

Cargo.toml

@@ -21,9 +21,8 @@ path = "regex_macros/benches/bench_dynamic.rs"
 test = false
 bench = true
 
-[dependencies.regex-syntax]
-path = "regex_syntax"
-version = "*"
+[dependencies]
+regex-syntax = { path = "regex-syntax", version = "0.1" }
 
 [dev-dependencies]
 rand = "0.3"
@@ -32,5 +31,4 @@ rand = "0.3"
 pattern = []
 
 [profile.bench]
-opt-level = 3
 lto = true

regex_syntax/Cargo.toml renamed to regex-syntax/Cargo.toml

@@ -6,8 +6,8 @@ license = "MIT/Apache-2.0"
 repository = "https://github.com/rust-lang/regex"
 documentation = "http://doc.rust-lang.org/regex"
 homepage = "https://github.com/rust-lang/regex"
-description = "A regular expression parser (RE2 only)."
+description = "A regular expression parser."
 
 [dev-dependencies]
-quickcheck = "*"
-rand = "*"
+quickcheck = "0.2"
+rand = "0.3"

regex_syntax/src/lib.rs renamed to regex-syntax/src/lib.rs

@@ -540,7 +540,6 @@ impl PartialOrd<ClassRange> for char {
 
 /// This implementation of `Display` will write a regular expression from the
 /// syntax tree. It does not write the original string parsed.
-// TODO(burntsushi): Write tests for the regex writer.
 impl fmt::Display for Expr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -722,6 +721,13 @@ pub enum ErrorKind {
     UnrecognizedFlag(char),
     /// Unrecognized named Unicode class. e.g., `\p{Foo}`.
     UnrecognizedUnicodeClass(String),
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
 }
 
 impl Error {
@@ -773,6 +779,7 @@ impl ErrorKind {
             UnrecognizedEscape(_) => "unrecognized escape sequence",
             UnrecognizedFlag(_) => "unrecognized flag",
             UnrecognizedUnicodeClass(_) => "unrecognized Unicode class name",
+            __Nonexhaustive => unreachable!(),
         }
     }
 }
@@ -866,6 +873,7 @@ impl fmt::Display for ErrorKind {
                            (Allowed flags: i, s, m, U, x.)", c),
             UnrecognizedUnicodeClass(ref s) =>
                 write!(f, "Unrecognized Unicode class name: '{}'.", s),
+            __Nonexhaustive => unreachable!(),
         }
     }
 }

regex_syntax/src/parser.rs renamed to regex-syntax/src/parser.rs

@@ -59,13 +59,21 @@ pub enum Error {
     /// The compiled program exceeded the set size limit.
     /// The argument is the size limit imposed.
     CompiledTooBig(usize),
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
 }
 
 impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::Syntax(ref err) => err.description(),
             Error::CompiledTooBig(_) => "compiled program too big",
+            Error::__Nonexhaustive => unreachable!(),
         }
     }
 
@@ -85,6 +93,7 @@ impl fmt::Display for Error {
                 write!(f, "Compiled regex exceeds size limit of {} bytes.",
                        limit)
             }
+            Error::__Nonexhaustive => unreachable!(),
         }
     }
 }