add HIR printer

regex-syntax/src/ast/print.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 /*!
-This module provides a regular expression printer.
+This module provides a regular expression printer for `Ast`.
 */
 
 use std::fmt;
@@ -422,7 +422,7 @@ mod tests {
     }
 
     fn roundtrip_with<F>(mut f: F, given: &str)
-        where F: FnMut(&mut ParserBuilder) -> &mut ParserBuilder
+    where F: FnMut(&mut ParserBuilder) -> &mut ParserBuilder
     {
         let mut builder = ParserBuilder::new();
         f(&mut builder);
@@ -434,11 +434,6 @@ mod tests {
         assert_eq!(given, dst);
     }
 
-    #[test]
-    fn scratch() {
-        roundtrip(".");
-    }
-
     #[test]
     fn print_literal() {
         roundtrip("a");

regex-syntax/src/hir/mod.rs

@@ -25,6 +25,7 @@ pub use hir::visitor::{Visitor, visit};
 
 mod interval;
 pub mod literal;
+pub mod print;
 pub mod translate;
 mod visitor;
 
@@ -152,6 +153,10 @@ impl fmt::Display for ErrorKind {
 ///    and can be computed cheaply during the construction process. For
 ///    example, one such attribute is whether the expression must match at the
 ///    beginning of the text.
+///
+/// Also, an `Hir`'s `fmt::Display` implementation prints an HIR as a regular
+/// expression pattern string, and uses constant stack space and heap space
+/// proportional to the size of the `Hir`.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Hir {
     /// The underlying HIR kind.
@@ -302,10 +307,7 @@ impl Hir {
         // A negated word boundary matches the empty string, but a normal
         // word boundary does not!
         info.set_match_empty(word_boundary.is_negated());
-        // ASCII word boundaries can match invalid UTF-8.
-        if let WordBoundary::Ascii = word_boundary {
-            info.set_always_utf8(false);
-        }
+        // Negated ASCII word boundaries can match invalid UTF-8.
         if let WordBoundary::AsciiNegate = word_boundary {
             info.set_always_utf8(false);
         }
@@ -605,6 +607,19 @@ impl HirKind {
     }
 }
 
+/// Print a display representation of this Hir.
+///
+/// The result of this is a valid regular expression pattern string.
+///
+/// This implementation uses constant stack space and heap space proportional
+/// to the size of the `Hir`.
+impl fmt::Display for Hir {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use hir::print::Printer;
+        Printer::new().print(self, f)
+    }
+}
+
 /// The high-level intermediate representation of a literal.
 ///
 /// A literal corresponds to a single character, where a character is either