Throwing customization hooks (#261)

* Throwing customization hooks

* Adds test to try out throwing custom code. 

* Adds processor support.

* Add throws to capture transform API, plumbing

* Remove non-failable try-capture overloads

Author: milseman

Sources/RegexBuilder/Variadics.swift

@@ -615,35 +615,6 @@ struct VariadicsGenerator: ParsableCommand {
           self.init(node: .capture(reference: reference.id, component.regex.root))
         }
 
-        \(disfavored)\
-        public init<\(genericParams), NewCapture>(
-          _ component: R,
-          transform: @escaping (Substring) -> NewCapture
-        ) \(whereClauseTransformed) {
-          self.init(node: .capture(.transform(
-            CaptureTransform(resultType: NewCapture.self) {
-              transform($0) as Any
-            },
-            component.regex.root)))
-        }
-
-        \(disfavored)\
-        public init<\(genericParams), NewCapture>(
-          _ component: R,
-          as reference: Reference<NewCapture>,
-          transform: @escaping (Substring) -> NewCapture
-        ) \(whereClauseTransformed) {
-          self.init(node: .capture(
-            reference: reference.id,
-            .transform(
-              CaptureTransform(resultType: NewCapture.self) {
-                transform($0) as Any
-              },
-              component.regex.root)))
-        }
-      }
-
-      extension TryCapture {
         \(disfavored)\
         public init<\(genericParams), NewCapture>(
           _ component: R,
@@ -670,15 +641,17 @@ struct VariadicsGenerator: ParsableCommand {
               },
               component.regex.root)))
         }
+      }
 
+      extension TryCapture {
         \(disfavored)\
         public init<\(genericParams), NewCapture>(
           _ component: R,
-          transform: @escaping (Substring) -> NewCapture?
+          transform: @escaping (Substring) throws -> NewCapture?
         ) \(whereClauseTransformed) {
           self.init(node: .capture(.transform(
             CaptureTransform(resultType: NewCapture.self) {
-              transform($0) as Any?
+              try transform($0) as Any?
             },
             component.regex.root)))
         }
@@ -687,13 +660,13 @@ struct VariadicsGenerator: ParsableCommand {
         public init<\(genericParams), NewCapture>(
           _ component: R,
           as reference: Reference<NewCapture>,
-          transform: @escaping (Substring) -> NewCapture?
+          transform: @escaping (Substring) throws -> NewCapture?
         ) \(whereClauseTransformed) {
           self.init(node: .capture(
             reference: reference.id,
             .transform(
               CaptureTransform(resultType: NewCapture.self) {
-                transform($0) as Any?
+                try transform($0) as Any?
               },
               component.regex.root)))
         }
@@ -719,35 +692,6 @@ struct VariadicsGenerator: ParsableCommand {
             component().regex.root))
         }
 
-        \(disfavored)\
-        public init<\(genericParams), NewCapture>(
-          @\(concatBuilderName) _ component: () -> R,
-          transform: @escaping (Substring) -> NewCapture
-        ) \(whereClauseTransformed) {
-          self.init(node: .capture(.transform(
-            CaptureTransform(resultType: NewCapture.self) {
-              transform($0) as Any
-            },
-            component().regex.root)))
-        }
-
-        \(disfavored)\
-        public init<\(genericParams), NewCapture>(
-          as reference: Reference<NewCapture>,
-          @\(concatBuilderName) _ component: () -> R,
-          transform: @escaping (Substring) -> NewCapture
-        ) \(whereClauseTransformed) {
-          self.init(node: .capture(
-            reference: reference.id,
-            .transform(
-              CaptureTransform(resultType: NewCapture.self) {
-                transform($0) as Any
-              },
-              component().regex.root)))
-        }
-      }
-
-      extension TryCapture {
         \(disfavored)\
         public init<\(genericParams), NewCapture>(
           @\(concatBuilderName) _ component: () -> R,
@@ -774,15 +718,17 @@ struct VariadicsGenerator: ParsableCommand {
               },
               component().regex.root)))
         }
