Implement the (?n) option

This switches `(...)` groups to being non-capturing,
with only named groups capturing.

Author: hamishknight

Sources/_RegexParser/Regex/Parse/LexicalAnalysis.swift

@@ -914,6 +914,10 @@ extension Source {
         }
         // TODO: (name:)
 
+        // If (?n) is set, a bare (...) group is non-capturing.
+        if context.syntax.contains(.namedCapturesOnly) {
+          return .nonCapture
+        }
         return .capture
       }
     }

Sources/_RegexParser/Regex/Parse/Parse.swift

@@ -287,23 +287,34 @@ extension Parser {
   private mutating func applySyntaxOptions(
     of opts: AST.MatchingOptionSequence
   ) {
-    // We skip this for multi-line, as extended syntax is always enabled there.
-    if context.syntax.contains(.multilineExtendedSyntax) { return }
+    func mapOption(_ option: SyntaxOptions,
+                   _ pred: (AST.MatchingOption) -> Bool) {
+      if opts.resetsCurrentOptions {
+        context.syntax.remove(option)
+      }
+      if opts.adding.contains(where: pred) {
+        context.syntax.insert(option)
+      }
+      if opts.removing.contains(where: pred) {
+        context.syntax.remove(option)
+      }
+    }
+    func mapOption(_ option: SyntaxOptions, _ kind: AST.MatchingOption.Kind) {
+      mapOption(option, { $0.kind == kind })
+    }
+
+    // (?n)
+    mapOption(.namedCapturesOnly, .namedCapturesOnly)
 
-    // Check if we're introducing or removing extended syntax.
+    // (?x), (?xx)
+    // We skip this for multi-line, as extended syntax is always enabled there.
     // TODO: PCRE differentiates between (?x) and (?xx) where only the latter
     // handles non-semantic whitespace in a custom character class. Other
     // engines such as Oniguruma, Java, and ICU do this under (?x). Therefore,
     // treat (?x) and (?xx) as the same option here. If we ever get a strict
     // PCRE mode, we will need to change this to handle that.
-    if opts.resetsCurrentOptions {
-      context.syntax.remove(.extendedSyntax)
-    }
-    if opts.adding.contains(where: \.isAnyExtended) {
-      context.syntax.insert(.extendedSyntax)
-    }
-    if opts.removing.contains(where: \.isAnyExtended) {
-      context.syntax.remove(.extendedSyntax)
+    if !context.syntax.contains(.multilineExtendedSyntax) {
+      mapOption(.extendedSyntax, \.isAnyExtended)
     }
   }
 

Sources/_RegexParser/Regex/Parse/SyntaxOptions.swift

@@ -63,6 +63,9 @@ public struct SyntaxOptions: OptionSet {
     return [Self(1 << 6), .extendedSyntax]
   }
 
+  /// `(?n)`
+  public static var namedCapturesOnly: Self { Self(1 << 7) }
+
   /*
 
     /// `<digit>*` == `[[:digit:]]*` == `\d*`

Tests/RegexTests/ParseTests.swift

@@ -973,6 +973,13 @@ extension RegexTests {
       "d"
     )), captures: [.cap])
 
+    parseTest("(?n)(?^:())(?<x>)()", concat(
+      changeMatchingOptions(matchingOptions(adding: .namedCapturesOnly)),
+      changeMatchingOptions(unsetMatchingOptions(), capture(empty())),
+      namedCapture("x", empty()),
+      nonCapture(empty())
+    ), captures: [.cap, .named("x")])
+
     // MARK: References
 
     // \1 ... \9 are always backreferences.