Update AST -> AST.Node

Fix places that are currently producing and consuming
AST nodes to use `AST.Node` instead of `AST`.

This requires adding entry-points for both `AST`
and `AST.Node` for:

- renderAsCanonical
- printAsCanonical
- printAsPattern
- _render(in:)

Author: hamishknight

Sources/VariadicsGenerator/VariadicsGenerator.swift

@@ -255,7 +255,7 @@ struct VariadicsGenerator: ParsableCommand {
     outputForEach(
       0..<arity, separator: ", ", lineTerminator: ""
     ) { i in
-      "x\(i).\(patternProtocolRequirementName).ast"
+      "x\(i).\(patternProtocolRequirementName).ast.root"
     }
     output("))\n")
     output("  }\n}\n\n")

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -96,7 +96,7 @@ extension AST.Node {
   }
 
   /// If this node is a parent node, access its children
-  public var children: [AST]? {
+  public var children: [AST.Node]? {
     return (_associatedValue as? _ASTParent)?.children
   }
 
@@ -144,10 +144,10 @@ extension AST.Node {
 extension AST {
 
   public struct Alternation: Hashable, _ASTNode {
-    public let children: [AST]
+    public let children: [AST.Node]
     public let pipes: [SourceLocation]
 
-    public init(_ mems: [AST], pipes: [SourceLocation]) {
+    public init(_ mems: [AST.Node], pipes: [SourceLocation]) {
       // An alternation must have at least two branches (though the branches
       // may be empty AST nodes), and n - 1 pipes.
       precondition(mems.count >= 2)
@@ -163,10 +163,10 @@ extension AST {
   }
 
   public struct Concatenation: Hashable, _ASTNode {
-    public let children: [AST]
+    public let children: [AST.Node]
     public let location: SourceLocation
 
-    public init(_ mems: [AST], _ location: SourceLocation) {
+    public init(_ mems: [AST.Node], _ location: SourceLocation) {
       self.children = mems
       self.location = location
     }
@@ -218,16 +218,16 @@ extension AST {
     public enum Kind: Hashable {
       /// An absent repeater `(?~absent)`. This is equivalent to `(?~|absent|.*)`
       /// and therefore matches as long as the pattern `absent` is not matched.
-      case repeater(AST)
+      case repeater(AST.Node)
 
       /// An absent expression `(?~|absent|expr)`, which defines an `absent`
       /// pattern which must not be matched against while the pattern `expr` is
       /// matched.
-      case expression(absentee: AST, pipe: SourceLocation, expr: AST)
+      case expression(absentee: AST.Node, pipe: SourceLocation, expr: AST.Node)
 
       /// An absent stopper `(?~|absent)`, which prevents matching against
       /// `absent` until the end of the regex, or until it is cleared.
-      case stopper(AST)
+      case stopper(AST.Node)
 
       /// An absent clearer `(?~|)` which cancels the effect of an absent
       /// stopper.

Sources/_MatchingEngine/Regex/AST/ASTProtocols.swift

@@ -28,20 +28,20 @@ extension _ASTNode {
 }
 
 protocol _ASTParent: _ASTNode {
-  var children: [AST] { get }
+  var children: [AST.Node] { get }
 }
 
 extension AST.Concatenation: _ASTParent {}
 extension AST.Alternation: _ASTParent {}
 
 extension AST.Group: _ASTParent {
-  var children: [AST] { [child] }
+  var children: [AST.Node] { [child] }
 }
 extension AST.Quantification: _ASTParent {
-  var children: [AST] { [child] }
+  var children: [AST.Node] { [child] }
 }
 extension AST.AbsentFunction: _ASTParent {
-  var children: [AST] {
+  var children: [AST.Node] {
     switch kind {
     case .repeater(let a), .stopper(let a): return [a]
     case .expression(let a, _, let c):      return [a, c]

Sources/_MatchingEngine/Regex/AST/Atom.swift

@@ -689,7 +689,7 @@ extension AST.Atom {
   }
 }
 
-extension AST {
+extension AST.Node {
   public var literalStringValue: String? {
     switch self {
     case .atom(let a): return a.literalStringValue

Sources/_MatchingEngine/Regex/AST/Conditional.swift

@@ -14,13 +14,13 @@ extension AST {
     public var location: SourceLocation
     public var condition: Condition
 
-    public var trueBranch: AST
+    public var trueBranch: AST.Node
     public var pipe: SourceLocation?
-    public var falseBranch: AST
+    public var falseBranch: AST.Node
 
     public init(
-      _ condition: Condition, trueBranch: AST, pipe: SourceLocation?,
-      falseBranch: AST, _ location: SourceLocation
+      _ condition: Condition, trueBranch: AST.Node, pipe: SourceLocation?,
+      falseBranch: AST.Node, _ location: SourceLocation
     ) {
       self.location = location
       self.condition = condition

Sources/_MatchingEngine/Regex/AST/Group.swift

@@ -12,12 +12,12 @@
 extension AST {
   public struct Group: Hashable {
     public let kind: Located<Kind>
-    public let child: AST
+    public let child: AST.Node
 
     public let location: SourceLocation
 
     public init(
-      _ kind: Located<Kind>, _ child: AST, _ r: SourceLocation
+      _ kind: Located<Kind>, _ child: AST.Node, _ r: SourceLocation
     ) {
       self.kind = kind
       self.child = child

Sources/_MatchingEngine/Regex/AST/Quantification.swift

@@ -14,13 +14,13 @@ extension AST {
     public let amount: Located<Amount>
     public let kind: Located<Kind>
 
-    public let child: AST
+    public let child: AST.Node
     public let location: SourceLocation
 
     public init(
       _ amount: Located<Amount>,
       _ kind: Located<Kind>,
-      _ child: AST,
+      _ child: AST.Node,
       _ r: SourceLocation
     ) {
       self.amount = amount

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -25,7 +25,7 @@ public enum CaptureStructure: Equatable {
   }
 }
 
-extension AST {
+extension AST.Node {
   public var captureStructure: CaptureStructure {
     // Note: This implementation could be more optimized.
     switch self {
@@ -68,7 +68,7 @@ extension AST {
       var captures = CaptureStructure.empty
       switch c.condition.kind {
       case .group(let g):
-        captures = captures + AST.group(g).captureStructure
+        captures = captures + AST.Node.group(g).captureStructure
       default:
         break
       }

Sources/_MatchingEngine/Regex/Parse/Parse.swift

@@ -127,7 +127,7 @@ extension Parser {
       }
       fatalError("Unhandled termination condition")
     }
-    return ast
+    return .init(ast)
   }
 
   /// Parse a regular expression node. This should be used instead of `parse()`
@@ -136,7 +136,7 @@ extension Parser {
   ///     RegexNode    -> '' | Alternation
   ///     Alternation  -> Concatenation ('|' Concatenation)*
   ///
-  mutating func parseNode() throws -> AST {
+  mutating func parseNode() throws -> AST.Node {
     let _start = source.currentPosition
 
     if source.isEmpty { return .empty(.init(loc(_start))) }
@@ -163,8 +163,8 @@ extension Parser {
   ///     ConcatComponent -> Trivia | Quote | Quantification
   ///     Quantification  -> QuantOperand Quantifier?
   ///
-  mutating func parseConcatenation() throws -> AST {
-    var result = Array<AST>()
+  mutating func parseConcatenation() throws -> AST.Node {
+    var result = [AST.Node]()
     let _start = source.currentPosition
 
     while true {
@@ -219,9 +219,9 @@ extension Parser {
   /// Perform a recursive parse for the branches of a conditional.
   mutating func parseConditionalBranches(
     start: Source.Position, _ cond: AST.Conditional.Condition
-  ) throws -> AST {
+  ) throws -> AST.Node {
     let child = try parseNode()
-    let trueBranch: AST, falseBranch: AST, pipe: SourceLocation?
+    let trueBranch: AST.Node, falseBranch: AST.Node, pipe: SourceLocation?
     switch child {
     case .alternation(let a):
       // If we have an alternation child, we only accept 2 branches.
@@ -316,7 +316,7 @@ extension Parser {
   ///     Conditional      -> ConditionalStart Concatenation ('|' Concatenation)? ')'
   ///     ConditionalStart -> KnownConditionalStart | GroupConditionalStart
   ///
-  mutating func parseQuantifierOperand() throws -> AST? {
+  mutating func parseQuantifierOperand() throws -> AST.Node? {
     assert(!source.isEmpty)
 
     let _start = source.currentPosition

Sources/_MatchingEngine/Regex/Printing/DumpAST.swift

@@ -26,11 +26,11 @@ extension _ASTPrintable {
   public var description: String { _print() }
   public var debugDescription: String { _dump() }
 
-  var _children: [AST]? {
+  var _children: [AST.Node]? {
     if let children = (self as? _ASTParent)?.children {
       return children
     }
-    if let children = (self as? AST)?.children {
+    if let children = (self as? AST.Node)?.children {
       return children
     }
     return nil

Sources/_MatchingEngine/Regex/Printing/PrintAsCanonical.swift

@@ -26,13 +26,38 @@ extension AST {
   }
 }
 
+extension AST.Node {
+  /// Render using Swift's preferred regex literal syntax
+  public func renderAsCanonical(
+    showDelimiters delimiters: Bool = false,
+    terminateLine: Bool = false
+  ) -> String {
+    var printer = PrettyPrinter()
+    printer.printAsCanonical(
+       self,
+       delimiters: delimiters,
+       terminateLine: terminateLine)
+    return printer.finish()
+  }
+}
+
 extension PrettyPrinter {
   /// Will output `ast` in canonical form, taking care to
   /// also indent and terminate the line (updating internal state)
   mutating func printAsCanonical(
     _ ast: AST,
     delimiters: Bool = false,
     terminateLine terminate: Bool = true
+  ) {
+    printAsCanonical(ast.root, delimiters: delimiters, terminateLine: terminate)
+  }
+
+  /// Will output `ast` in canonical form, taking care to
+  /// also indent and terminate the line (updating internal state)
+  mutating func printAsCanonical(
+    _ ast: AST.Node,
+    delimiters: Bool = false,
+    terminateLine terminate: Bool = true
   ) {
     indent()
     if delimiters { output("'/") }
@@ -45,7 +70,7 @@ extension PrettyPrinter {
 
   /// Output the `ast` in canonical form, does not indent, terminate,
   /// or affect internal state
-  mutating func outputAsCanonical(_ ast: AST) {
+  mutating func outputAsCanonical(_ ast: AST.Node) {
     switch ast {
     case let .alternation(a):
       for idx in a.children.indices {

Sources/_MatchingEngine/Regex/Printing/PrintAsPattern.swift

@@ -31,7 +31,7 @@ extension AST {
 
 extension PrettyPrinter {
   /// If pattern printing should back off, prints the regex literal and returns true
-  mutating func patternBackoff(_ ast: AST) -> Bool {
+  mutating func patternBackoff(_ ast: AST.Node) -> Bool {
     if let max = maxTopDownLevels, depth >= max {
       return true
     }
@@ -42,6 +42,10 @@ extension PrettyPrinter {
   }
 
   mutating func printAsPattern(_ ast: AST) {
+    printAsPattern(ast.root)
+  }
+
+  mutating func printAsPattern(_ ast: AST.Node) {
     if patternBackoff(ast) {
       printAsCanonical(ast, delimiters: true)
       return
@@ -345,7 +349,7 @@ extension AST.Quantification.Kind {
   }
 }
 
-extension AST {
+extension AST.Node {
   var height: Int {
     // FIXME: Is this right for custom char classes?
     // How do we count set operations?

Sources/_MatchingEngine/Regex/Printing/RenderRanges.swift

@@ -10,17 +10,29 @@
 //===----------------------------------------------------------------------===//
 
 // Useful for testing, debugging, etc.
-extension AST {
-  func _postOrder() -> Array<AST> {
-    var nodes = Array<AST>()
+extension AST.Node {
+  func _postOrder() -> Array<AST.Node> {
+    var nodes = Array<AST.Node>()
     _postOrder(into: &nodes)
     return nodes
   }
-  func _postOrder(into array: inout Array<AST>) {
+  func _postOrder(into array: inout Array<AST.Node>) {
     children?.forEach { $0._postOrder(into: &array) }
     array.append(self)
   }
 
+  // Produce a textually "rendered" range
+  //
+  // 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)
+  }
+
   // We render from top-to-bottom, coalescing siblings
   public func _render(in input: String) -> [String] {
     let base = String(repeating: " ", count: input.count)
@@ -46,16 +58,10 @@ extension AST {
 
     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)
+}
+extension AST {
+  // We render from top-to-bottom, coalescing siblings
+  public func _render(in input: String) -> [String] {
+    root._render(in: input)
   }
 }