Drop the ASTStage parameter

We now always run validation, which is fine
because the resulting AST can still be returned.

Author: hamishknight

Sources/PatternConverter/PatternConverter.swift

@@ -50,8 +50,7 @@ struct PatternConverter: ParsableCommand {
     print("Converting '\(delim)\(regex)\(delim)'")
 
     let ast = try _RegexParser.parse(
-      regex, .semantic,
-      experimentalSyntax ? .experimental : .traditional)
+      regex, experimentalSyntax ? .experimental : .traditional)
 
     // Show rendered source ranges
     if renderSourceRanges {

Sources/_RegexParser/Regex/Parse/CompilerInterface.swift

@@ -96,7 +96,7 @@ public func swiftCompilerParseRegexLiteral(
   _ input: String, captureBufferOut: UnsafeMutableRawBufferPointer
 ) throws -> (regexToEmit: String, version: Int) {
   do {
-    let ast = try parseWithDelimiters(input, .semantic)
+    let ast = try parseWithDelimiters(input)
     // Serialize the capture structure for later type inference.
     assert(captureBufferOut.count >= input.utf8.count)
     ast.captureStructure.encode(to: captureBufferOut)

Sources/_RegexParser/Regex/Parse/Parse.swift

@@ -636,37 +636,20 @@ extension Parser {
   }
 }
 
-public enum ASTStage {
-  /// The regex is parsed, and a syntactically valid AST is returned. Otherwise
-  /// an error is thrown. This is useful for e.g syntax coloring.
-  case syntactic
-
-  /// The regex is parsed, and a syntactically and semantically valid AST is
-  /// returned. Otherwise an error is thrown. A semantically valid AST has been
-  /// checked for e.g unsupported constructs and invalid backreferences.
-  case semantic
-}
-
 public func parseWithRecovery<S: StringProtocol>(
-  _ regex: S, _ syntax: SyntaxOptions, stage: ASTStage = .semantic
+  _ regex: S, _ syntax: SyntaxOptions
 ) -> AST where S.SubSequence == Substring
 {
   let source = Source(String(regex))
   var parser = Parser(source, syntax: syntax)
-  let ast = parser.parse()
-  switch stage {
-  case .syntactic:
-    return ast
-  case .semantic:
-    return validate(ast)
-  }
+  return validate(parser.parse())
 }
 
 public func parse<S: StringProtocol>(
-  _ regex: S, _ stage: ASTStage, _ syntax: SyntaxOptions
+  _ regex: S, _ syntax: SyntaxOptions
 ) throws -> AST where S.SubSequence == Substring
 {
-  try parseWithRecovery(regex, syntax, stage: stage).ensureValid()
+  try parseWithRecovery(regex, syntax).ensureValid()
 }
 
 extension StringProtocol {
@@ -709,12 +692,12 @@ public func parseWithDelimitersWithRecovery<S: StringProtocol>(
 /// Parses a given regex string with delimiters, inferring the syntax options
 /// from the delimiters used.
 public func parseWithDelimiters<S: StringProtocol>(
-  _ regex: S, _ stage: ASTStage
+  _ regex: S
 ) throws -> AST where S.SubSequence == Substring {
   let (contents, delim) = droppingRegexDelimiters(String(regex))
   let syntax = defaultSyntaxOptions(delim, contents: contents)
   do {
-    return try parseWithRecovery(contents, syntax, stage: stage).ensureValid()
+    return try parseWithRecovery(contents, syntax).ensureValid()
   } catch let error as LocatedErrorProtocol {
     // Convert the range in 'contents' to the range in 'regex'.
     let delimCount = delim.opening.count

Sources/_StringProcessing/Compiler.swift

@@ -37,7 +37,7 @@ class Compiler {
 func _compileRegex(
   _ regex: String, _ syntax: SyntaxOptions = .traditional
 ) throws -> Executor {
-  let ast = try parse(regex, .semantic, syntax)
+  let ast = try parse(regex, syntax)
   let program = try Compiler(ast: ast).emit()
   return Executor(program: program)
 }

Sources/_StringProcessing/Regex/AnyRegexOutput.swift

@@ -143,11 +143,11 @@ extension Regex where Output == AnyRegexOutput {
   ///
   /// - Parameter pattern: The regular expression.
   public init(_ pattern: String) throws {
-    self.init(ast: try parse(pattern, .semantic, .traditional))
+    self.init(ast: try parse(pattern, .traditional))
   }
 
   internal init(_ pattern: String, syntax: SyntaxOptions) throws {
-    self.init(ast: try parse(pattern, .semantic, syntax))
+    self.init(ast: try parse(pattern, syntax))
   }
 }
 
@@ -161,7 +161,7 @@ extension Regex {
     _ pattern: String,
     as: Output.Type = Output.self
   ) throws {
-    self.init(ast: try parse(pattern, .semantic, .traditional))
+    self.init(ast: try parse(pattern, .traditional))
   }
 
   /// Produces a regex that matches `verbatim` exactly, as though every

Sources/_StringProcessing/Regex/Core.swift

@@ -44,7 +44,7 @@ public struct Regex<Output>: RegexComponent {
   // Compiler interface. Do not change independently.
   @usableFromInline
   init(_regexString pattern: String) {
-    self.init(ast: try! parse(pattern, .semantic, .traditional))
+    self.init(ast: try! parse(pattern, .traditional))
   }
 
   // Compiler interface. Do not change independently.
@@ -53,7 +53,7 @@ public struct Regex<Output>: RegexComponent {
     assert(version == currentRegexLiteralFormatVersion)
     // The version argument is passed by the compiler using the value defined
     // in libswiftParseRegexLiteral.
-    self.init(ast: try! parseWithDelimiters(pattern, .semantic))
+    self.init(ast: try! parseWithDelimiters(pattern))
   }
 
   public var regex: Regex<Output> {

Tests/RegexTests/CaptureTests.swift

@@ -158,7 +158,7 @@ func captureTest(
   file: StaticString = #file,
   line: UInt = #line
 ) {
-  let ast = try! parse(regex, .semantic, .traditional)
+  let ast = try! parse(regex, .traditional)
   var capList = ast.captureList.withoutLocs
   // Peel off the whole match element.
   capList.captures.removeFirst()

Tests/RegexTests/DiagnosticTests.swift

@@ -20,7 +20,7 @@ extension RegexTests {
     XCTAssert(SourceLocation.fake.isFake)
     XCTAssert(group(.capture, "a").location.isFake)
 
-    let ast = try! parse("(a)", .semantic, .traditional).root
+    let ast = try! parse("(a)", .traditional).root
     XCTAssert(ast.location.isReal)
   }
 
@@ -31,7 +31,7 @@ extension RegexTests {
     //
     // Input should be a concatenation or alternation
     func flatTest(_ str: String, _ expected: [String]) {
-      guard let ast = try? parse(str, .semantic, .traditional).root else {
+      guard let ast = try? parse(str, .traditional).root else {
         XCTFail("Fail to parse: \(str)")
         return
       }
@@ -53,9 +53,7 @@ extension RegexTests {
     flatTest("a|(b)|", ["a", "(b)", ""])
 
     func renderTest(_ str: String, _ expected: [String]) {
-      let lines = try! parse(
-        str, .semantic, .traditional
-      )._render(in: str)
+      let lines = try! parse(str, .traditional)._render(in: str)
       func fail() {
         XCTFail("""
           expected:

Tests/RegexTests/RenderDSLTests.swift

@@ -21,7 +21,7 @@ func testConversion(
   _ expectedDSL: String,
   file: StaticString = #file, line: UInt = #line
 ) throws {
-  let ast = try _RegexParser.parse(regex, .semantic, .traditional)
+  let ast = try _RegexParser.parse(regex, .traditional)
   let actualDSL = renderAsBuilderDSL(ast: ast)._trimmingSuffix(while: \.isWhitespace)
   XCTAssertEqual(actualDSL, expectedDSL[...], file: file, line: line)
 }