A tale of two pretty printers and one executable (#97)

Canonical literal and pattern DSL pretty-printers

`PrintAsCanonical` will pretty-print an AST using Swift's preferred, canonical regex literal syntax. The parser accepts many things, but Swift can have an opinion on which is the preferred way to spell something.

`PrintAsPattern` will print as a result builder DSL. It is parameterized over a maximum top-down levels to convert (everything below that will be a canonical regex literal) as well as a minimum-tree-height value (everything below _that_ will also be printed as a canonical regex literal).

Also included is an executable to drive these API.

Naming scheme:

AST's `renderFoo` will take options and output a String.

AST value's `_canonicalBase` produces a string of that value in Swift's canonical regex form.

PrettyPrinter's `output` will accumulate the given contents without indentation, newlines, and internal state updates.

PrettyPrinter's `print` will indent, insert newlines, and update internal state.

Author: milseman

Package.swift

@@ -47,9 +47,6 @@ let package = Package(
         .target(
             name: "Prototypes",
             dependencies: ["_MatchingEngine"]),
-        .testTarget(
-            name: "AlgorithmsTests",
-            dependencies: ["_StringProcessing"]),
         .testTarget(
           name: "UnicodeTests",
           dependencies: ["_Unicode"]),
@@ -60,6 +57,12 @@ let package = Package(
             dependencies: [
               .product(name: "ArgumentParser", package: "swift-argument-parser")
             ]),
+        .executableTarget(
+            name: "PatternConverter",
+            dependencies: [
+              .product(name: "ArgumentParser", package: "swift-argument-parser"),
+              "_MatchingEngine",
+            ]),
 
         // MARK: Exercises
         .target(

Sources/PatternConverter/PatternConverter.swift

@@ -0,0 +1,65 @@
+// swift run PatternConverter <regex>
+
+import ArgumentParser
+import _MatchingEngine
+
+@main
+struct PatternConverter: ParsableCommand {
+
+  @Argument(help: "The regex to convert")
+  var regex: String
+
+  @Flag(help: "Whether to use the experimental syntax")
+  var experimentalSyntax: Bool = false
+
+  @Flag(help: "Whether to show rendered source ranges")
+  var renderSourceRanges: Bool = false
+
+  @Flag(help: "Whether to show canonical regex literal")
+  var showCanonical: Bool = false
+
+  @Option(help: "Limit (from top-down) the conversion levels")
+  var topDownConversionLimit: Int?
+
+  @Option(help: "(TODO) Limit (from bottom-up) the conversion levels")
+  var bottomUpConversionLimit: Int?
+
+  func run() throws {
+    print("""
+
+    NOTE: This tool is experimental and its output is not
+          necessarily compilable.
+
+    """)
+    let delim = experimentalSyntax ? "|" : "/"
+    print("Converting '\(delim)\(regex)\(delim)'")
+
+    let ast = try _MatchingEngine.parse(
+      regex,
+      experimentalSyntax ? .experimental : .traditional)
+
+    // Show rendered source ranges
+    if renderSourceRanges {
+      print()
+      print(regex)
+      print(ast._render(in: regex).joined(separator: "\n"))
+      print()
+    }
+
+    if showCanonical {
+      print("Canonical:")
+      print()
+      print(ast.renderAsCanonical())
+      print()
+    }
+
+    print()
+    let render = ast.renderAsPattern(
+      maxTopDownLevels: topDownConversionLimit,
+      minBottomUpLevels: bottomUpConversionLimit
+    )
+    print(render)
+
+    return
+  }
+}

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -55,6 +55,10 @@ extension AST {
     }
   }
 
+  func `as`<T: _ASTNode>(_ t: T.Type = T.self) -> T? {
+    _associatedValue as? T
+  }
+
   /// If this node is a parent node, access its children
   public var children: [AST]? {
     return (_associatedValue as? _ASTParent)?.children
@@ -94,8 +98,6 @@ extension AST {
       self.children = mems
       self.location = location
     }
-
-    public var _dumpBase: String { "alternation" }
   }
 
   public struct Concatenation: Hashable, _ASTNode {
@@ -106,8 +108,6 @@ extension AST {
       self.children = mems
       self.location = location
     }
-
-    public var _dumpBase: String { "" }
   }
 
   public struct Quote: Hashable, _ASTNode {
@@ -118,8 +118,6 @@ extension AST {
       self.literal = s
       self.location = location
     }
-
-    public var _dumpBase: String { "quote" }
   }
 
   public struct Trivia: Hashable, _ASTNode {
@@ -135,11 +133,6 @@ extension AST {
       self.contents = v.value
       self.location = v.location
     }
-
-    public var _dumpBase: String {
-      // TODO: comments, non-semantic whitespace, etc.
-      ""
-    }
   }
 
   public struct Empty: Hashable, _ASTNode {
@@ -148,8 +141,6 @@ extension AST {
     public init(_ location: SourceLocation) {
       self.location = location
     }
-
-    public var _dumpBase: String { "" }
   }
 }
 

Sources/_MatchingEngine/Regex/AST/ASTProtocols.swift

@@ -29,112 +29,3 @@ extension AST.Group: _ASTParent {
 extension AST.Quantification: _ASTParent {
   var children: [AST] { [child] }
 }
-
-
-// MARK: - Printing
-
-/// AST entities can be pretty-printed or dumped
-///
-/// Alternative: just use `description` for pretty-print
-/// and `debugDescription` for dump
-public protocol _ASTPrintable:
-  CustomStringConvertible,
-  CustomDebugStringConvertible
-{
-  // The "base" dump out for AST nodes, like `alternation`.
-  // Children printing, parens, etc., handled automatically
-  var _dumpBase: String { get }
-
-}
-extension _ASTPrintable {
-  public var description: String { _print() }
-  public var debugDescription: String { _dump() }
-
-  var _children: [AST]? {
-    if let children = (self as? _ASTParent)?.children {
-      return children
-    }
-    if let children = (self as? AST)?.children {
-      return children
-    }
-    return nil
-  }
-
-  func _print() -> String {
-    // TODO: prettier printing
-    _dump()
-  }
-  func _dump() -> String {
-    guard let children = _children else {
-      return _dumpBase
-    }
-    let sub = children.lazy.compactMap {
-      // Exclude trivia for now, as we don't want it to appear when performing
-      // comparisons of dumped output in tests.
-      // TODO: We should eventually have some way of filtering out trivia for
-      // tests, so that it can appear in regular dumps.
-      if $0.isTrivia { return nil }
-      return $0._dump()
-    }.joined(separator: ",")
-    return "\(_dumpBase)(\(sub))"
-  }
-}
-
-extension AST: _ASTPrintable {
-  public var _dumpBase: String {
-    _associatedValue._dumpBase
-  }
-}
-
-// MARK: - Rendering
-
-// Useful for testing, debugging, etc.
-extension AST {
-  func _postOrder() -> Array<AST> {
-    var nodes = Array<AST>()
-    _postOrder(into: &nodes)
-    return nodes
-  }
-  func _postOrder(into array: inout Array<AST>) {
-    children?.forEach { $0._postOrder(into: &array) }
-    array.append(self)
-  }
-
-  // We render from top-to-bottom, coalescing siblings
-  public func _render(in input: String) -> [String] {
-    let base = String(repeating: " ", count: input.count)
-    var lines = [base]
-
-    // TODO: drop the filtering when fake-ness is taken out of
-    // this module
-    let nodes = _postOrder().filter(\.location.isReal)
-
-    nodes.forEach { node in
-      let loc = node.location
-      let count = input[loc.range].count
-      for idx in lines.indices {
-        if lines[idx][loc.range].all(\.isWhitespace) {
-          node._renderRange(count: count, into: &lines[idx])
-          return
-        }
-      }
-      var nextLine = base
-      node._renderRange(count: count, into: &nextLine)
-      lines.append(nextLine)
-    }
-
-    return lines.first!.all(\.isWhitespace) ? [] : lines
-  }
-
-  // Produce a textually "rendered" rane
-  //
-  // NOTE: `input` must be the string from which a
-  // source range was derived.
-  func _renderRange(
-    count: Int, into output: inout String
-  ) {
-    guard count > 0 else { return }
-    let repl = String(repeating: "-", count: count-1) + "^"
-    output.replaceSubrange(location.range, with: repl)
-  }
-}