Make RegexBuilder quantifiers follow option settings

Sources/RegexBuilder/DSL.swift

@@ -120,27 +120,29 @@ extension DSLTree.Node {
   @available(SwiftStdlib 5.7, *)
   static func repeating(
     _ range: Range<Int>,
-    _ behavior: QuantificationBehavior,
+    _ behavior: QuantificationBehavior?,
     _ node: DSLTree.Node
   ) -> DSLTree.Node {
     // TODO: Throw these as errors
     assert(range.lowerBound >= 0, "Cannot specify a negative lower bound")
     assert(!range.isEmpty, "Cannot specify an empty range")
+
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
 
     switch (range.lowerBound, range.upperBound) {
     case (0, Int.max): // 0...
-      return .quantification(.zeroOrMore, behavior.astKind, node)
+      return .quantification(.zeroOrMore, kind, node)
     case (1, Int.max): // 1...
-      return .quantification(.oneOrMore, behavior.astKind, node)
+      return .quantification(.oneOrMore, kind, node)
     case _ where range.count == 1: // ..<1 or ...0 or any range with count == 1
       // Note: `behavior` is ignored in this case
-      return .quantification(.exactly(.init(faking: range.lowerBound)), .eager, node)
+      return .quantification(.exactly(.init(faking: range.lowerBound)), .default, node)
     case (0, _): // 0..<n or 0...n or ..<n or ...n
-      return .quantification(.upToN(.init(faking: range.upperBound)), behavior.astKind, node)
+      return .quantification(.upToN(.init(faking: range.upperBound)), kind, node)
     case (_, Int.max): // n...
-      return .quantification(.nOrMore(.init(faking: range.lowerBound)), behavior.astKind, node)
+      return .quantification(.nOrMore(.init(faking: range.lowerBound)), kind, node)
     default: // any other range
-      return .quantification(.range(.init(faking: range.lowerBound), .init(faking: range.upperBound)), behavior.astKind, node)
+      return .quantification(.range(.init(faking: range.lowerBound), .init(faking: range.upperBound)), kind, node)
     }
   }
 }

Sources/VariadicsGenerator/VariadicsGenerator.swift

@@ -378,9 +378,10 @@ struct VariadicsGenerator: ParsableCommand {
         \(params.disfavored)\
         public init<\(params.genericParams)>(
           _ component: Component,
-          _ behavior: QuantificationBehavior = .eagerly
+          _ behavior: QuantificationBehavior? = nil
         ) \(params.whereClauseForInit) {
-          self.init(node: .quantification(.\(kind.astQuantifierAmount), behavior.astKind, component.regex.root))
+          let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+          self.init(node: .quantification(.\(kind.astQuantifierAmount), kind, component.regex.root))
         }
       }
 
@@ -389,10 +390,11 @@ struct VariadicsGenerator: ParsableCommand {
         \(defaultAvailableAttr)
         \(params.disfavored)\
         public init<\(params.genericParams)>(
-          _ behavior: QuantificationBehavior = .eagerly,
+          _ behavior: QuantificationBehavior? = nil,
           @\(concatBuilderName) _ component: () -> Component
         ) \(params.whereClauseForInit) {
-          self.init(node: .quantification(.\(kind.astQuantifierAmount), behavior.astKind, component().regex.root))
+          let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+          self.init(node: .quantification(.\(kind.astQuantifierAmount), kind, component().regex.root))
         }
       }
 
