Eliminate extra public API

Sources/Exercises/Participants/RegexParticipant.swift

@@ -69,10 +69,10 @@ private func graphemeBreakPropertyData<RP: RegexComponent>(
 private func graphemeBreakPropertyDataLiteral(
   forLine line: String
 ) -> GraphemeBreakEntry? {
-  return graphemeBreakPropertyData(
-    forLine: line,
-    using: r(#"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
-             matching: (Substring, Substring, Substring?, Substring).self))
+  let regex = try! Regex(
+    compiling: #"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
+    as: (Substring, Substring, Substring?, Substring).self)
+  return graphemeBreakPropertyData(forLine: line, using: regex)
 }
 
 // MARK: - Builder DSL

Sources/PatternConverter/PatternConverter.swift

@@ -13,7 +13,7 @@
 
 import ArgumentParser
 import _RegexParser
-import _StringProcessing
+@_spi(PatternConverter) import _StringProcessing
 
 @main
 struct PatternConverter: ParsableCommand {

Sources/_StringProcessing/Algorithms/Consumers/PredicateConsumer.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct PredicateConsumer<Consumed: Collection> {
+struct PredicateConsumer<Consumed: Collection> {
   let predicate: (Consumed.Element) -> Bool
 }
 
@@ -29,7 +29,7 @@ extension PredicateConsumer: CollectionConsumer {
 extension PredicateConsumer: BidirectionalCollectionConsumer
   where Consumed: BidirectionalCollection
 {
-  public func consumingBack(
+  func consumingBack(
     _ consumed: Consumed,
     in range: Range<Consumed.Index>
   ) -> Consumed.Index? {
@@ -59,9 +59,9 @@ extension PredicateConsumer: BackwardCollectionSearcher,
                              BackwardStatelessCollectionSearcher
   where Searched: BidirectionalCollection
 {
-  public typealias BackwardSearched = Consumed
+  typealias BackwardSearched = Consumed
 
-  public func searchBack(
+  func searchBack(
     _ searched: BackwardSearched,
     in range: Range<BackwardSearched.Index>
   ) -> Range<BackwardSearched.Index>? {

Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift

@@ -9,13 +9,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct RegexConsumer<
+struct RegexConsumer<
   R: RegexComponent, Consumed: BidirectionalCollection
 > where Consumed.SubSequence == Substring {
   // TODO: Should `Regex` itself implement these protocols?
   let regex: R
 
-  public init(_ regex: R) {
+  init(_ regex: R) {
     self.regex = regex
   }
 }
@@ -36,9 +36,9 @@ extension RegexConsumer {
 // well, taking advantage of the fact that the captures can be ignored
 
 extension RegexConsumer: MatchingCollectionConsumer {
-  public typealias Match = R.Output
+  typealias Match = R.Output
 
-  public func matchingConsuming(
+  func matchingConsuming(
     _ consumed: Consumed, in range: Range<Consumed.Index>
   ) -> (upperBound: String.Index, match: Match)? {
     _matchingConsuming(consumed[...], in: range)
@@ -47,7 +47,7 @@ extension RegexConsumer: MatchingCollectionConsumer {
 
 // TODO: We'll want to bake backwards into the engine
 extension RegexConsumer: BidirectionalMatchingCollectionConsumer {
-  public func matchingConsumingBack(
+  func matchingConsumingBack(
     _ consumed: Consumed, in range: Range<Consumed.Index>
   ) -> (lowerBound: String.Index, match: Match)? {
     var i = range.lowerBound
@@ -67,12 +67,12 @@ extension RegexConsumer: BidirectionalMatchingCollectionConsumer {
 }
 
 extension RegexConsumer: MatchingStatelessCollectionSearcher {
-  public typealias Searched = Consumed
+  typealias Searched = Consumed
 
   // TODO: We'll want to bake search into the engine so it can
   // take advantage of the structure of the regex itself and
   // its own internal state
-  public func matchingSearch(
+  func matchingSearch(
     _ searched: Searched, in range: Range<Searched.Index>
   ) -> (range: Range<String.Index>, match: Match)? {
     ConsumerSearcher(consumer: self).matchingSearch(searched, in: range)
@@ -81,9 +81,9 @@ extension RegexConsumer: MatchingStatelessCollectionSearcher {
 
 // TODO: Bake in search-back to engine too
 extension RegexConsumer: BackwardMatchingStatelessCollectionSearcher {
-  public typealias BackwardSearched = Consumed
+  typealias BackwardSearched = Consumed
 
-  public func matchingSearchBack(
+  func matchingSearchBack(
     _ searched: BackwardSearched, in range: Range<Searched.Index>
   ) -> (range: Range<String.Index>, match: Match)? {
     ConsumerSearcher(consumer: self).matchingSearchBack(searched, in: range)

Sources/_StringProcessing/Algorithms/Searchers/TwoWaySearcher.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct TwoWaySearcher<Searched: BidirectionalCollection>
+struct TwoWaySearcher<Searched: BidirectionalCollection>
   where Searched.Element: Comparable
 {
   // TODO: Be generic over the pattern?
@@ -36,14 +36,14 @@ public struct TwoWaySearcher<Searched: BidirectionalCollection>
 }
 
 extension TwoWaySearcher: CollectionSearcher {
-  public struct State {
+  struct State {
     let end: Searched.Index
     var index: Searched.Index
     var criticalIndex: Searched.Index
     var memory: (offset: Int, index: Searched.Index)?
   }
 
-  public func state(
+  func state(
     for searched: Searched,
     in range: Range<Searched.Index>
   ) -> State {
@@ -57,7 +57,7 @@ extension TwoWaySearcher: CollectionSearcher {
       memory: nil)
   }
 
-  public func search(
+  func search(
     _ searched: Searched,
     _ state: inout State
   ) -> Range<Searched.Index>? {

Sources/_StringProcessing/Algorithms/Searchers/ZSearcher.swift

@@ -9,12 +9,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct ZSearcher<Searched: Collection> {
+struct ZSearcher<Searched: Collection> {
   let pattern: [Searched.Element]
   let z: [Int]
   let areEquivalent: (Searched.Element, Searched.Element) -> Bool
 
-  public init(
+  init(
     pattern: [Searched.Element],
     by areEquivalent: @escaping (Searched.Element, Searched.Element
     ) -> Bool) {
@@ -25,7 +25,7 @@ public struct ZSearcher<Searched: Collection> {
 }
 
 extension ZSearcher: StatelessCollectionSearcher {
-  public func search(
+  func search(
     _ searched: Searched,
     in range: Range<Searched.Index>
   ) -> Range<Searched.Index>? {

Sources/_StringProcessing/PrintAsPattern.swift

@@ -19,6 +19,7 @@ import _RegexParser
 
 extension AST {
   /// Render as a Pattern DSL
+  @_spi(PatternConverter)
   public func renderAsBuilderDSL(
     maxTopDownLevels: Int? = nil,
     minBottomUpLevels: Int? = nil

Sources/_StringProcessing/Regex/Core.swift

@@ -129,24 +129,3 @@ extension UnicodeScalar: RegexComponent {
     .init(node: .atom(.scalar(self)))
   }
 }
-
-// MARK: - Testing
-
-public struct MockRegexLiteral<Output>: RegexComponent {
-  public typealias MatchValue = Substring
-  public let regex: Regex<Output>
-
-  public init(
-    _ string: String,
-    _ syntax: SyntaxOptions = .traditional,
-    matching: Output.Type = Output.self
-  ) throws {
-    regex = Regex(ast: try parse(string, syntax))
-  }
-}
-
-public func r<Output>(
-  _ s: String, matching matchType: Output.Type = Output.self
-) -> MockRegexLiteral<Output> {
-  try! MockRegexLiteral(s, matching: matchType)
-}

Sources/_StringProcessing/Utility/ASTBuilder.swift

@@ -106,16 +106,16 @@ func negativeLookahead(_ child: AST.Node) -> AST.Node {
 func negativeLookbehind(_ child: AST.Node) -> AST.Node {
   group(.negativeLookbehind, child)
 }
-public func nonAtomicLookahead(_ child: AST.Node) -> AST.Node {
+func nonAtomicLookahead(_ child: AST.Node) -> AST.Node {
   group(.nonAtomicLookahead, child)
 }
-public func nonAtomicLookbehind(_ child: AST.Node) -> AST.Node {
+func nonAtomicLookbehind(_ child: AST.Node) -> AST.Node {
   group(.nonAtomicLookbehind, child)
 }
-public func scriptRun(_ child: AST.Node) -> AST.Node {
+func scriptRun(_ child: AST.Node) -> AST.Node {
   group(.scriptRun, child)
 }
-public func atomicScriptRun(_ child: AST.Node) -> AST.Node {
+func atomicScriptRun(_ child: AST.Node) -> AST.Node {
   group(.atomicScriptRun, child)
 }
 func changeMatchingOptions(

Tests/RegexBuilderTests/RegexDSLTests.swift

@@ -611,9 +611,9 @@ class RegexDSLTests: XCTestCase {
     }
 
     do {
-      let regexLiteral = try MockRegexLiteral(
-        #"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
-        matching: (Substring, Substring, Substring?, Substring).self)
+      let regexLiteral = try Regex(
+        compiling: #"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
+        as: (Substring, Substring, Substring?, Substring).self)
       let maybeMatchResult = line.matchWhole(regexLiteral)
       let matchResult = try XCTUnwrap(maybeMatchResult)
       let (wholeMatch, lower, upper, propertyString) = matchResult.output