Merge pull request #222 from rxwei/anyregexoutput

Author: rxwei

Sources/_StringProcessing/Capture.swift

@@ -33,7 +33,7 @@ struct StoredCapture {
 }
 
 // TODO: Where should this live? Inside TypeConstruction?
-func constructExistentialMatchComponent(
+func constructExistentialOutputComponent(
   from input: Substring,
   in range: Range<String.Index>?,
   value: Any?,
@@ -62,10 +62,10 @@ func constructExistentialMatchComponent(
 }
 
 extension StructuredCapture {
-  func existentialMatchComponent(
+  func existentialOutputComponent(
     from input: Substring
   ) -> Any {
-    constructExistentialMatchComponent(
+    constructExistentialOutputComponent(
       from: input,
       in: storedCapture?.range,
       value: storedCapture?.value,
@@ -81,13 +81,13 @@ extension StructuredCapture {
 extension Sequence where Element == StructuredCapture {
   // FIXME: This is a stop gap where we still slice the input
   // and traffic through existentials
-  func existentialMatch(
+  func existentialOutput(
     from input: Substring
   ) -> Any {
     var caps = Array<Any>()
     caps.append(input)
     caps.append(contentsOf: self.map {
-      $0.existentialMatchComponent(from: input)
+      $0.existentialOutputComponent(from: input)
     })
     return TypeConstruction.tuple(of: caps)
   }

Sources/_StringProcessing/Executor.swift

@@ -44,7 +44,7 @@ struct Executor {
     // specially compiling) whole-match values.
     let value: Any?
     if Output.self != Substring.self,
-       Output.self != (Substring, DynamicCaptures).self,
+       Output.self != AnyRegexOutput.self,
        caps.isEmpty
     {
       value = cpu.registers.values.first
@@ -65,7 +65,7 @@ struct Executor {
     _ input: String,
     in inputRange: Range<String.Index>,
     _ mode: MatchMode
-  ) throws -> Regex<(Substring, DynamicCaptures)>.Match? {
+  ) throws -> Regex<AnyRegexOutput>.Match? {
     try match(input, in: inputRange, mode)
   }
 }

Sources/_StringProcessing/RegexDSL/AnyRegexOutput.swift

@@ -0,0 +1,128 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+import _MatchingEngine
+
+extension Regex where Output == AnyRegexOutput {
+  public init(_ pattern: String) throws {
+    self.init(ast: try parse(pattern, .traditional))
+  }
+}
+
+extension Regex.Match where Output == AnyRegexOutput {
+  // Ensures `.0` always refers to the whole match.
+  public subscript(
+    dynamicMember keyPath: KeyPath<(Substring, _doNotUse: ()), Substring>
+  ) -> Substring {
+    input[range]
+  }
+}
+
+public struct AnyRegexOutput {
+  let input: String
+  fileprivate let _elements: [ElementRepresentation]
+
+  /// The underlying representation of the element of a type-erased regex
+  /// output.
+  fileprivate struct ElementRepresentation {
+    /// The depth of `Optioals`s wrapping the underlying value. For example,
+    /// `Substring` has optional depth `0`, and `Int??` has optional depth `2`.
+    let optionalDepth: Int
+    /// The bounds of the output element.
+    let bounds: Range<String.Index>?
+  }
+}
+
+extension AnyRegexOutput {
+  /// Creates a type-erased regex output from an existing output.
+  ///
+  /// Use this initializer to fit a regex with strongly typed captures into the
+  /// use site of a dynamic regex, i.e. one that was created from a string.
+  public init<Output>(_ match: Regex<Output>.Match) {
+    // Note: We use type equality instead of `match.output as? ...` to prevent
+    // unexpected optional flattening.
+    if Output.self == AnyRegexOutput.self {
+      self = match.output as! AnyRegexOutput
+      return
+    }
+    fatalError("FIXME: Not implemented")
+    // self.init(input: match.input, _elements: <elements of output tuple>)
+  }
+}
+
+extension AnyRegexOutput {
+  internal init<C: Collection>(
+    input: String, elements: C
+  ) where C.Element == StructuredCapture {
+    self.init(input: input, _elements: elements.map(ElementRepresentation.init))
+  }
+}
+
+extension AnyRegexOutput.ElementRepresentation {
+  init(_ element: StructuredCapture) {
+    self.init(
+      optionalDepth: element.optionalCount,
+      bounds: element.storedCapture.flatMap(\.range))
+  }
+
+  func value(forInput input: String) -> Any {
+    // Ok for now because `existentialMatchComponent`
+    // wont slice the input if there's no range to slice with
+    //
+    // FIXME: This is ugly :-/
+    let input = bounds.map { input[$0] } ?? ""
+
+    return constructExistentialOutputComponent(
+      from: input,
+      in: bounds,
+      value: nil,
+      optionalCount: optionalDepth)
+  }
+}
+
+extension AnyRegexOutput: RandomAccessCollection {
+  public struct Element {
+    fileprivate let representation: ElementRepresentation
+    let input: String
+
+    public var range: Range<String.Index>? {
+      representation.bounds
+    }
+
+    public var substring: Substring? {
+      range.map { input[$0] }
+    }
+  }
+
+  public var startIndex: Int {
+    _elements.startIndex
+  }
+
+  public var endIndex: Int {
+    _elements.endIndex
+  }
+
+  public var count: Int {
+    _elements.count
+  }
+
+  public func index(after i: Int) -> Int {
+    _elements.index(after: i)
+  }
+
+  public func index(before i: Int) -> Int {
+    _elements.index(before: i)
+  }
+
+  public subscript(position: Int) -> Element {
+    .init(representation: _elements[position], input: input)
+  }
+}

Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift

@@ -23,11 +23,14 @@ extension Regex {
 
 extension Regex.Match {
   public var output: Output {
-    if Output.self == (Substring, DynamicCaptures).self {
-      // FIXME(rdar://89449323): Compiler assertion
-      let input = input
-      let dynCaps = rawCaptures.map { StoredDynamicCapture($0, in: input) }
-      return (input[range], dynCaps) as! Output
+    if Output.self == AnyRegexOutput.self {
+      let wholeMatchAsCapture = StructuredCapture(
+        optionalCount: 0,
+        storedCapture: StoredCapture(range: range, value: nil))
+      let output = AnyRegexOutput(
+        input: input,
+        elements: [wholeMatchAsCapture] + rawCaptures)
+      return output as! Output
     } else if Output.self == Substring.self {
       // FIXME: Plumb whole match (`.0`) through the matching engine.
       return input[range] as! Output
@@ -40,7 +43,7 @@ extension Regex.Match {
       guard value == nil else {
         fatalError("FIXME: what would this mean?")
       }
-      let typeErasedMatch = rawCaptures.existentialMatch(from: input[range])
+      let typeErasedMatch = rawCaptures.existentialOutput(from: input[range])
       return typeErasedMatch as! Output
     }
   }
@@ -62,7 +65,7 @@ extension Regex.Match {
       preconditionFailure(
         "Reference did not capture any match in the regex")
     }
-    return rawCaptures[offset].existentialMatchComponent(from: input[...])
+    return rawCaptures[offset].existentialOutputComponent(from: input[...])
       as! Capture
   }
 }

Sources/_StringProcessing/RegexDSL/Match.swift

@@ -12,12 +12,6 @@
 import XCTest
 @testable import _StringProcessing
 
-func dynCap(
-  _ s: String, optional: Bool = false
-) -> StoredDynamicCapture {
-  StoredDynamicCapture(s[...], optionalCount: optional ? 1 : 0)
-}
-
 class RegexDSLTests: XCTestCase {
   func _testDSLCaptures<Content: RegexComponent, MatchType>(
     _ tests: (input: String, expectedCaptures: MatchType?)...,
@@ -559,25 +553,25 @@ class RegexDSLTests: XCTestCase {
     do {
       let regex = try Regex("aabcc.")
       let line = "aabccd"
-      let captures = try XCTUnwrap(line.match(regex)?.1)
-      XCTAssertEqual(captures, [])
+      let match = try XCTUnwrap(line.match(regex))
+      XCTAssertEqual(match.0, line[...])
+      let output = match.output
+      XCTAssertEqual(output[0].substring, line[...])
     }
     do {
-
       let regex = try Regex(
         #"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#)
       let line = """
         A6F0..A6F1    ; Extend # Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMUM \
         COMBINING MARK TUKWENTIS
         """
-      let captures = try XCTUnwrap(line.match(regex)?.1)
-      XCTAssertEqual(
-        captures,
-        [
-          dynCap("A6F0"),
-          dynCap("A6F1", optional: true),
-          dynCap("Extend"),
-        ])
+      let match = try XCTUnwrap(line.match(regex))
+      XCTAssertEqual(match.0, line[...])
+      let output = match.output
+      XCTAssertEqual(output[0].substring, line[...])
+      XCTAssertTrue(output[1].substring == "A6F0")
+      XCTAssertTrue(output[2].substring == "A6F1")
+      XCTAssertTrue(output[3].substring == "Extend")
     }
   }