syntax: add 'Hir::dot' method to replace 'Hir::{any,dot}_{char,byte}'

In a previous commit, I replaced 'Hir::{any,dot}' a total of four
methods. Essentially, I expanded out the boolean parameter to
'Hir::{any,dot}'.

I later realized that we'll probably need a "dot except for CR and LF"
too. And having four methods all for the same 'dot' construct seemed a
bit much. So I've turned it into one method with a new 'Dot' enum.
Eventually, that enum should grow two more variants: 'AnyCharExceptCRLF'
and 'AnyByteExceptCRLF'. That sort of expansion would have been pretty
annoying to do (because of naming) in the prior scheme.

Author: BurntSushi

regex-syntax/src/hir/mod.rs

@@ -317,54 +317,41 @@ impl Hir {
         }
     }
 
-    /// Build an HIR expression for `.`.
-    ///
-    /// A `.` expression matches any character except for a newline terminator.
-    /// To build an expression that matches any character, including newline
-    /// terminators, use the `any_char` method.
-    pub fn dot_char() -> Hir {
-        let mut cls = ClassUnicode::empty();
-        cls.push(ClassUnicodeRange::new('\0', '\x09'));
-        cls.push(ClassUnicodeRange::new('\x0B', '\u{10FFFF}'));
-        Hir::class(Class::Unicode(cls))
-    }
-
-    /// Build an HIR expression for `(?-u:.)`.
-    ///
-    /// A non-Unicode `.` expression matches any byte except for a newline
-    /// terminator. To build an expression that matches any byte, including
-    /// newline terminators, use the `any_byte` method.
-    pub fn dot_byte() -> Hir {
-        let mut cls = ClassBytes::empty();
-        cls.push(ClassBytesRange::new(b'\0', b'\x09'));
-        cls.push(ClassBytesRange::new(b'\x0B', b'\xFF'));
-        Hir::class(Class::Bytes(cls))
-    }
-
-    /// Build an HIR expression for `(?s:.)`.
-    ///
-    /// A `(?s:.)` expression matches any character, including newline
-    /// terminators. To build an expression that matches any character except
-    /// for newline terminators, use the `dot_char` method.
-    ///
-    /// Note that `(?s:)` is equivalent to `\p{any}`.
-    pub fn any_char() -> Hir {
-        let mut cls = ClassUnicode::empty();
-        cls.push(ClassUnicodeRange::new('\0', '\u{10FFFF}'));
-        Hir::class(Class::Unicode(cls))
-    }
-
-    /// Build an HIR expression for `(?s-u:.)`.
-    ///
-    /// A `(?s-u:.)` expression matches any byte, including newline terminators.
-    /// To build an expression that matches any byte except for newline
-    /// terminators, use the `dot_byte` method.
-    ///
-    /// Note that `(?s-u:.)` is equivalent to `(?-u:[\x00-\xFF])`.
-    pub fn any_byte() -> Hir {
-        let mut cls = ClassBytes::empty();
-        cls.push(ClassBytesRange::new(b'\0', b'\xFF'));
-        Hir::class(Class::Bytes(cls))
+    /// Returns an HIR expression for `.`.
+    ///
+    /// * [`Dot::AnyChar`] maps to `(?su:.)`.
+    /// * [`Dot::AnyByte`] maps to `(?s-u:.)`.
+    /// * [`Dot::AnyCharExceptNL`] maps to `(?u-s:.)`.
+    /// * [`Dot::AnyByteExceptNL`] maps to `(?-su:.)`.
+    ///
+    /// Note that this is a convenience routine for constructing the correct
+    /// character class based on the value of `Dot`. There is no explicit "dot"
+    /// HIR value. It is just an abbreviation for a common character class.
+    pub fn dot(dot: Dot) -> Hir {
+        match dot {
+            Dot::AnyChar => {
+                let mut cls = ClassUnicode::empty();
+                cls.push(ClassUnicodeRange::new('\0', '\u{10FFFF}'));
+                Hir::class(Class::Unicode(cls))
+            }
+            Dot::AnyByte => {
+                let mut cls = ClassBytes::empty();
+                cls.push(ClassBytesRange::new(b'\0', b'\xFF'));
+                Hir::class(Class::Bytes(cls))
+            }
+            Dot::AnyCharExceptNL => {
+                let mut cls = ClassUnicode::empty();
+                cls.push(ClassUnicodeRange::new('\0', '\x09'));
+                cls.push(ClassUnicodeRange::new('\x0B', '\u{10FFFF}'));
+                Hir::class(Class::Unicode(cls))
+            }
+            Dot::AnyByteExceptNL => {
+                let mut cls = ClassBytes::empty();
+                cls.push(ClassBytesRange::new(b'\0', b'\x09'));
+                cls.push(ClassBytesRange::new(b'\x0B', b'\xFF'));
+                Hir::class(Class::Bytes(cls))
+            }
+        }
     }
 }
 
