Reorganize our modules

Sources/Algorithms/Consumers/RegexConsumer.swift

@@ -15,14 +15,9 @@ public struct Regex {
 public struct RegexConsumer: CollectionConsumer {
   // NOTE: existential
   let vm: Executor
-  let referenceVM: TortoiseVM
 
   public init(regex: Regex) {
-    let ast = try! parse(regex.string, .traditional)
-    let program = Compiler(ast: ast).emit()
-    self.vm = Executor(program: program)
-    let legacyProgram = try! compile(ast, options: regex.options)
-    self.referenceVM = TortoiseVM(program: legacyProgram)
+    self.vm = _compileRegex(regex.string)
   }
 
   public func consume(
@@ -32,12 +27,6 @@ public struct RegexConsumer: CollectionConsumer {
       input: consumed.base,
       in: index..<consumed.endIndex,
       mode: .partialFromFront)
-    assert(
-      result?.range == referenceVM.execute(
-        input: consumed.base,
-        in: index..<consumed.endIndex,
-        mode: .partialFromFront
-      )?.range)
     return result?.range.upperBound
   }
 }

Sources/_MatchingEngine/Regex/Parse/Source.swift

@@ -40,9 +40,9 @@ extension Source: _CollectionWrapper {
 }
 
 extension Source: _Peekable {
-  public typealias Output = Char
+  typealias Output = Char
 
-  public mutating func advance() {
+  mutating func advance() {
     assert(!isEmpty)
     _wrapped = _wrapped.dropFirst()
   }

Sources/_MatchingEngine/Utility/Peek.swift

@@ -1,6 +1,6 @@
 // MARK: - _Peekable
 
-public protocol _Peekable {
+protocol _Peekable {
   associatedtype Output
 
   var isEmpty: Bool { get }
@@ -9,7 +9,7 @@ public protocol _Peekable {
 }
 
 extension _Peekable where Self: Collection, Output == Element {
-  public func peek() -> Output? { self.first }
+  func peek() -> Output? { self.first }
 
   @discardableResult
   mutating func eat(upTo: Index) -> SubSequence {

Sources/_StringProcessing/Capture.swift

@@ -2,7 +2,7 @@ import _MatchingEngine
 
 // TODO: what here should be in the compile-time module?
 
-public enum Capture {
+enum Capture {
   case atom(Any)
   indirect case tuple([Capture])
   indirect case optional(Capture?)
@@ -14,16 +14,17 @@ extension Capture {
     elements.count == 1 ? elements[0] : .tuple(elements)
   }
 
-  public static var void: Capture {
+  static var void: Capture {
     .tuple([])
   }
 
-  public var value: Any {
+  var value: Any {
     switch self {
     case .atom(let atom):
       return atom
     case .tuple(let elements):
-      return _tuple(of: elements.map(\.value))
+      return TypeConstruction.tuple(
+        of: elements.map(\.value))
     case .array(let elements):
       guard let first = elements.first else {
         return [Any]()

Sources/_StringProcessing/Compiler.swift

@@ -1,17 +1,17 @@
 import _MatchingEngine
 
-public struct RegexProgram {
+struct RegexProgram {
   typealias Program = _MatchingEngine.Program<String>
   var program: Program
 }
 
-public class Compiler {
-  public let ast: AST
-  public let matchLevel: CharacterClass.MatchLevel
-  public let options: REOptions
+class Compiler {
+  let ast: AST
+  let matchLevel: CharacterClass.MatchLevel
+  let options: REOptions
   private var builder = RegexProgram.Program.Builder()
 
-  public init(
+  init(
     ast: AST,
     matchLevel: CharacterClass.MatchLevel = .graphemeCluster,
     options: REOptions = []
@@ -21,7 +21,7 @@ public class Compiler {
     self.options = options
   }
 
-  public __consuming func emit() -> RegexProgram {
+  __consuming func emit() -> RegexProgram {
     emit(ast)
     builder.buildAccept()
     return RegexProgram(program: builder.assemble())
@@ -202,3 +202,10 @@ public class Compiler {
   }
 }
 
+public func _compileRegex(
+  _ regex: String, _ syntax: SyntaxOptions = .traditional
+) -> Executor {
+  let ast = try! parse(regex, .traditional)
+  let program = Compiler(ast: ast).emit()
+  return Executor(program: program)
+}

Sources/_StringProcessing/Executor.swift

@@ -3,7 +3,7 @@ import _MatchingEngine
 public struct Executor {
   let engine: Engine<String>
 
-  public init(program: RegexProgram, enablesTracing: Bool = false) {
+  init(program: RegexProgram, enablesTracing: Bool = false) {
     self.engine = Engine(program.program, enableTracing: enablesTracing)
   }
 
@@ -23,9 +23,9 @@ public struct Executor {
 // Backward compatibility layer. To be removed when we deprecate legacy
 // components.
 extension Executor: VirtualMachine {
-  public static let motto = "Executor"
+  static let motto = "Executor"
 
-  public init(program: RegexProgram) {
+  init(program: RegexProgram) {
     self.init(program: program, enablesTracing: false)
   }
 }

Sources/_StringProcessing/Legacy/VirtualMachine.swift

@@ -7,23 +7,23 @@ public enum MatchMode {
 
 public struct MatchResult {
   public var range: Range<String.Index>
-  public var captures: Capture
+  var captures: Capture
 
-  public var destructure: (
+  var destructure: (
     matched: Range<String.Index>, captures: Capture
   ) {
     (range, captures)
   }
 
-  public init(
+  init(
     _ matched: Range<String.Index>, _ captures: Capture
   ) {
     self.range = matched
     self.captures = captures
   }
 }
 
-public protocol VirtualMachine {
+protocol VirtualMachine {
   associatedtype Program
 
   /// The backend's motto and general life philosophy.
@@ -128,7 +128,7 @@ extension RECode {
       topLevelCaptures = [.array(topLevelCaptures)]
     }
 
-    public func singleCapture() -> Capture {
+    func singleCapture() -> Capture {
       .tupleOrAtom(topLevelCaptures)
     }
   }

Sources/_StringProcessing/Utility/TypeConstruction.swift

@@ -48,91 +48,89 @@ private func swift_getTupleTypeMetadata3(
   proposedWitnesses: UnsafeRawPointer?
 ) -> (value: Any.Type, state: Int)
 
-/// Returns a tuple metatype of the given element types.
-public func tupleType<ElementTypes: BidirectionalCollection>(
-  of elementTypes: __owned ElementTypes
-) -> Any.Type where ElementTypes.Element == Any.Type {
-  // From swift/ABI/Metadata.h:
-  //   template <typename int_type>
-  //   class TargetTupleTypeFlags {
-  //     enum : int_type {
-  //       NumElementsMask = 0x0000FFFFU,
-  //       NonConstantLabelsMask = 0x00010000U,
-  //     };
-  //     int_type Data;
-  //     ...
-  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(
+enum TypeConstruction {
+
+  /// Returns a tuple metatype of the given element types.
+  public static func tupleType<
+    ElementTypes: BidirectionalCollection
+  >(
+    of elementTypes: __owned ElementTypes
+  ) -> Any.Type where ElementTypes.Element == Any.Type {
+    // From swift/ABI/Metadata.h:
+    //   template <typename int_type>
+    //   class TargetTupleTypeFlags {
+    //     enum : int_type {
+    //       NumElementsMask = 0x0000FFFFU,
+    //       NonConstantLabelsMask = 0x00010000U,
+    //     };
+    //     int_type Data;
+    //     ...
+    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(
+    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(
+    default:
+      let result = elementTypes.withContiguousStorageIfAvailable { elementTypesBuffer in
+        swift_getTupleTypeMetadata(
           request: 0,
           flags: elementTypesBuffer.count,
           elements: elementTypesBuffer.baseAddress,
           labels: nil,
           proposedWitnesses: nil).value
-    }
-    guard let result = result else {
-      fatalError("""
+      }
+      guard let result = result else {
+        fatalError("""
           The collection of element types does not support an internal representation of
           contiguous storage
           """)
+      }
+      return result
     }
-    return result
   }
-}
-
-// FIXME: namespaces are hard
-internal func _tuple<Elements: BidirectionalCollection>(
-  of elements: __owned Elements
-) -> Any where Elements.Element == Any {
-  tuple(of: elements)
-}
 
-/// Creates a type-erased tuple with the given elements.
-public func tuple<Elements: BidirectionalCollection>(
-  of elements: __owned Elements
-) -> Any where Elements.Element == Any {
-  // Open existential on the overall tuple type.
-  func create<T>(_: T.Type) -> Any {
-    let baseAddress = UnsafeMutablePointer<T>.allocate(
-      capacity: MemoryLayout<T>.size)
-    defer { baseAddress.deallocate() }
-    // Initialize elements based on their concrete type.
-    var currentElementAddressUnaligned = UnsafeMutableRawPointer(baseAddress)
-    for element in elements {
-      // Open existential on each element type.
-      func initializeElement<T>(_ element: T) {
-        currentElementAddressUnaligned =
+  /// Creates a type-erased tuple with the given elements.
+  public static func tuple<Elements: BidirectionalCollection>(
+    of elements: __owned Elements
+  ) -> Any where Elements.Element == Any {
+    // Open existential on the overall tuple type.
+    func create<T>(_: T.Type) -> Any {
+      let baseAddress = UnsafeMutablePointer<T>.allocate(
+        capacity: MemoryLayout<T>.size)
+      defer { baseAddress.deallocate() }
+      // Initialize elements based on their concrete type.
+      var currentElementAddressUnaligned = UnsafeMutableRawPointer(baseAddress)
+      for element in elements {
+        // Open existential on each element type.
+        func initializeElement<T>(_ element: T) {
+          currentElementAddressUnaligned =
           currentElementAddressUnaligned.roundedUp(toAlignmentOf: T.self)
-        currentElementAddressUnaligned.bindMemory(
-          to: T.self, capacity: MemoryLayout<T>.size
-        ).initialize(to: element)
-        // Advance to the next element (unaligned).
-        currentElementAddressUnaligned =
+          currentElementAddressUnaligned.bindMemory(
+            to: T.self, capacity: MemoryLayout<T>.size
+          ).initialize(to: element)
+          // Advance to the next element (unaligned).
+          currentElementAddressUnaligned =
           currentElementAddressUnaligned.advanced(by: MemoryLayout<T>.stride)
+        }
+        _openExistential(element, do: initializeElement)
       }
-      _openExistential(element, do: initializeElement)
+      return baseAddress.move()
     }
-    return baseAddress.move()
+    let elementTypes = elements.map { type(of: $0) }
+    return _openExistential(tupleType(of: elementTypes), do: create)
   }
-  let elementTypes = elements.map { type(of: $0) }
-  return _openExistential(tupleType(of: elementTypes), do: create)
 }

Tests/UtilTests/UtilTests.swift

@@ -1,24 +1,27 @@
 import XCTest
 @testable import _StringProcessing
 
-
 class UtilTests: XCTestCase {
   func testTupleTypeConstruction() {
-    XCTAssertTrue(tupleType(of: []) == Void.self)
-    XCTAssertTrue(tupleType(of: [Int.self, Any.self]) == (Int, Any).self)
+    XCTAssertTrue(TypeConstruction.tupleType(
+      of: []) == Void.self)
+    XCTAssertTrue(TypeConstruction.tupleType(
+      of: [Int.self, Any.self]) == (Int, Any).self)
     XCTAssertTrue(
-      tupleType(of: [[Int].self, [Int: Int].self, Void.self, Any.self])
-        == ([Int], [Int: Int], Void, Any).self)
+      TypeConstruction.tupleType(
+        of: [[Int].self, [Int: Int].self, Void.self, Any.self])
+      == ([Int], [Int: Int], Void, Any).self)
   }
 
   func testTypeErasedTupleConstruction() throws {
-    let tuple0Erased = tuple(of: [1, 2, 3])
+    let tuple0Erased = TypeConstruction.tuple(of: [1, 2, 3])
     let tuple0 = try XCTUnwrap(tuple0Erased as? (Int, Int, Int))
     XCTAssertEqual(tuple0.0, 1)
     XCTAssertEqual(tuple0.1, 2)
     XCTAssertEqual(tuple0.2, 3)
 
-    let tuple1Erased = tuple(of: [[1, 2], [true, false], [3.0, 4.0]])
+    let tuple1Erased = TypeConstruction.tuple(
+      of: [[1, 2], [true, false], [3.0, 4.0]])
     XCTAssertTrue(type(of: tuple1Erased) == ([Int], [Bool], [Double]).self)
     let tuple1 = try XCTUnwrap(tuple1Erased as? ([Int], [Bool], [Double]))
     XCTAssertEqual(tuple1.0, [1, 2])