Throwing matches and update to CustomMatchingRegexComponent

- Update the name `CustomRegexComponent` to `CustomMatchingRegexComponent` per pitch
- Adopt `throws` for `CustomMatchingRegexComponent` as added in swiftlang#261. Errors thrown by
`CustomMatchingRegexComponent`'s conformers will be bubbled up to the engine and
surfaced at client-side.

Author: itingliu

Documentation/Evolution/StringProcessingAlgorithms.md

@@ -187,7 +187,7 @@ public protocol CustomMatchingRegexComponent : RegexComponent {
         _ input: String,
         startingAt index: String.Index,
         in bounds: Range<String.Index>
-    ) -> (upperBound: String.Index, match: Match)?
+    ) throws -> (upperBound: String.Index, match: Match)?
 }
 ```
 

Sources/_StringProcessing/ByteCodeGen.swift

@@ -293,13 +293,15 @@ extension Compiler.ByteCodeGen {
   mutating func emitMatcher(
     _ matcher: @escaping _MatcherInterface,
     into capture: CaptureRegister? = nil
-  ) {
+  ) throws {
 
     // TODO: Consider emitting consumer interface if
     // not captured. This may mean we should store
     // an existential instead of a closure...
 
-    let matcher = builder.makeMatcherFunction(matcher)
+    let matcher = builder.makeMatcherFunction { input, start, range in
+      try matcher(input, start, range)
+    }
 
     let valReg = builder.makeValueRegister()
     builder.buildMatcher(matcher, into: valReg)
@@ -576,7 +578,7 @@ extension Compiler.ByteCodeGen {
       let cap = builder.makeCapture(id: refId)
       switch child {
       case let .matcher(_, m):
-        emitMatcher(m, into: cap)
+        try emitMatcher(m, into: cap)
       case let .transform(t, child):
         try emitTransform(t, child, into: cap)
       default:
@@ -639,7 +641,7 @@ extension Compiler.ByteCodeGen {
       throw Unsupported("consumer")
 
     case let .matcher(_, f):
-      emitMatcher(f)
+      try emitMatcher(f)
 
     case .transform:
       throw Unreachable(

Sources/_StringProcessing/Regex/DSLConsumers.swift

@@ -9,18 +9,20 @@
 //
 //===----------------------------------------------------------------------===//
 
-public protocol CustomRegexComponent: RegexComponent {
+public protocol CustomMatchingRegexComponent: RegexComponent {
   func match(
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, output: Output)?
+  ) throws -> (upperBound: String.Index, output: Output)?
 }
 
-extension CustomRegexComponent {
+extension CustomMatchingRegexComponent {
   public var regex: Regex<Output> {
-    Regex(node: .matcher(.init(Output.self), { input, index, bounds in
-      match(input, startingAt: index, in: bounds)
-    }))
+
+    let node: DSLTree.Node = .matcher(.init(Output.self), { input, index, bounds in
+      try match(input, startingAt: index, in: bounds)
+    })
+    return Regex(node: node)
   }
 }

Tests/RegexBuilderTests/CustomTests.swift

@@ -14,7 +14,7 @@ import _StringProcessing
 @testable import RegexBuilder
 
 // A nibbler processes a single character from a string
-private protocol Nibbler: CustomRegexComponent {
+private protocol Nibbler: CustomMatchingRegexComponent {
   func nibble(_: Character) -> Output?
 }
 
@@ -24,7 +24,7 @@ extension Nibbler {
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, output: Output)? {
+  ) throws -> (upperBound: String.Index, output: Output)? {
     guard index != bounds.upperBound, let res = nibble(input[index]) else {
       return nil
     }
@@ -49,6 +49,68 @@ private struct Asciibbler: Nibbler {
   }
 }
 
+private struct IntParser: CustomMatchingRegexComponent {
+  struct ParseError: Error, Hashable {}
+  typealias Output = Int
+  func match(_ input: String,
+    startingAt index: String.Index,
+    in bounds: Range<String.Index>
+  ) throws -> (upperBound: String.Index, output: Int)? {
+    let r = Regex {
+      Capture(OneOrMore(.digit)) { Int($0) }
+    }
+    guard let match = input[index..<bounds.upperBound].wholeMatch(of: r),
+            let output = match.output.1 else {
+      throw ParseError()
+    }
+
+    return (match.range.upperBound, output)
+  }
+}
+
+private struct CurrencyParser: CustomMatchingRegexComponent {
+  enum Currency: String {
+    case usd = "USD"
+    case ntd = "NTD"
+    case dem = "DEM"
+  }
+
+  enum ParseError: Error, Hashable {
+    case unrecognized
+    case deprecated
+  }
+
+  typealias Output = Currency
+  func match(_ input: String,
+             startingAt index: String.Index,
+             in bounds: Range<String.Index>
+  ) throws -> (upperBound: String.Index, output: Currency)? {
+
+    guard index != bounds.upperBound else {
+      return nil
+    }
+
+    let substr = input[index..<bounds.upperBound]
+
+    let currencies: [Currency] = [ .usd, .ntd ]
+    let deprecated: [Currency] = [ .dem ]
+
+    for currency in currencies {
+      if let range = substr.range(of: currency.rawValue) {
+        return (range.upperBound, currency)
+      }
+    }
+
+    for dep in deprecated {
+      if let _ = substr.range(of: dep.rawValue) {
+        throw ParseError.deprecated
+      }
+    }
+
+    throw ParseError.unrecognized
+  }
+}
+
 enum MatchCall {
   case match
   case firstMatch
@@ -223,4 +285,99 @@ class CustomRegexComponentTests: XCTestCase {
 
 
   }
+
+  func testCustomRegexThrows() {
+
+    func customTest<Match: Equatable, E: Error & Equatable>(
+      _ regex: Regex<Match>,
+      _ tests: (input: String, match: Match?, expectError: E?)...,
+      file: StaticString = #file,
+      line: UInt = #line
+    ) {
+      for (input, match, expectError) in tests {
+        do {
+          let result = try regex.wholeMatch(in: input)?.output
+          XCTAssertEqual(result, match)
+        } catch let e as E {
+          XCTAssertEqual(e, expectError)
+        } catch {
+          XCTFail()
+        }
+      }
+    }
+
+    customTest(
+      Regex {
+        IntParser()
+      },
+      ("zzz", nil, IntParser.ParseError()),
+      ("x10x", nil, IntParser.ParseError()),
+      ("30", 30, nil)
+    )
+
+    customTest(
+      Regex {
+        CurrencyParser()
+      },
+      ("USD", .usd, nil),
+      ("NTD", .ntd, nil),
+      ("NTD USD", .usd, nil),
+      ("DEM", nil, CurrencyParser.ParseError.deprecated),
+      ("XXX", nil, CurrencyParser.ParseError.unrecognized)
+    )
+
+    customTest(
+      Regex {
+        CurrencyParser()
+        IntParser()
+      },
+      ("USD100", "USD100", nil),
+      ("USD100.000", "USD100", IntParser.ParseError())
+    )
+
+    customTest(
+      Regex {
+        CurrencyParser()
+        IntParser()
+      },
+      ("XXX100", nil, CurrencyParser.ParseError.unrecognized),
+      ("XXX100.00", nil, CurrencyParser.ParseError.unrecognized),
+      ("DEM100", nil, CurrencyParser.ParseError.deprecated)
+    )
+
+    func currencyTest(
+      _ regex: Regex<(Substring, CurrencyParser.Currency, Int)>,
+      _ tests: (input: String, match: (Substring, CurrencyParser.Currency, Int)?, expectError1: CurrencyParser.ParseError?, expectError2: IntParser.ParseError?)...,
+      file: StaticString = #file,
+      line: UInt = #line
+    ) {
+      for (input, match, expectError1, expectError2) in tests {
+        do {
+          let result = try regex.wholeMatch(in: input)?.output
+          XCTAssertEqual(result?.0, match?.0)
+          XCTAssertEqual(result?.1, match?.1)
+          XCTAssertEqual(result?.2, match?.2)
+        } catch let e as CurrencyParser.ParseError {
+          XCTAssertEqual(e, expectError1)
+        } catch let e as IntParser.ParseError {
+          XCTAssertEqual(e, expectError2)
+        } catch {
+          XCTFail("caught error: \(error.localizedDescription)")
+        }
+      }
+    }
+
+    currencyTest(
+      Regex {
+        Capture(CurrencyParser())
+        Capture(IntParser())
+      },
+      ("USD100", ("USD100", .usd, 100), nil, nil),
+      ("NTD500", ("NTD500", .ntd, 500), nil, nil),
+      ("XXX20", nil, .unrecognized, IntParser.ParseError()),
+      ("DEM500", nil, .deprecated, nil),
+      ("DEM500.345", nil, .deprecated, IntParser.ParseError()),
+      ("NTD100.345", nil, nil, IntParser.ParseError())
+    )
+  }
 }

Tests/RegexBuilderTests/RegexDSLTests.swift

@@ -743,13 +743,13 @@ class RegexDSLTests: XCTestCase {
       var patch: Int
       var dev: String?
     }
-    struct SemanticVersionParser: CustomRegexComponent {
+    struct SemanticVersionParser: CustomMatchingRegexComponent {
       typealias Output = SemanticVersion
       func match(
         _ input: String,
         startingAt index: String.Index,
         in bounds: Range<String.Index>
-      ) -> (upperBound: String.Index, output: SemanticVersion)? {
+      ) throws -> (upperBound: String.Index, output: SemanticVersion)? {
         let regex = Regex {
           TryCapture(OneOrMore(.digit)) { Int($0) }
           "."
@@ -776,13 +776,13 @@ class RegexDSLTests: XCTestCase {
         return (match.range.upperBound, result)
       }
     }
-    
+
     let versions = [
       ("1.0", SemanticVersion(major: 1, minor: 0, patch: 0)),
       ("1.0.1", SemanticVersion(major: 1, minor: 0, patch: 1)),
       ("12.100.5-dev", SemanticVersion(major: 12, minor: 100, patch: 5, dev: "dev")),
     ]
-    
+
     let parser = SemanticVersionParser()
     for (str, version) in versions {
       XCTAssertEqual(str.wholeMatch(of: parser)?.output, version)