Implement .as for Regex

Author: Azoy

Sources/_RegexParser/Utility/TypeConstruction.swift

@@ -17,19 +17,7 @@
 //                              const Metadata * const *elements,
 //                              const char *labels,
 //                              const ValueWitnessTable *proposedWitnesses);
-//
-//   SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-//   MetadataResponse
-//   swift_getTupleTypeMetadata2(MetadataRequest request,
-//                               const Metadata *elt0, const Metadata *elt1,
-//                               const char *labels,
-//                               const ValueWitnessTable *proposedWitnesses);
-//   SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-//   MetadataResponse
-//   swift_getTupleTypeMetadata3(MetadataRequest request,
-//                               const Metadata *elt0, const Metadata *elt1,
-//                               const Metadata *elt2, const char *labels,
-//                               const ValueWitnessTable *proposedWitnesses);
+
 
 @_silgen_name("swift_getTupleTypeMetadata")
 private func swift_getTupleTypeMetadata(
@@ -40,31 +28,13 @@ private func swift_getTupleTypeMetadata(
   proposedWitnesses: UnsafeRawPointer?
 ) -> (value: Any.Type, state: Int)
 
-@_silgen_name("swift_getTupleTypeMetadata2")
-private func swift_getTupleTypeMetadata2(
-  request: Int,
-  element1: Any.Type,
-  element2: Any.Type,
-  labels: UnsafePointer<Int8>?,
-  proposedWitnesses: UnsafeRawPointer?
-) -> (value: Any.Type, state: Int)
-
-@_silgen_name("swift_getTupleTypeMetadata3")
-private func swift_getTupleTypeMetadata3(
-  request: Int,
-  element1: Any.Type,
-  element2: Any.Type,
-  element3: Any.Type,
-  labels: UnsafePointer<Int8>?,
-  proposedWitnesses: UnsafeRawPointer?
-) -> (value: Any.Type, state: Int)
-
 public enum TypeConstruction {
   /// Returns a tuple metatype of the given element types.
   public static func tupleType<
     ElementTypes: BidirectionalCollection
   >(
-    of elementTypes: __owned ElementTypes
+    of elementTypes: __owned ElementTypes,
+    labels: String? = nil
   ) -> Any.Type where ElementTypes.Element == Any.Type {
     // From swift/ABI/Metadata.h:
     //   template <typename int_type>
@@ -78,39 +48,50 @@ public enum TypeConstruction {
     let elementCountFlag = 0x0000FFFF
     assert(elementTypes.count != 1, "A one-element tuple is not a realistic Swift type")
     assert(elementTypes.count <= elementCountFlag, "Tuple size exceeded \(elementCountFlag)")
-    switch elementTypes.count {
-    case 2:
-      return swift_getTupleTypeMetadata2(
-        request: 0,
-        element1: elementTypes[elementTypes.startIndex],
-        element2: elementTypes[elementTypes.index(elementTypes.startIndex, offsetBy: 1)],
-        labels: nil,
-        proposedWitnesses: nil).value
-    case 3:
-      return swift_getTupleTypeMetadata3(
-        request: 0,
-        element1: elementTypes[elementTypes.startIndex],
-        element2: elementTypes[elementTypes.index(elementTypes.startIndex, offsetBy: 1)],
-        element3: elementTypes[elementTypes.index(elementTypes.startIndex, offsetBy: 2)],
-        labels: nil,
-        proposedWitnesses: nil).value
-    default:
-      let result = elementTypes.withContiguousStorageIfAvailable { elementTypesBuffer in
-        swift_getTupleTypeMetadata(
+    
+    var flags = elementTypes.count
+    
+    // If we have labels to provide, then say the label pointer is not constant
+    // because the lifetime of said pointer will only be vaild for the lifetime
+    // of the 'swift_getTupleTypeMetadata' call. If we don't have labels, then
+    // our label pointer will be empty and constant.
+    if labels != nil {
+      // Has non constant labels
+      flags |= 0x10000
+    }
+    
+    let result = elementTypes.withContiguousStorageIfAvailable { elementTypesBuffer in
+      if let labels = labels {
+        return labels.withCString { labelsPtr in
+          swift_getTupleTypeMetadata(
+            request: 0,
+            flags: flags,
+            elements: elementTypesBuffer.baseAddress,
+            labels: labelsPtr,
+            proposedWitnesses: nil
+          )
+        }
+      } else {
+        return swift_getTupleTypeMetadata(
           request: 0,
-          flags: elementTypesBuffer.count,
+          flags: flags,
           elements: elementTypesBuffer.baseAddress,
           labels: nil,
-          proposedWitnesses: nil).value
+          proposedWitnesses: nil
+        )
       }
-      guard let result = result else {
-        fatalError("""
-          The collection of element types does not support an internal representation of
-          contiguous storage
-          """)
-      }
-      return result
     }
+    
+    guard let result = result else {
+      fatalError(
+        """
+        The collection of element types does not support an internal representation of
+        contiguous storage
+        """
+      )
+    }
+    
+    return result.value
   }
 
   /// Creates a type-erased tuple with the given elements.

Sources/_StringProcessing/Regex/AnyRegexOutput.swift

@@ -222,8 +222,8 @@ extension Regex where Output == AnyRegexOutput {
   ///
   /// 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>) {
-    fatalError("FIXME: Not implemented")
+  public init<Output>(_ regex: Regex<Output>) {
+    self.init(node: regex.root)
   }
 
   /// Returns a typed regex by converting the underlying types.
@@ -232,6 +232,12 @@ extension Regex where Output == AnyRegexOutput {
   /// - Returns: A regex generic over the output type if the underlying types can be converted.
   ///   Returns `nil` otherwise.
   public func `as`<Output>(_ type: Output.Type) -> Regex<Output>? {
-    fatalError("FIXME: Not implemented")
+    let result = Regex<Output>(node: root)
+    
+    guard result._verifyType() else {
+      return nil
+    }
+    
+    return result
   }
 }

Sources/_StringProcessing/Utility/TypeVerification.swift

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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
+//
+//===----------------------------------------------------------------------===//
+
+@_implementationOnly import _RegexParser
+
+@available(SwiftStdlib 5.7, *)
+extension Regex {
+  internal func _verifyType() -> Bool {
+    var tupleElements: [Any.Type] = [Substring.self]
+    var labels = " "
+    
+    for capture in program.tree.root._captureList.captures {
+      var captureType: Any.Type = capture.type ?? Substring.self
+      var i = capture.optionalDepth
+      
+      while i != 0 {
+        captureType = TypeConstruction.optionalType(of: captureType)
+        i -= 1
+      }
+      
+      tupleElements.append(captureType)
+      
+      if let name = capture.name {
+        labels += name
+      }
+      
+      labels.unicodeScalars.append(" ")
+    }
+    
+    // If we have no captures, then our Regex must be Regex<Substring>.
+    if tupleElements.count == 1 {
+      return Output.self == Substring.self
+    }
+    
+    let createdType = TypeConstruction.tupleType(
+      of: tupleElements,
+      labels: labels
+    )
+    
+    return Output.self == createdType
+  }
+}

Tests/RegexTests/CaptureTests.swift

@@ -451,7 +451,23 @@ extension RegexTests {
     //    TODO: "((a|b)|c)*"
 
   }
-
+  
+  func testTypeVerification() throws {
+    let opaque1 = try Regex("abc")
+    let concrete1 = try XCTUnwrap(opaque1.as(Substring.self))
+    XCTAssertNil(opaque1.as((Substring, Substring).self))
+    XCTAssertNil(opaque1.as(Int.self))
+    
+    let opaque2 = try Regex("(abc)")
+    let concrete2 = try XCTUnwrap(opaque2.as((Substring, Substring).self))
+    XCTAssertNil(opaque2.as(Substring.self))
+    XCTAssertNil(opaque2.as((Substring, Int).self))
+    
+    let opaque3 = try Regex("(?<someLabel>abc)")
+    let concrete3 = try XCTUnwrap(opaque3.as((Substring, someLabel: Substring).self))
+    XCTAssertNil(opaque3.as((Substring, Substring).self))
+    XCTAssertNil(opaque3.as(Substring.self))
+  }
 }
 
 

Tests/RegexTests/MatchTests.swift

@@ -35,7 +35,7 @@ extension Executor {
         in: start..<input.endIndex,
         .partialFromFront
       ) {
-        let caps = result.rawCaptures.slices(from: input)
+        let caps = result.anyRegexOutput.slices(from: input)
         return (input[result.range], caps)
       } else if start == input.endIndex {
         throw MatchError("match not found for \(regex) in \(input)")