@@ -1233,6 +1220,31 @@ impl Repetition {
     }
 }
 
+/// A type describing the different flavors of `.`.
+///
+/// This type is meant to be used with [`Hir::dot`], which is a convenience
+/// routine for building HIR values derived from the `.` regex.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Dot {
+    /// Matches the UTF-8 encoding of any Unicode scalar value.
+    ///
+    /// This is equivalent to `(?su:.)` and also `\p{any}`.
+    AnyChar,
+    /// Matches any byte value.
+    ///
+    /// This is equivalent to `(?s-u:.)` and also `(?-u:[\x00-\xFF])`.
+    AnyByte,
+    /// Matches the UTF-8 encoding of any Unicode scalar value except for `\n`.
+    ///
+    /// This is equivalent to `(?u-s:.)` and also `[\p{any}--\n]`.
+    AnyCharExceptNL,
+    /// Matches any byte value except for `\n`.
+    ///
+    /// This is equivalent to `(?-su:.)` and also `(?-u:[[\x00-\xFF]--\n])`.
+    AnyByteExceptNL,
+}
+
 /// A custom `Drop` impl is used for `HirKind` such that it uses constant stack
 /// space but heap space proportional to the depth of the total `Hir`.
 impl Drop for Hir {

regex-syntax/src/hir/translate.rs

@@ -856,23 +856,10 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
     }
 
     fn hir_dot(&self, span: Span) -> Result<Hir> {
-        let unicode = self.flags().unicode();
-        if !unicode && !self.trans().allow_invalid_utf8 {
+        if !self.flags().unicode() && !self.trans().allow_invalid_utf8 {
             return Err(self.error(span, ErrorKind::InvalidUtf8));
         }
-        Ok(if self.flags().dot_matches_new_line() {
-            if unicode {
-                Hir::any_char()
-            } else {
-                Hir::any_byte()
-            }
-        } else {
-            if unicode {
-                Hir::dot_char()
-            } else {
-                Hir::dot_byte()
-            }
-        })
+        Ok(Hir::dot(self.flags().dot()))
     }
 
     fn hir_assertion(&self, asst: &ast::Assertion) -> Result<Hir> {
@@ -1210,6 +1197,22 @@ impl Flags {
         }
     }
 
+    fn dot(&self) -> hir::Dot {
+        if self.dot_matches_new_line() {
+            if self.unicode() {
+                hir::Dot::AnyChar
+            } else {
+                hir::Dot::AnyByte
+            }
+        } else {
+            if self.unicode() {
+                hir::Dot::AnyCharExceptNL
+            } else {
+                hir::Dot::AnyByteExceptNL
+            }
+        }
+    }
+
     fn case_insensitive(&self) -> bool {
         self.case_insensitive.unwrap_or(false)
     }

src/compile.rs

@@ -425,9 +425,9 @@ impl Compiler {
 
     fn c_dotstar(&mut self) -> Result {
         let hir = if self.compiled.only_utf8() {
-            Hir::any_char()
+            Hir::dot(hir::Dot::AnyChar)
         } else {
-            Hir::any_byte()
+            Hir::dot(hir::Dot::AnyByte)
         };
         Ok(self
             .c(&Hir::repetition(hir::Repetition {