syntax: rejigger Hir::{dot,any}

Instead of using a boolean parameter, we just split them into dot_char,
dot_byte, any_char, any_byte.

Another path would be to use an enum, but this appeals to me a little
more.

Author: BurntSushi

regex-syntax/src/hir/mod.rs

@@ -310,44 +310,52 @@ impl Hir {
 
     /// Build an HIR expression for `.`.
     ///
-    /// A `.` expression matches any character except for `\n`. To build an
-    /// expression that matches any character, including `\n`, use the `any`
-    /// method.
-    ///
-    /// If `bytes` is `true`, then this assumes characters are limited to a
-    /// single byte.
-    pub fn dot(bytes: bool) -> Hir {
-        if bytes {
-            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))
-        } else {
-            let mut cls = ClassUnicode::empty();
-            cls.push(ClassUnicodeRange::new('\0', '\x09'));
-            cls.push(ClassUnicodeRange::new('\x0B', '\u{10FFFF}'));
-            Hir::class(Class::Unicode(cls))
-        }
+    /// 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 `(?s).`.
+    /// Build an HIR expression for `(?-u:.)`.
     ///
-    /// A `(?s).` expression matches any character, including `\n`. To build an
-    /// expression that matches any character except for `\n`, then use the
-    /// `dot` method.
+    /// 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:.)`.
     ///
-    /// If `bytes` is `true`, then this assumes characters are limited to a
-    /// single byte.
-    pub fn any(bytes: bool) -> Hir {
-        if bytes {
-            let mut cls = ClassBytes::empty();
-            cls.push(ClassBytesRange::new(b'\0', b'\xFF'));
-            Hir::class(Class::Bytes(cls))
-        } else {
-            let mut cls = ClassUnicode::empty();
-            cls.push(ClassUnicodeRange::new('\0', '\u{10FFFF}'));
-            Hir::class(Class::Unicode(cls))
-        }
+    /// 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))
     }
 }
 

regex-syntax/src/hir/translate.rs

@@ -861,9 +861,17 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
             return Err(self.error(span, ErrorKind::InvalidUtf8));
         }
         Ok(if self.flags().dot_matches_new_line() {
-            Hir::any(!unicode)
+            if unicode {
+                Hir::any_char()
+            } else {
+                Hir::any_byte()
+            }
         } else {
-            Hir::dot(!unicode)
+            if unicode {
+                Hir::dot_char()
+            } else {
+                Hir::dot_byte()
+            }
         })
     }
 

src/compile.rs

@@ -424,23 +424,19 @@ impl Compiler {
     }
 
     fn c_dotstar(&mut self) -> Result {
-        Ok(if !self.compiled.only_utf8() {
-            self.c(&Hir::repetition(hir::Repetition {
-                min: 0,
-                max: None,
-                greedy: false,
-                hir: Box::new(Hir::any(true)),
-            }))?
-            .unwrap()
+        let hir = if self.compiled.only_utf8() {
+            Hir::any_char()
         } else {
-            self.c(&Hir::repetition(hir::Repetition {
+            Hir::any_byte()
+        };
+        Ok(self
+            .c(&Hir::repetition(hir::Repetition {
                 min: 0,
                 max: None,
                 greedy: false,
-                hir: Box::new(Hir::any(false)),
+                hir: Box::new(hir),
             }))?
-            .unwrap()
-        })
+            .unwrap())
     }
 
     fn c_char(&mut self, c: char) -> ResultOrEmpty {