internalize capture structure

Author: milseman

Sources/PatternConverter/PatternConverter.swift

@@ -30,9 +30,6 @@ struct PatternConverter: ParsableCommand {
   @Flag(help: "Whether to show canonical regex literal")
   var showCanonical: Bool = false
 
-  @Flag(help: "Whether to show capture structure")
-  var showCaptureStructure: Bool = false
-
   @Flag(help: "Whether to skip result builder DSL")
   var skipDSL: Bool = false
 
@@ -71,13 +68,6 @@ struct PatternConverter: ParsableCommand {
       print()
     }
 
-    if showCaptureStructure {
-      print("Capture structure:")
-      print()
-      print(ast.captureStructure)
-      print()
-    }
-
     print()
     if !skipDSL {
       let render = ast.renderAsBuilderDSL(

Sources/_RegexParser/Regex/AST/AST.swift

@@ -26,7 +26,7 @@ extension AST {
   public var hasCapture: Bool { root.hasCapture }
 
   /// The capture structure of this AST tree.
-  public var captureStructure: CaptureStructure {
+  var captureStructure: CaptureStructure {
     root._captureList._captureStructure(nestOptionals: true)
   }
 }

Sources/_RegexParser/Regex/Parse/CaptureList.swift

@@ -111,7 +111,7 @@ extension AST.Node {
 }
 
 extension CaptureList {
-  public func _captureStructure(nestOptionals: Bool) -> CaptureStructure {
+  func _captureStructure(nestOptionals: Bool) -> CaptureStructure {
     if captures.isEmpty { return .empty }
     if captures.count == 1 {
       return captures.first!._captureStructure(nestOptionals: nestOptionals)
@@ -123,7 +123,7 @@ extension CaptureList {
 }
 
 extension CaptureList.Capture {
-  public func _captureStructure(nestOptionals: Bool) -> CaptureStructure {
+  func _captureStructure(nestOptionals: Bool) -> CaptureStructure {
     if optionalDepth == 0 {
       if let ty = type {
         return .atom(name: name, type: .init(ty))

Sources/_RegexParser/Regex/Parse/CaptureStructure.swift

@@ -10,16 +10,16 @@
 //===----------------------------------------------------------------------===//
 
 // A tree representing the type of some captures.
-public enum CaptureStructure: Equatable {
+enum CaptureStructure: Equatable {
   case atom(name: String? = nil, type: AnyType? = nil)
   indirect case optional(CaptureStructure)
   indirect case tuple([CaptureStructure])
 
-  public static func tuple(_ children: CaptureStructure...) -> Self {
+  static func tuple(_ children: CaptureStructure...) -> Self {
     tuple(children)
   }
 
-  public static var empty: Self {
+  static var empty: Self {
     .tuple([])
   }
 }
@@ -29,14 +29,14 @@ public enum CaptureStructure: Equatable {
 extension CaptureStructure {
   /// Returns a Boolean indicating whether the structure does not contain any
   /// captures.
-  public var isEmpty: Bool {
+  var isEmpty: Bool {
     if case .tuple(let elements) = self, elements.isEmpty {
       return true
     }
     return false
   }
 
-  public func type(withAtomType atomType: Any.Type) -> Any.Type {
+  func type(withAtomType atomType: Any.Type) -> Any.Type {
     switch self {
     case .atom(_, type: nil):
       return atomType
@@ -51,13 +51,13 @@ extension CaptureStructure {
     }
   }
 
-  public typealias DefaultAtomType = Substring
+  typealias DefaultAtomType = Substring
 
-  public var type: Any.Type {
+  var type: Any.Type {
     type(withAtomType: DefaultAtomType.self)
   }
 
-  public var atomType: AnyType {
+  var atomType: AnyType {
     switch self {
     case .atom(_, type: nil):
       return .init(Substring.self)
@@ -89,7 +89,7 @@ extension CaptureStructure {
   private typealias SerializationVersion = UInt16
   private static let currentSerializationVersion: SerializationVersion = 1
 
-  public static func serializationBufferSize(
+  static func serializationBufferSize(
     forInputUTF8CodeUnitCount inputUTF8CodeUnitCount: Int
   ) -> Int {
     MemoryLayout<SerializationVersion>.stride + inputUTF8CodeUnitCount + 1
@@ -110,7 +110,7 @@ extension CaptureStructure {
   ///
   /// - Parameter buffer: A buffer whose byte count is at least the byte count
   ///   of the regular expression string that produced this capture structure.
-  public func encode(to buffer: UnsafeMutableRawBufferPointer) {
+  func encode(to buffer: UnsafeMutableRawBufferPointer) {
     assert(!buffer.isEmpty, "Buffer must not be empty")
     assert(
       buffer.count >=
@@ -169,7 +169,7 @@ extension CaptureStructure {
 
   /// Creates a capture structure by decoding a serialized representation from
   /// the given buffer.
-  public init?(decoding buffer: UnsafeRawBufferPointer) {
+  init?(decoding buffer: UnsafeRawBufferPointer) {
     var scopes: [[CaptureStructure]] = [[]]
     var currentScope: [CaptureStructure] {
       get { scopes[scopes.endIndex - 1] }
@@ -223,13 +223,13 @@ extension CaptureStructure {
 }
 
 extension CaptureStructure: CustomStringConvertible {
-  public var description: String {
+  var description: String {
     var printer = PrettyPrinter()
     _print(&printer)
     return printer.finish()
   }
 
-  private func _print(_ printer: inout PrettyPrinter) {
+  func _print(_ printer: inout PrettyPrinter) {
     switch self {
     case let .atom(name, type):
       let name = name ?? "<unnamed>"

Tests/RegexTests/CaptureTests.swift

@@ -11,7 +11,7 @@
 
 import XCTest
 @testable @_spi(RegexBuilder) import _StringProcessing
-import _RegexParser
+@testable import _RegexParser
 
 extension StructuredCapture {
   func formatStringCapture(input: String) -> String {