@@ -404,7 +406,7 @@ struct VariadicsGenerator: ParsableCommand {
           public static func buildLimitedAvailability<\(params.genericParams)>(
             _ component: Component
           ) -> \(regexTypeName)<\(params.matchType)> \(params.whereClause) {
-            .init(node: .quantification(.\(kind.astQuantifierAmount), .eager, component.regex.root))
+            .init(node: .quantification(.\(kind.astQuantifierAmount), .default, component.regex.root))
           }
         }
         """ : "")
@@ -488,7 +490,7 @@ struct VariadicsGenerator: ParsableCommand {
         ) \(params.whereClauseForInit) {
           assert(count > 0, "Must specify a positive count")
           // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-          self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+          self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
         }
 
         \(defaultAvailableAttr)
@@ -499,15 +501,15 @@ struct VariadicsGenerator: ParsableCommand {
         ) \(params.whereClauseForInit) {
           assert(count > 0, "Must specify a positive count")
           // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-          self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+          self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
         }
 
         \(defaultAvailableAttr)
         \(params.disfavored)\
         public init<\(params.genericParams), R: RangeExpression>(
           _ component: Component,
           _ expression: R,
-          _ behavior: QuantificationBehavior = .eagerly
+          _ behavior: QuantificationBehavior? = nil
         ) \(params.repeatingWhereClause) {
           self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
         }
@@ -516,7 +518,7 @@ struct VariadicsGenerator: ParsableCommand {
         \(params.disfavored)\
         public init<\(params.genericParams), R: RangeExpression>(
           _ expression: R,
-          _ behavior: QuantificationBehavior = .eagerly,
+          _ behavior: QuantificationBehavior? = nil,
           @\(concatBuilderName) _ component: () -> Component
         ) \(params.repeatingWhereClause) {
           self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))

Sources/_StringProcessing/ByteCodeGen.swift

@@ -364,10 +364,20 @@ extension Compiler.ByteCodeGen {
 
   mutating func emitQuantification(
     _ amount: AST.Quantification.Amount,
-    _ kind: AST.Quantification.Kind,
+    _ kind: DSLTree.QuantificationKind,
     _ child: DSLTree.Node
   ) throws {
-    let kind = kind.applying(options)
+    let updatedKind: AST.Quantification.Kind
+    switch kind {
+    case .explicit(let kind):
+      updatedKind = kind
+    case .syntax(let kind):
+      updatedKind = kind.applying(options)
+    case .default:
+      updatedKind = options.isReluctantByDefault
+        ? .reluctant
+        : .eager
+    }
 
     let (low, high) = amount.bounds
     switch (low, high) {
@@ -496,7 +506,7 @@ extension Compiler.ByteCodeGen {
     }
 
     // Set up a dummy save point for possessive to update
-    if kind == .possessive {
+    if updatedKind == .possessive {
       builder.pushEmptySavePoint()
     }
 
@@ -542,7 +552,7 @@ extension Compiler.ByteCodeGen {
         to: exit, ifZeroElseDecrement: extraTripsReg!)
     }
 
-    switch kind {
+    switch updatedKind {
     case .eager:
       builder.buildSplit(to: loopBody, saving: exit)
     case .possessive:

Sources/_StringProcessing/PrintAsPattern.swift

@@ -397,3 +397,14 @@ extension AST.Quantification.Kind {
     }
   }
 }
+
+extension DSLTree.QuantificationKind {
+  var _patternBase: String {
+    switch self {
+    case .explicit(let kind), .syntax(let kind):
+      return kind._patternBase
+    case .default:
+      return ".eager"
+    }
+  }
+}

Sources/_StringProcessing/Regex/ASTConversion.swift

@@ -123,7 +123,7 @@ extension AST.Node {
       case let .quantification(v):
         let child = v.child.dslTreeNode
         return .quantification(
-          v.amount.value, v.kind.value, child)
+          v.amount.value, .syntax(v.kind.value), child)
 
       case let .quote(v):
         return .quotedLiteral(v.literal)

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -56,7 +56,7 @@ extension DSLTree {
 
     case quantification(
       AST.Quantification.Amount,
-      AST.Quantification.Kind,
+      QuantificationKind,
       Node)
 
     case customCharacterClass(CustomCharacterClass)
@@ -103,6 +103,16 @@ extension DSLTree {
 }
 
 extension DSLTree {
+  @_spi(RegexBuilder)
+  public enum QuantificationKind {
+    /// The default quantification kind, as set by options.
+    case `default`
+    /// An explicitly chosen kind, overriding any options.
+    case explicit(AST.Quantification.Kind)
+    /// A kind set via syntax, which can be affected by options.
+    case syntax(AST.Quantification.Kind)
+  }
+
   @_spi(RegexBuilder)
   public struct CustomCharacterClass {
     var members: [Member]

Sources/_StringProcessing/Regex/Options.swift

@@ -59,6 +59,32 @@ extension RegexComponent {
     wrapInOption(.singleLine, addingIf: dotMatchesNewlines)
   }
 
+  /// Returns a regular expression where the start and end of input
+  /// anchors (`^` and `$`) also match against the start and end of a line.
+  ///
+  /// This method corresponds to applying the `m` option in a regular
+  /// expression literal. For this behavior in the `RegexBuilder` syntax, see
+  /// ``Anchor.startOfLine``, ``Anchor.endOfLine``, ``Anchor.startOfInput``,
+  /// and ``Anchor.endOfInput``.
+  ///
+  /// - Parameter matchLineEndings: A Boolean value indicating whether `^` and
+  ///   `$` should match the start and end of lines, respectively.
+  public func anchorsMatchLineEndings(_ matchLineEndings: Bool = true) -> Regex<RegexOutput> {
+    wrapInOption(.multiline, addingIf: matchLineEndings)
+  }
+
+  /// Returns a regular expression where quantifiers are reluctant by default
+  /// instead of eager.
+  ///
+  /// This method corresponds to applying the `U` option in a regular
+  /// expression literal.
+  ///
+  /// - Parameter useReluctantQuantifiers: A Boolean value indicating whether
+  ///   quantifiers should be reluctant by default.
+  public func reluctantQuantifiers(_ useReluctantQuantifiers: Bool = true) -> Regex<RegexOutput> {
+    wrapInOption(.reluctantByDefault, addingIf: useReluctantQuantifiers)
+  }
+
   /// Returns a regular expression that matches with the specified semantic
   /// level.
   ///
@@ -128,39 +154,6 @@ public struct RegexSemanticLevel: Hashable {
   }
 }
 
-// Options that only affect literals
-@available(SwiftStdlib 5.7, *)
-extension RegexComponent {
-  /// Returns a regular expression where the start and end of input
-  /// anchors (`^` and `$`) also match against the start and end of a line.
-  ///
-  /// This method corresponds to applying the `m` option in a regular
-  /// expression literal, and only applies to regular expressions specified as
-  /// literals. For this behavior in the `RegexBuilder` syntax, see
-  /// ``Anchor.startOfLine``, ``Anchor.endOfLine``, ``Anchor.startOfInput``,
-  /// and ``Anchor.endOfInput``.
-  ///
-  /// - Parameter matchLineEndings: A Boolean value indicating whether `^` and
-  ///   `$` should match the start and end of lines, respectively.
-  public func anchorsMatchLineEndings(_ matchLineEndings: Bool = true) -> Regex<RegexOutput> {
-    wrapInOption(.multiline, addingIf: matchLineEndings)
-  }
-
-  /// Returns a regular expression where quantifiers are reluctant by default
-  /// instead of eager.
-  ///
-  /// This method corresponds to applying the `U` option in a regular
-  /// expression literal, and only applies to regular expressions specified as
-  /// literals. In the `RegexBuilder` syntax, pass a ``QuantificationBehavior``
-  /// value to any quantification method to change its behavior.
-  ///
-  /// - Parameter useReluctantCaptures: A Boolean value indicating whether
-  ///   quantifiers should be reluctant by default.
-  public func reluctantCaptures(_ useReluctantCaptures: Bool = true) -> Regex<RegexOutput> {
-    wrapInOption(.reluctantByDefault, addingIf: useReluctantCaptures)
-  }
-}
-
 // MARK: - Helper method
 
 @available(SwiftStdlib 5.7, *)

Tests/RegexBuilderTests/RegexDSLTests.swift

@@ -262,6 +262,24 @@ class RegexDSLTests: XCTestCase {
         }
         .ignoringCase(false)
       }
+
+    try _testDSLCaptures(
+      ("abcdef123", ("abcdef123", "a", "123")),
+      matchType: (Substring, Substring, Substring).self, ==) {
+        Capture {
+          // Reluctant behavior due to option
+          OneOrMore(.anyOf("abcd"))
+            .reluctantQuantifiers()
+        }
+        ZeroOrMore("a"..."z")
+
+        Capture {
+          // Eager behavior due to explicit parameter, despite option
+          OneOrMore(.digit, .eagerly)
+            .reluctantQuantifiers()
+        }
+        ZeroOrMore(.digit)
+      }
   }
 
   func testQuantificationBehavior() throws {
@@ -293,7 +311,7 @@ class RegexDSLTests: XCTestCase {
           OneOrMore(.word)
           Capture(.digit)
           ZeroOrMore(.any)
-        }.reluctantCaptures()
+        }.reluctantQuantifiers()
       }
     }
 #endif