Cleanups and pretty printing (#159)

* [gardening] Keep parser comments consistent

* Pretty-print CaptureStructure

* Remove AnyCaptureType

* Hook up capture structure pretty printer to command line tools

Author: milseman

Sources/PatternConverter/PatternConverter.swift

@@ -30,6 +30,12 @@ struct PatternConverter: ParsableCommand {
   @Flag(help: "Whether to show canonical regex literal")
   var showCanonical: Bool = false
 
+  @Flag(help: "Whether to show capture structure")
+  var showCaptureStructure: Bool = false
+
+  @Flag(help: "Whether to skip result builder DSL")
+  var skipDSL: Bool = false
+
   @Option(help: "Limit (from top-down) the conversion levels")
   var topDownConversionLimit: Int?
 
@@ -65,12 +71,21 @@ struct PatternConverter: ParsableCommand {
       print()
     }
 
+    if showCaptureStructure {
+      print("Capture structure:")
+      print()
+      print(ast.captureStructure)
+      print()
+    }
+
     print()
-    let render = ast.renderAsBuilderDSL(
-      maxTopDownLevels: topDownConversionLimit,
-      minBottomUpLevels: bottomUpConversionLimit
-    )
-    print(render)
+    if !skipDSL {
+      let render = ast.renderAsBuilderDSL(
+        maxTopDownLevels: topDownConversionLimit,
+        minBottomUpLevels: bottomUpConversionLimit
+      )
+      print(render)
+    }
 
     return
   }

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -400,3 +400,39 @@ extension CaptureStructure {
     self = currentScope.count == 1 ? currentScope[0] : .tuple(currentScope)
   }
 }