+      }
 
+      extension TryCapture {
         \(disfavored)\
         public init<\(genericParams), NewCapture>(
           @\(concatBuilderName) _ component: () -> R,
-          transform: @escaping (Substring) -> NewCapture?
+          transform: @escaping (Substring) throws -> NewCapture?
         ) \(whereClauseTransformed) {
           self.init(node: .capture(.transform(
             CaptureTransform(resultType: NewCapture.self) {
-              transform($0) as Any?
+              try transform($0) as Any?
             },
             component().regex.root)))
         }
@@ -791,13 +737,13 @@ struct VariadicsGenerator: ParsableCommand {
         public init<\(genericParams), NewCapture>(
           as reference: Reference<NewCapture>,
           @\(concatBuilderName) _ component: () -> R,
-          transform: @escaping (Substring) -> NewCapture?
+          transform: @escaping (Substring) throws -> NewCapture?
         ) \(whereClauseTransformed) {
           self.init(node: .capture(
             reference: reference.id,
             .transform(
               CaptureTransform(resultType: NewCapture.self) {
-                transform($0) as Any?
+                try transform($0) as Any?
               },
               component().regex.root)))
         }

Sources/VariadicsGenerator/VariadicsGenerator.swift

@@ -304,78 +304,3 @@ extension AST {
     }
   }
 }
-
-// FIXME: Get this out of here
-public struct CaptureTransform: Equatable, Hashable, CustomStringConvertible {
-  public enum Closure {
-    case nonfailable((Substring) -> Any)
-    case failable((Substring) -> Any?)
-    case throwing((Substring) throws -> Any)
-  }
-  public let resultType: Any.Type
-  public let closure: Closure
-
-  public init(resultType: Any.Type, closure: Closure) {
-    self.resultType = resultType
-    self.closure = closure
-  }
-
-  public init(
-    resultType: Any.Type,
-    _ closure: @escaping (Substring) -> Any
-  ) {
-    self.init(resultType: resultType, closure: .nonfailable(closure))
-  }
-
-  public init(
-    resultType: Any.Type,
-    _ closure: @escaping (Substring) -> Any?
-  ) {
-    self.init(resultType: resultType, closure: .failable(closure))
-  }
-
-  public init(
-    resultType: Any.Type,
-    _ closure: @escaping (Substring) throws -> Any
-  ) {
-    self.init(resultType: resultType, closure: .throwing(closure))
-  }
-
-  public func callAsFunction(_ input: Substring) -> Any? {
-    switch closure {
-    case .nonfailable(let closure):
-      let result = closure(input)
-      assert(type(of: result) == resultType)
-      return result
-    case .failable(let closure):
-      guard let result = closure(input) else {
-        return nil
-      }
-      assert(type(of: result) == resultType)
-      return result
-    case .throwing(let closure):
-      do {
-        let result = try closure(input)
-        assert(type(of: result) == resultType)
-        return result
-      } catch {
-        return nil
-      }
-    }
-  }
-
-  public static func == (lhs: CaptureTransform, rhs: CaptureTransform) -> Bool {
-    unsafeBitCast(lhs.closure, to: (Int, Int).self) ==
-      unsafeBitCast(rhs.closure, to: (Int, Int).self)
-  }
-
-  public func hash(into hasher: inout Hasher) {
-    let (fn, ctx) = unsafeBitCast(closure, to: (Int, Int).self)
-    hasher.combine(fn)
-    hasher.combine(ctx)
-  }
-
-  public var description: String {
-    "<transform result_type=\(resultType)>"
-  }
-}

Sources/_RegexParser/Regex/AST/AST.swift

