moar capture list

Author: milseman

Sources/_RegexParser/Regex/Parse/CaptureList.swift

@@ -10,7 +10,7 @@
 //===----------------------------------------------------------------------===//
 
 public struct CaptureList {
-  var captures: [Capture]
+  public var captures: [Capture]
 
   public init() {
     captures = []
@@ -23,9 +23,9 @@ public struct CaptureList {
 
 extension CaptureList {
   public struct Capture {
-    var name: String?
-    var type: Any.Type?
-    var optionalDepth: Int
+    public var name: String?
+    public var type: Any.Type?
+    public var optionalDepth: Int
 
     public init(
       name: String? = nil,

Sources/_StringProcessing/Engine/Structuralize.swift

@@ -1,78 +1,21 @@
 @_implementationOnly import _RegexParser
 
-extension CaptureStructure {
-  var optionalCount: Int {
-    switch self {
-    case .atom: return 0
-    case .optional(let o):
-      return 1 + o.optionalCount
-    case .tuple:
-      // FIXME: Separate CaptureStructure and a component
-      fatalError("Recursive nesting")
-    @unknown default:
-      fatalError("Unknown default")
-    }
-  }
-
-  // FIXME: Do it all in one pass, no need for all these
-  // intermediary arrays
+extension CaptureList {
   func structuralize(
     _ list: MECaptureList,
     _ input: String
-  ) throws -> [StructuredCapture] {
-
-    func mapCap(
-      _ cap: CaptureStructure,
-      _ storedCap: Processor<String>._StoredCapture
-    ) -> StructuredCapture {
-      // TODO: CaptureList perhaps should store a
-      // metatype or relevant info...
-      let optCount = cap.optionalCount
-
-      if cap.atomType.base == Substring.self {
-        // FIXME: What if a typed capture is Substring?
-        assert(!storedCap.hasValues)
-
-        if let r = storedCap.latest {
-          return StructuredCapture(
-            optionalCount: optCount,
-            storedCapture: StoredCapture(range: r))
-        }
+  ) -> [StructuredCapture] {
+    assert(list.values.count == captures.count)
 
-        return StructuredCapture(
-          optionalCount: optCount,
-          storedCapture: nil)
-      }
+    var result = [StructuredCapture]()
+    for (cap, meStored) in zip(self.captures, list.values) {
+      let stored = StoredCapture(
+        range: meStored.latest, value: meStored.latestValue)
 
-      guard (storedCap.isEmpty || storedCap.hasValues) else {
-        print(storedCap)
-        fatalError()
-      }
-      // TODO: assert types are the same, under all the
-      // optionals
-
-      if let v = storedCap.latestValue {
-        return StructuredCapture(
-          optionalCount: optCount,
-          storedCapture: StoredCapture(range: storedCap.latest, value: v))
-      }
-      return StructuredCapture(
-        optionalCount: optCount,
-        storedCapture: nil)
-    }
-
-    switch self {
-    case let .tuple(values):
-      assert(list.values.count == values.count)
-      var result = Array<StructuredCapture>()
-      for (cap, storedCap) in zip(values, list.values) {
-        result.append(mapCap(cap, storedCap))
-      }
-      return result
-
-    default:
-      assert(list.values.count == 1)
-      return [mapCap(self, list.values.first!)]
+      result.append(.init(
+        optionalCount: cap.optionalDepth, storedCapture: stored))
     }
+    return result
   }
 }
+

Sources/_StringProcessing/Executor.swift

@@ -40,10 +40,8 @@ struct Executor {
       referencedCaptureOffsets: engine.program.referencedCaptureOffsets,
       namedCaptureOffsets: engine.program.namedCaptureOffsets)
 
-    let capStruct = engine.program.captureList._captureStructure(nestOptionals: true)
     let range = inputRange.lowerBound..<endIdx
-    let caps = try capStruct.structuralize(
-        capList, input)
+    let caps = engine.program.captureList.structuralize(capList, input)
 
     // FIXME: This is a workaround for not tracking (or
     // specially compiling) whole-match values.

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -343,11 +343,6 @@ extension DSLTree.Node {
   }
 }
 
-extension DSLTree {
-  var captureStructure: CaptureStructure {
-    root._captureList._captureStructure(nestOptionals: true)
-  }
-}
 extension DSLTree.Node {
   /// For typed capture-producing nodes, the type produced.
   var valueCaptureType: AnyType? {
@@ -574,10 +569,6 @@ extension DSLTree {
         return abs.ast.children.map(\.dslTreeNode).map(_Tree.init)
       }
     }
-
-    func _captureStructure() -> CaptureStructure {
-      self.node._captureList._captureStructure(nestOptionals: true)
-    }
   }
 
   @_spi(RegexBuilder)

Tests/RegexTests/CaptureTests.swift

@@ -131,7 +131,7 @@ func captureTest(
   }
 
   // Ensure DSLTree preserves literal captures
-  let dslCapStructure = ast.dslTree.captureStructure
+  let dslCapStructure = ast.dslTree.root._captureList._captureStructure(nestOptionals: true)
   guard dslCapStructure == capStructure else {
     XCTFail("""
       DSLTree did not preserve structure: