[WIP] Regex lookbehind support

Sources/RegexBuilder/Anchor.swift

@@ -226,3 +226,64 @@ public struct NegativeLookahead<Output>: _BuiltinRegexComponent {
     self.init(_RegexFactory().negativeLookaheadNonCapturing(component()))
   }
 }
+
+/// A regex component that allows a match to continue only if its contents
+/// match at the given location.
+///
+/// A lookbehind is a zero-length assertion that its included regex matches at
+/// a particular position. Lookbehinds do not advance the overall matching
+/// position in the input string — once a lookbehind succeeds, matching continues
+/// in the regex from the same position.
+@available(SwiftStdlib 5.7, *) // TODO: How should this be gated?
+public struct Lookbehind<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
+
+  init(_ regex: Regex<Output>) {
+    self.regex = regex
+  }
+
+  /// Creates a lookbehind from the given regex component.
+  public init<R: RegexComponent>(
+    _ component: R
+  ) where R.RegexOutput == Output {
+    self.init(_RegexFactory().lookbehindNonCapturing(component))
+  }
+
+  /// Creates a lookbehind from the regex generated by the given builder closure.
+  public init<R: RegexComponent>(
+    @RegexComponentBuilder _ component: () -> R
+  ) where R.RegexOutput == Output {
+    self.init(_RegexFactory().lookbehindNonCapturing(component()))
+  }
+}
+
+/// A regex component that allows a match to continue only if its contents
+/// do not match at the given location.
+///
+/// A negative lookbehind is a zero-length assertion that its included regex
+/// does not match at a particular position. Lookbehinds do not advance the
+/// overall matching position in the input string — once a lookbehind succeeds,
+/// matching continues in the regex from the same position.
+@available(SwiftStdlib 5.7, *) // TODO: How should this be gated?
+public struct NegativeLookbehind<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
+
+  init(_ regex: Regex<Output>) {
+    self.regex = regex
+  }
+
+  /// Creates a negative lookbehind from the given regex component.
+  public init<R: RegexComponent>(
+    _ component: R
+  ) where R.RegexOutput == Output {
+    self.init(_RegexFactory().negativeLookbehindNonCapturing(component))
+  }
+
+  /// Creates a negative lookbehind from the regex generated by the given builder
+  /// closure.
+  public init<R: RegexComponent>(
+    @RegexComponentBuilder _ component: () -> R
+  ) where R.RegexOutput == Output {
+    self.init(_RegexFactory().negativeLookbehindNonCapturing(component()))
+  }
+}

Sources/_RegexParser/Regex/AST/MatchingOptions.swift

@@ -47,6 +47,9 @@ extension AST {
 
       // NSRegularExpression compatibility special-case
       case nsreCompatibleDot        // no AST representation
+
+      // Lookbehind support
+      case reverse                  // no AST representation
     }
 
     public var kind: Kind

Sources/_RegexParser/Regex/Parse/Parse.swift

@@ -523,6 +523,19 @@ extension Parser {
   mutating func parseCustomCharacterClass(
     _ start: Source.Located<CustomCC.Start>
   ) -> CustomCC {
+    // Excessively nested recursion is a common DOS attack, so limit
+    // our recursion.
+    context.parseDepth += 1
+    defer { context.parseDepth -= 1 }
+    guard context.parseDepth < context.maxParseDepth else {
+      self.errorAtCurrentPosition(.nestingTooDeep)
+
+      // This is not generally recoverable and further errors will be
+      // incorrect
+      diags.suppressFurtherDiagnostics = true
+      return .init(start, [], start.location)
+    }
+
     let alreadyInCCC = context.isInCustomCharacterClass
     context.isInCustomCharacterClass = true
     defer { context.isInCustomCharacterClass = alreadyInCCC }

Sources/_RegexParser/Regex/Parse/Sema.swift

@@ -143,7 +143,7 @@ extension RegexValidator {
     case .caseInsensitive, .possessiveByDefault, .reluctantByDefault,
         .singleLine, .multiline, .namedCapturesOnly, .extended, .extraExtended,
         .asciiOnlyDigit, .asciiOnlyWord, .asciiOnlySpace, .asciiOnlyPOSIXProps,
-        .nsreCompatibleDot:
+        .nsreCompatibleDot, .reverse:
       break
     }
   }
@@ -370,7 +370,7 @@ extension RegexValidator {
     }
     switch kind.value {
     case .capture, .namedCapture, .nonCapture, .lookahead, .negativeLookahead,
-        .atomicNonCapturing:
+        .atomicNonCapturing, .lookbehind, .negativeLookbehind:
       break
 
     case .balancedCapture:
@@ -384,8 +384,8 @@ extension RegexValidator {
     case .nonAtomicLookahead:
       error(.unsupported("non-atomic lookahead"), at: kind.location)
 
-    case .lookbehind, .negativeLookbehind, .nonAtomicLookbehind:
-      error(.unsupported("lookbehind"), at: kind.location)
+    case .nonAtomicLookbehind:
+      error(.unsupported("non-atomic lookbehind"), at: kind.location)
 
     case .scriptRun, .atomicScriptRun:
       error(.unsupported("script run"), at: kind.location)