@@ -317,7 +317,7 @@ extension Compiler.ByteCodeGen {
   ) throws {
     let transform = builder.makeTransformFunction {
       input, range in
-      t(input[range])
+      try t(input[range])
     }
     builder.buildBeginCapture(cap)
     try emitNode(child)

Sources/_StringProcessing/ByteCodeGen.swift

@@ -25,6 +25,7 @@ extension Engine {
 }
 
 extension Processor where Input == String {
+  // TODO: Should we throw here?
   mutating func consume() -> Input.Index? {
     while true {
       switch self.state {

Sources/_StringProcessing/Engine/Consume.swift

@@ -14,11 +14,11 @@ import _RegexParser
 struct MEProgram<Input: Collection> where Input.Element: Equatable {
   typealias ConsumeFunction = (Input, Range<Input.Index>) -> Input.Index?
   typealias AssertionFunction =
-    (Input, Input.Index, Range<Input.Index>) -> Bool
+    (Input, Input.Index, Range<Input.Index>) throws -> Bool
   typealias TransformFunction =
-    (Input, Range<Input.Index>) -> Any?
+    (Input, Range<Input.Index>) throws -> Any?
   typealias MatcherFunction =
-    (Input, Input.Index, Range<Input.Index>) -> (Input.Index, Any)?
+    (Input, Input.Index, Range<Input.Index>) throws -> (Input.Index, Any)?
 
   var instructions: InstructionList<Instruction>
 

Sources/_StringProcessing/Engine/MEProgram.swift

@@ -51,6 +51,8 @@ struct Processor<
 
   var state: State = .inProgress
 
+  var failureReason: Error? = nil
+
   var isTracingEnabled: Bool
 
   var storedCaptures: Array<_StoredCapture>
@@ -181,6 +183,13 @@ extension Processor {
     registers.ints = intRegisters
   }
 
+  mutating func abort(_ e: Error? = nil) {
+    if let e = e {
+      self.failureReason = e
+    }
+    self.state = .fail
+  }
+
   mutating func tryAccept() {
     switch (currentPosition, matchMode) {
     // When reaching the end of the match bounds or when we are only doing a
@@ -355,24 +364,34 @@ extension Processor {
     case .assertBy:
       let reg = payload.assertion
       let assertion = registers[reg]
-      guard assertion(input, currentPosition, bounds) else {
-        signalFailure()
+      do {
+        guard try assertion(input, currentPosition, bounds) else {
+          signalFailure()
+          return
+        }
+      } catch {
+        abort(error)
         return
       }
       controller.step()
 
     case .matchBy:
       let (matcherReg, valReg) = payload.pairedMatcherValue
       let matcher = registers[matcherReg]
-      guard let (nextIdx, val) = matcher(
-        input, currentPosition, bounds
-      ) else {
-        signalFailure()
+      do {
+        guard let (nextIdx, val) = try matcher(
+          input, currentPosition, bounds
+        ) else {
+          signalFailure()
+          return
+        }
+        registers[valReg] = val
+        advance(to: nextIdx)
+        controller.step()
+      } catch {
+        abort(error)
         return
       }
-      registers[valReg] = val
-      advance(to: nextIdx)
-      controller.step()
 
     case .print:
       // TODO: Debug stream
@@ -431,14 +450,18 @@ extension Processor {
         fatalError(
           "Unreachable: transforming without a capture")
       }
-      // FIXME: Pass input or the slice?
-      guard let value = transform(input, range) else {
-        signalFailure()
+      do {
+        // FIXME: Pass input or the slice?
+        guard let value = try transform(input, range) else {
+          signalFailure()
+          return
+        }
+        storedCaptures[capNum].registerValue(value)
+        controller.step()
+      } catch {
+        abort(error)
         return
       }
-      storedCaptures[capNum].registerValue(value)
-
-      controller.step()
 
     case .captureValue:
       let (val, cap) = payload.pairedValueCapture

Sources/_StringProcessing/Engine/Processor.swift

@@ -28,6 +28,9 @@ struct Executor {
       input: input, bounds: inputRange, matchMode: mode)
 
     guard let endIdx = cpu.consume() else {
+      if let e = cpu.failureReason {
+        throw e
+      }
       return nil
     }