Refactor AST into a struct containing AST.Node enum

Introduce `AST` as a new root type, with `AST.Node`
becoming the type used to represent a particular
node in the AST. This will allow us to store top-level
state on the `AST` type rather than for each `AST.Node`.

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -9,47 +9,64 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// A regex abstract syntax tree
-@frozen
-public indirect enum AST:
-  Hashable/*, _ASTPrintable ASTValue, ASTAction*/
-{
-  /// ... | ... | ...
-  case alternation(Alternation)
+/// A regex abstract syntax tree. This is a top-level type that stores the root
+/// node.
+public struct AST: Hashable {
+  public var root: AST.Node
+  public init(_ root: AST.Node) {
+    self.root = root
+  }
+}
 
-  /// ... ...
-  case concatenation(Concatenation)
+extension AST {
+  /// Whether this AST tree has nested somewhere inside it a capture.
+  public var hasCapture: Bool { root.hasCapture }
 
-  /// (...)
-  case group(Group)
+  /// The capture structure of this AST tree.
+  public var captureStructure: CaptureStructure { root.captureStructure }
+}
 
-  /// (?(cond) true-branch | false-branch)
-  case conditional(Conditional)
+extension AST {
+  /// A node in the regex AST.
+  @frozen
+  public indirect enum Node:
+    Hashable/*, _ASTPrintable ASTValue, ASTAction*/
+  {
+    /// ... | ... | ...
+    case alternation(Alternation)
 
-  case quantification(Quantification)
+    /// ... ...
+    case concatenation(Concatenation)
 
-  /// \Q...\E
-  case quote(Quote)
+    /// (...)
+    case group(Group)
 
-  /// Comments, non-semantic whitespace, etc
-  case trivia(Trivia)
+    /// (?(cond) true-branch | false-branch)
+    case conditional(Conditional)
 
-  case atom(Atom)
+    case quantification(Quantification)
 
-  case customCharacterClass(CustomCharacterClass)
+    /// \Q...\E
+    case quote(Quote)
 
-  case absentFunction(AbsentFunction)
+    /// Comments, non-semantic whitespace, etc
+    case trivia(Trivia)
 
-  case empty(Empty)
+    case atom(Atom)
 
-  // FIXME: Move off the regex literal AST
-  case groupTransform(
-    Group, transform: CaptureTransform)
-}
+    case customCharacterClass(CustomCharacterClass)
 
-// TODO: Do we want something that holds the AST and stored global options?
+    case absentFunction(AbsentFunction)
 
-extension AST {
+    case empty(Empty)
+
+    // FIXME: Move off the regex literal AST
+    case groupTransform(
+      Group, transform: CaptureTransform)
+  }
+}
+
+extension AST.Node {
   // :-(
   //
   // Existential-based programming is highly prone to silent

Sources/_MatchingEngine/Regex/Printing/DumpAST.swift

@@ -57,6 +57,12 @@ extension _ASTPrintable {
 }
 
 extension AST: _ASTPrintable {
+  public var _dumpBase: String {
+    root._dumpBase
+  }
+}
+
+extension AST.Node: _ASTPrintable {
   public var _dumpBase: String {
     _associatedValue._dumpBase
   }