Disable unused delimiters

Leave only `/.../` (and its extended syntax)
enabled for now.

Author: hamishknight

Sources/_RegexParser/Regex/Parse/DelimiterLexing.swift

@@ -35,6 +35,12 @@ struct Delimiter: Hashable {
       return false
     }
   }
+
+  /// The delimiters which are currently enabled.
+  static var enabledDelimiters: [Kind] { [.forwardSlash] }
+
+  /// All known delimiters.
+  static var allDelimiters: [Kind] { Kind.allCases }
 }
 
 extension Delimiter {
@@ -106,11 +112,15 @@ fileprivate struct DelimiterLexer {
   var firstNewline: UnsafeRawPointer?
   var isMultiline: Bool { firstNewline != nil }
 
-  init(start: UnsafeRawPointer, end: UnsafeRawPointer) {
+  let delimiters: [Delimiter.Kind]
+
+  init(start: UnsafeRawPointer, end: UnsafeRawPointer,
+       delimiters: [Delimiter.Kind]) {
     precondition(start <= end)
     self.start = start
     self.cursor = start
     self.end = end
+    self.delimiters = delimiters
   }
 
   func ascii(_ s: Unicode.Scalar) -> UInt8 {
@@ -337,7 +347,7 @@ fileprivate struct DelimiterLexer {
   }
 
   mutating func tryLexOpeningDelimiter(poundCount: Int) -> Delimiter? {
-    for kind in Delimiter.Kind.allCases {
+    for kind in delimiters {
       // If the delimiter allows extended pound syntax, or there are no pounds,
       // we just need to lex it.
       let opening = kind.opening.utf8
@@ -435,7 +445,7 @@ func droppingRegexDelimiters(_ str: String) -> (String, Delimiter) {
     precondition(result.utf8.elementsEqual(slice))
     return (result, delim)
   }
-  for kind in Delimiter.Kind.allCases {
+  for kind in Delimiter.allDelimiters {
     if let (contents, d) = stripDelimiter(kind) {
       return (contents, d)
     }
@@ -446,8 +456,9 @@ func droppingRegexDelimiters(_ str: String) -> (String, Delimiter) {
 /// Attempt to lex a regex literal between `start` and `end`, returning either
 /// the contents and pointer from which to resume lexing, or an error.
 func lexRegex(
-  start: UnsafeRawPointer, end: UnsafeRawPointer
+  start: UnsafeRawPointer, end: UnsafeRawPointer,
+  delimiters: [Delimiter.Kind] = Delimiter.enabledDelimiters
 ) throws -> (contents: String, Delimiter, end: UnsafeRawPointer) {
-  var lexer = DelimiterLexer(start: start, end: end)
+  var lexer = DelimiterLexer(start: start, end: end, delimiters: delimiters)
   return try lexer.lex()
 }

Tests/RegexTests/LexTests.swift

@@ -100,7 +100,7 @@ extension RegexTests {
   }
 
 
-  func testCompilerInterface() {
+  func testCompilerInterface() throws {
     func delim(_ kind: Delimiter.Kind, poundCount: Int = 0) -> Delimiter {
       Delimiter(kind, poundCount: poundCount)
     }
@@ -138,7 +138,9 @@ extension RegexTests {
       input.withCString {
         let endPtr = $0 + input.utf8.count
         assert(endPtr.pointee == 0)
-        guard let out = try? lexRegex(start: $0, end: endPtr) else {
+        guard let out = try? lexRegex(
+          start: $0, end: endPtr, delimiters: Delimiter.allDelimiters)
+        else {
           XCTAssertNil(expected)
           return
         }
@@ -150,5 +152,23 @@ extension RegexTests {
         XCTAssertEqual(expected?.1, droppedDelimiters.1)
       }
     }
+
+    // TODO: Remove the lexing code for these if we no longer need them.
+    let disabledDelimiters: [String] = [
+      "#|x|#", "re'x'", "rx'y'"
+    ]
+
+    for input in disabledDelimiters {
+      try input.withCString {
+        let endPtr = $0 + input.utf8.count
+        assert(endPtr.pointee == 0)
+        do {
+          _ = try lexRegex(start: $0, end: endPtr)
+          XCTFail()
+        } catch let e as DelimiterLexError {
+          XCTAssertEqual(e.kind, .unknownDelimiter)
+        }
+      }
+    }
   }
 }

Tests/RegexTests/ParseTests.swift

@@ -117,7 +117,8 @@ func delimiterLexingTest(
 ) -> String {
   input.withCString(encodedAs: UTF8.self) { ptr in
     let endPtr = ptr + input.utf8.count
-    let (contents, delim, end) = try! lexRegex(start: ptr, end: endPtr)
+    let (contents, delim, end) = try! lexRegex(
+      start: ptr, end: endPtr, delimiters: Delimiter.allDelimiters)
     if ignoreTrailing {
       XCTAssertNotEqual(end, endPtr, file: file, line: line)
     } else {
@@ -260,7 +261,8 @@ func delimiterLexingDiagnosticTest(
 ) {
   do {
     _ = try input.withCString { ptr in
-      try lexRegex(start: ptr, end: ptr + input.count)
+      try lexRegex(
+        start: ptr, end: ptr + input.count, delimiters: Delimiter.allDelimiters)
     }
     XCTFail("""
       Passed, but expected error: \(expected)