DSLTree

Package.swift

@@ -68,6 +68,7 @@ let package = Package(
             dependencies: [
               .product(name: "ArgumentParser", package: "swift-argument-parser"),
               "_MatchingEngine",
+              "_StringProcessing"
             ]),
 
         // MARK: Exercises

Sources/PatternConverter/PatternConverter.swift

@@ -13,6 +13,7 @@
 
 import ArgumentParser
 import _MatchingEngine
+import _StringProcessing
 
 @main
 struct PatternConverter: ParsableCommand {

Sources/VariadicsGenerator/VariadicsGenerator.swift

@@ -251,13 +251,13 @@ struct VariadicsGenerator: ParsableCommand {
     output("  init(")
     outputForEach(0..<arity, separator: ", ") { "_ x\($0): T\($0)" }
     output(") {\n")
-    output("    \(patternProtocolRequirementName) = .init(ast: concat(\n      ")
+    output("    \(patternProtocolRequirementName) = .init(node: .concatenation([\n      ")
     outputForEach(
       0..<arity, separator: ", ", lineTerminator: ""
     ) { i in
-      "x\(i).\(patternProtocolRequirementName).ast.root"
+      "x\(i).\(patternProtocolRequirementName).root"
     }
-    output("))\n")
+    output("]))\n")
     output("  }\n}\n\n")
 
     // Emit concatenation builders.

Sources/_MatchingEngine/Engine/Processor.swift

@@ -93,6 +93,12 @@ extension Processor {
 }
 
 extension Processor {
+  var slice: Input.SubSequence {
+    // TODO: Should we whole-scale switch to slices, or
+    // does that depend on options for some anchors?
+    input[bounds]
+  }
+
   // Advance in our input
   //
   // Returns whether the advance succeeded. On failure, our
@@ -125,7 +131,7 @@ extension Processor {
     currentPosition < end ? input[currentPosition] : nil
   }
   func load(count: Int) -> Input.SubSequence? {
-    let slice = input[currentPosition...].prefix(count)
+    let slice = self.slice[currentPosition...].prefix(count)
     guard slice.count == count else { return nil }
     return slice
   }

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -33,7 +33,7 @@ extension AST {
   /// A node in the regex AST.
   @frozen
   public indirect enum Node:
-    Hashable/*, _ASTPrintable ASTValue, ASTAction*/
+    Hashable, _TreeNode //, _ASTPrintable ASTValue, ASTAction
   {
     /// ... | ... | ...
     case alternation(Alternation)
@@ -94,7 +94,7 @@ extension AST.Node {
     }
   }
 
-  func `as`<T: _ASTNode>(_ t: T.Type = T.self) -> T? {
+  public func `as`<T: _ASTNode>(_ t: T.Type = T.self) -> T? {
     _associatedValue as? T
   }
 

Sources/_MatchingEngine/Regex/AST/ASTProtocols.swift

@@ -19,7 +19,7 @@
 
 // MARK: - AST parent/child
 
-protocol _ASTNode: _ASTPrintable {
+public protocol _ASTNode: _ASTPrintable {
   var location: SourceLocation { get }
 }
 extension _ASTNode {
@@ -41,7 +41,7 @@ extension AST.Quantification: _ASTParent {
   var children: [AST.Node] { [child] }
 }
 extension AST.AbsentFunction: _ASTParent {
-  var children: [AST.Node] {
+  public 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/Group.swift

@@ -112,12 +112,12 @@ extension AST.Group.Kind {
   }
 }
 
-extension AST.Group {
+extension AST.Group.Kind {
   /// If this group is a lookaround assertion, return its direction
   /// and whether it is positive or negative. Otherwise returns
   /// `nil`.
   public var lookaroundKind: (forwards: Bool, positive: Bool)? {
-    switch self.kind.value {
+    switch self {
     case .lookahead:         return (true, true)
     case .negativeLookahead: return (true, false)
     case .lookbehind:         return (false, true)

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -25,71 +25,138 @@ public enum CaptureStructure: Equatable {
   }
 }
 
+extension CaptureStructure {
+  public init<C: Collection>(
+    alternating children: C
+  ) where C.Element: _TreeNode {
+    assert(children.count > 1)
+    self = children
+      .map(\.captureStructure)
+      .reduce(.empty, +)
+      .map(CaptureStructure.optional)
+  }
+  public init<C: Collection>(
+    concatenating children: C
+  ) where C.Element: _TreeNode {
+    self = children.map(\.captureStructure).reduce(.empty, +)
+  }
+
+  public init<T: _TreeNode>(
+    grouping child: T, as kind: AST.Group.Kind
+  ) {
+    let innerCaptures = child.captureStructure
+    switch kind {
+    case .capture:
+      self = .atom() + innerCaptures
+    case .namedCapture(let name):
+      self = .atom(name: name.value) + innerCaptures
+    case .balancedCapture(let b):
+      self = .atom(name: b.name?.value) + innerCaptures
+    default:
+      precondition(!kind.isCapturing)
+      self = innerCaptures
+    }
+  }
+
+  public init<T: _TreeNode>(
+    grouping child: T,
+    as kind: AST.Group.Kind,
+    withTransform transform: CaptureTransform
+  ) {
+    let innerCaptures = child.captureStructure
+    switch kind {
+    case .capture:
+      self = .atom(type: AnyType(transform.resultType)) + innerCaptures
+    case .namedCapture(let name):
+      self = .atom(name: name.value, type: AnyType(transform.resultType))
+        + innerCaptures
+    default:
+      self = innerCaptures
+    }
+  }
+
+  // TODO: We'll likely want/need a generalization of
+  // conditional's condition kind.
+  public init<T: _TreeNode>(
+    condition: AST.Conditional.Condition.Kind,
+    trueBranch: T,
+    falseBranch: T
+  ) {
+    // A conditional's capture structure is effectively that of an alternation
+    // between the true and false branches. However the condition may also
+    // have captures in the case of a group condition.
+    var captures = CaptureStructure.empty
+    switch condition {
+    case .group(let g):
+      captures = captures + AST.Node.group(g).captureStructure
+    default:
+      break
+    }
+    let branchCaptures = trueBranch.captureStructure +
+                         falseBranch.captureStructure
+    self = captures + branchCaptures.map(
+      CaptureStructure.optional)
+  }
+
+  public init<T: _TreeNode>(
+    quantifying child: T, amount: AST.Quantification.Amount
+  ) {
+    self = child.captureStructure.map(
+      amount == .zeroOrOne
+        ? CaptureStructure.optional
+        : CaptureStructure.array)
+  }
+
+  // TODO: Will need to adjust for DSLTree support, and
+  // "absent" isn't the best name for these.
+  public init(
+    absent kind: AST.AbsentFunction.Kind
+  ) {
+    // Only the child of an expression absent function is relevant, as the
+    // other expressions don't actually get matched against.
+    switch kind {
+    case .expression(_, _, let child):
+      self = child.captureStructure
+    case .clearer, .repeater, .stopper:
+      self = .empty
+    }
+  }
+
+}
+
 extension AST.Node {
   public var captureStructure: CaptureStructure {
     // Note: This implementation could be more optimized.
     switch self {
-    case .alternation(let alternation):
-      assert(alternation.children.count > 1)
-      return alternation.children
-        .map(\.captureStructure)
-        .reduce(.empty, +)
-        .map(CaptureStructure.optional)
-    case .concatenation(let concatenation):
-      return concatenation.children.map(\.captureStructure).reduce(.empty, +)
-    case .group(let group):
-      let innerCaptures = group.child.captureStructure
-      switch group.kind.value {
-      case .capture:
-        return .atom() + innerCaptures
-      case .namedCapture(let name):
-        return .atom(name: name.value) + innerCaptures
-      case .balancedCapture(let b):
-        return .atom(name: b.name?.value) + innerCaptures
-      default:
-        precondition(!group.kind.value.isCapturing)
-        return innerCaptures
-      }
-    case .groupTransform(let group, let transform):
-      let innerCaptures = group.child.captureStructure
-      switch group.kind.value {
-      case .capture:
-        return .atom(type: AnyType(transform.resultType)) + innerCaptures
-      case .namedCapture(let name):
-        return .atom(name: name.value, type: AnyType(transform.resultType))
-          + innerCaptures
-      default:
-        return innerCaptures
-      }
+    case let .alternation(a):
+      return CaptureStructure(alternating: a.children)
+
+    case let .concatenation(c):
+      return CaptureStructure(concatenating: c.children)
+
+    case let .group(g):
+      return CaptureStructure(
+        grouping: g.child, as: g.kind.value)
+
+    case .groupTransform(let g, let transform):
+      return CaptureStructure(
+        grouping: g.child,
+        as: g.kind.value,
+        withTransform: transform)
+
     case .conditional(let c):
-      // A conditional's capture structure is effectively that of an alternation
-      // between the true and false branches. However the condition may also
-      // have captures in the case of a group condition.
-      var captures = CaptureStructure.empty
-      switch c.condition.kind {
-      case .group(let g):
-        captures = captures + AST.Node.group(g).captureStructure
-      default:
-        break
-      }
-      let branchCaptures = c.trueBranch.captureStructure +
-                           c.falseBranch.captureStructure
-      return captures + branchCaptures.map(CaptureStructure.optional)
-
-    case .quantification(let quantification):
-      return quantification.child.captureStructure.map(
-        quantification.amount.value == .zeroOrOne
-          ? CaptureStructure.optional
-          : CaptureStructure.array)
+      return CaptureStructure(
+        condition: c.condition.kind,
+        trueBranch: c.trueBranch,
+        falseBranch: c.falseBranch)
+
+    case .quantification(let q):
+      return CaptureStructure(
+        quantifying: q.child, amount: q.amount.value)
+
     case .absentFunction(let abs):
-      // Only the child of an expression absent function is relevant, as the
-      // other expressions don't actually get matched against.
-      switch abs.kind {
-      case .expression(_, _, let child):
-        return child.captureStructure
-      case .clearer, .repeater, .stopper:
-        return .empty
-      }
+      return CaptureStructure(absent: abs.kind)
+
     case .quote, .trivia, .atom, .customCharacterClass, .empty:
       return .empty
     }