+
+extension CaptureStructure: CustomStringConvertible {
+  public var description: String {
+    var printer = PrettyPrinter()
+    _print(&printer)
+    return printer.finish()
+  }
+
+  private func _print(_ printer: inout PrettyPrinter) {
+    switch self {
+    case let .atom(name, type):
+      let name = name ?? "<unnamed>"
+      let type = type == nil ? "<untyped>"
+                             : String(describing: type)
+      printer.print("Atom(\(name): \(type))")
+
+    case let .array(c):
+      printer.printBlock("Array") { printer in
+        c._print(&printer)
+      }
+
+    case let .optional(c):
+      printer.printBlock("Optional") { printer in
+        c._print(&printer)
+      }
+
+    case let .tuple(cs):
+      printer.printBlock("Tuple") { printer in
+        for c in cs {
+          c._print(&printer)
+        }
+      }
+
+    }
+  }
+}

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -1022,7 +1022,7 @@ extension Source {
 
   /// Attempt to lex the start of a group conditional.
   ///
-  ///     GroupConditionalStart -> '(?' GroupStart
+  ///     GroupCondStart -> '(?' GroupStart
   ///
   mutating func lexGroupConditionalStart(
     context: ParsingContext

Sources/_MatchingEngine/Regex/Parse/Parse.swift

@@ -13,25 +13,33 @@
 
 Syntactic structure of a regular expression
 
- Regex           -> '' | Alternation
+ Regex           -> GlobalMatchingOptionSequence? RegexNode
+ RegexNode       -> '' | Alternation
  Alternation     -> Concatenation ('|' Concatenation)*
  Concatenation   -> (!'|' !')' ConcatComponent)*
  ConcatComponent -> Trivia | Quote | Quantification
  Quantification  -> QuantOperand Quantifier?
- QuantOperand    -> Group | CustomCharClass | Atom
- Group           -> GroupStart Regex ')'
+ QuantOperand    -> Conditional | Group | CustomCharClass
+                  | Atom | AbsentFunction
+
+ Conditional -> CondStart Concatenation ('|' Concatenation)? ')'
+ CondStart   -> KnownCondStart | GroupCondStart
+
+ Group       -> GroupStart RegexNode ')'
 
 Custom character classes are a mini-language to their own. We
 support UTS#18 set operators and nested character classes. The
 meaning of some atoms, such as `\b` changes inside a custom
-chararacter class. Below, we have a grammar "scope", that is we say
-"SetOp" to mean "CustomCharactetClass.SetOp", so we don't have to
-abbreviate/obfuscate/disambiguate with ugly names like "CCCSetOp".
+chararacter class. Below, we have a grammar "scope", that is we
+say "SetOp" to mean "CustomCharactetClass.SetOp", so we don't
+have to abbreviate/obfuscate/disambiguate with ugly names like
+"CCCSetOp".
 
 Also, PCRE lets you end in `&&`, but not Oniguruma as it's a set
-operator. We probably want a rule similar to how you can end in `-`
-and that's just the character. Perhaps we also have syntax options
-in case we need a compatibilty mode (it's easy to add here and now)
+operator. We probably want a rule similar to how you can end in
+`-` and that's just the character. Perhaps we also have syntax
+options in case we need a compatibilty mode (it's easy to add
+here and now)
 
  CustomCharClass -> Start Set (SetOp Set)* ']'
  Set             -> Member+
@@ -46,6 +54,9 @@ Lexical analysis provides the following:
  Quantifier -> `lexQuantifier`
  GroupStart -> `lexGroupStart`
 
+ GroupCondStart -> `lexGroupConditionalStart`
+ KnownCondStart -> `lexKnownCondition`
+
  CustomCharacterClass.Start -> `lexCustomCCStart`
  CustomCharacterClass.SetOp -> `lexCustomCCBinOp`
 
@@ -353,9 +364,9 @@ extension Parser {
   ///
   ///     QuantOperand     -> Conditional | Group | CustomCharClass | Atom
   ///                       | AbsentFunction
-  ///     Group            -> GroupStart RecursiveRegex ')'
-  ///     Conditional      -> ConditionalStart Concatenation ('|' Concatenation)? ')'
-  ///     ConditionalStart -> KnownConditionalStart | GroupConditionalStart
+  ///     Group            -> GroupStart RegexNode ')'
+  ///     Conditional      -> CondStart Concatenation ('|' Concatenation)? ')'
+  ///     CondStart        -> KnownCondStart | GroupCondStart
   ///
   mutating func parseQuantifierOperand() throws -> AST.Node? {
     assert(!source.isEmpty)

Sources/_StringProcessing/Capture.swift

@@ -17,15 +17,15 @@ enum Capture {
   case atom(Any)
   indirect case tuple([Capture])
   indirect case some(Capture)
-  case none(childType: AnyCaptureType)
-  indirect case array([Capture], childType: AnyCaptureType)
+  case none(childType: AnyType)
+  indirect case array([Capture], childType: AnyType)
 
   static func none(childType: Any.Type) -> Capture {
-    .none(childType: AnyCaptureType(childType))
+    .none(childType: AnyType(childType))
   }
 
   static func array(_ children: [Capture], childType: Any.Type) -> Capture {
-    .array(children, childType: AnyCaptureType(childType))
+    .array(children, childType: AnyType(childType))
   }
 }
 
@@ -77,19 +77,44 @@ extension Capture {
   }
 }
 
-/// A wrapper of an existential metatype, equatable and hashable by reference.
-struct AnyCaptureType: Equatable, Hashable {
-  var base: Any.Type
-
-  init(_ type: Any.Type) {
-    base = type
+extension Capture: CustomStringConvertible {
+  public var description: String {
+    var printer = PrettyPrinter()
+    _print(&printer)
+    return printer.finish()
   }
 
-  static func == (lhs: AnyCaptureType, rhs: AnyCaptureType) -> Bool {
-    lhs.base == rhs.base
-  }
+  private func _print(_ printer: inout PrettyPrinter) {
+    switch self {
+    case let .atom(n):
+      printer.print("Atom(\(n))")
+    case let .tuple(ns):
+      if ns.isEmpty {
+        printer.print("Tuple()")
+        return
+      }
+
+      printer.printBlock("Tuple") { printer in
+        for n in ns {
+          n._print(&printer)
+        }
+      }
 
-  func hash(into hasher: inout Hasher) {
-    hasher.combine(ObjectIdentifier(base))
+    case let .some(n):
+      printer.printBlock("Tuple") { printer in
+        n._print(&printer)
+      }
+
+    case let .none(childType):
+      printer.print("None(\(childType))")
+
+    case let .array(ns, childType):
+      printer.printBlock("Array(\(childType))") { printer in
+        for n in ns {
+          n._print(&printer)
+        }
+      }
+
+    }
   }
 }

Sources/_StringProcessing/Legacy/RECode.swift

@@ -75,11 +75,11 @@ extension RECode {
     case captureSome
 
     /// Replace top-level captures with a single `Capture.optional(nil)`.
-    case captureNil(childType: AnyCaptureType)
+    case captureNil(childType: AnyType)
 
     /// Form a `Capture.array(...)` from top-level captures, and use it to replace the top-level
     /// captures.
-    case captureArray(childType: AnyCaptureType)
+    case captureArray(childType: AnyType)
 
     var isAccept: Bool {
       switch self {
@@ -132,11 +132,11 @@ extension RECode.Instruction {
   static func label(_ i: Int) -> Self { .label(LabelId(i)) }
 
   static func captureNil(childType: Any.Type) -> Self {
-    .captureNil(childType: AnyCaptureType(childType))
+    .captureNil(childType: AnyType(childType))
   }
 
   static func captureArray(childType: Any.Type) -> Self {
-    .captureArray(childType: AnyCaptureType(childType))
+    .captureArray(childType: AnyType(childType))
   }
 }
 

Sources/_StringProcessing/Legacy/VirtualMachine.swift

@@ -129,15 +129,15 @@ extension RECode {
       topLevelCaptures = top
     }
 
-    mutating func captureNil(childType: AnyCaptureType) {
+    mutating func captureNil(childType: AnyType) {
       topLevelCaptures = [.none(childType: childType)]
     }
 
     mutating func captureSome() {
       topLevelCaptures = [.some(.tupleOrAtom(topLevelCaptures))]
     }
 
-    mutating func captureArray(childType: AnyCaptureType) {
+    mutating func captureArray(childType: AnyType) {
       topLevelCaptures = [.array(topLevelCaptures, childType: childType)]
     }