Introduce ParsingContext

Subsume the individual contextual lexing parameters
with a ParsingContext type that tracks the number
and names of groups, in addition to whether we're
parsing within a custom character class.

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/Group.swift

@@ -98,6 +98,14 @@ extension AST.Group.Kind {
       return false
     }
   }
+
+  /// If this is a named group, its name, `nil` otherwise.
+  public var name: String? {
+    switch self {
+    case .namedCapture(let name): return name.value
+    default: return nil
+    }
+  }
 }
 
 extension AST.Group {

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -936,7 +936,7 @@ extension Source {
   ///                       | [1-9] [0-9]+
   ///
   private mutating func lexEscapedReference(
-    priorGroupCount: Int
+    context: ParsingContext
   ) throws -> Located<AST.Atom.Kind>? {
     try recordLoc { src in
       try src.tryEating { src in
@@ -989,7 +989,7 @@ extension Source {
           let num = numAndLoc.value
           let loc = numAndLoc.location
           if num < 10 || firstChar == "8" || firstChar == "9" ||
-              num <= priorGroupCount {
+              context.isPriorGroupRef(.absolute(num)) {
             return .backreference(.init(.absolute(num), innerLoc: loc))
           }
           return nil
@@ -1066,9 +1066,11 @@ extension Source {
   ///                       | EscapedReference
   ///
   mutating func expectEscaped(
-    isInCustomCharacterClass ccc: Bool, priorGroupCount: Int
+    context: ParsingContext
   ) throws -> Located<AST.Atom.Kind> {
     try recordLoc { src in
+      let ccc = context.isInCustomCharacterClass
+
       // Keyboard control/meta
       if src.tryEat("c") || src.tryEat(sequence: "C-") {
         return .keyboardControl(try src.expectASCII().value)
@@ -1092,9 +1094,7 @@ extension Source {
 
       // References using escape syntax, e.g \1, \g{1}, \k<...>, ...
       // These are not valid inside custom character classes.
-      if !ccc, let ref = try src.lexEscapedReference(
-        priorGroupCount: priorGroupCount
-      )?.value {
+      if !ccc, let ref = try src.lexEscapedReference(context: context)?.value {
         return ref
       }
 
@@ -1132,9 +1132,8 @@ extension Source {
   ///
   ///     ExpGroupStart -> '(_:'
   ///
-  mutating func lexAtom(
-    isInCustomCharacterClass customCC: Bool, priorGroupCount: Int
-  ) throws -> AST.Atom? {
+  mutating func lexAtom(context: ParsingContext) throws -> AST.Atom? {
+    let customCC = context.isInCustomCharacterClass
     let kind: Located<AST.Atom.Kind>? = try recordLoc { src in
       // Check for not-an-atom, e.g. parser recursion termination
       if src.isEmpty { return nil }
@@ -1168,9 +1167,7 @@ extension Source {
       case "$": return customCC ? .char("$") : .endOfLine
 
       // Escaped
-      case "\\": return try src.expectEscaped(
-        isInCustomCharacterClass: customCC,
-        priorGroupCount: priorGroupCount).value
+      case "\\": return try src.expectEscaped(context: context).value
 
       case "]":
         assert(!customCC, "parser should have prevented this")
@@ -1186,7 +1183,7 @@ extension Source {
   /// Try to lex the end of a range in a custom character class, which consists
   /// of a '-' character followed by an atom.
   mutating func lexCustomCharClassRangeEnd(
-    priorGroupCount: Int
+    context: ParsingContext
   ) throws -> (dashLoc: SourceLocation, AST.Atom)? {
     // Make sure we don't have a binary operator e.g '--', and the '-' is not
     // ending the custom character class (in which case it is literal).
@@ -1195,8 +1192,7 @@ extension Source {
       return nil
     }
     let dashLoc = Location(start ..< currentPosition)
-    guard let end = try lexAtom(isInCustomCharacterClass: true,
-                                priorGroupCount: priorGroupCount) else {
+    guard let end = try lexAtom(context: context) else {
       return nil
     }
     return (dashLoc, end)

Sources/_MatchingEngine/Regex/Parse/Parse.swift

@@ -51,28 +51,52 @@ Lexical analysis provides the following:
 
 */
 
-private struct Parser {
-  var source: Source
-
-  /// Tracks the number of parent custom character classes to allow us to
-  /// determine whether or not to lex with custom character class syntax.
-  fileprivate var customCharacterClassDepth = 0
+struct ParsingContext {
+  /// Whether we're currently parsing in a custom character class.
+  var isInCustomCharacterClass = false
 
   /// Tracks the number of group openings we've seen, to disambiguate the '\n'
   /// syntax as a backreference or an octal sequence.
   fileprivate var priorGroupCount = 0
 
+  /// A set of used group names.
+  fileprivate var usedGroupNames = Set<String>()
+
+  fileprivate mutating func recordGroup(_ g: AST.Group.Kind) {
+    // TODO: Needs to track group number resets (?|...).
+    priorGroupCount += 1
+    if let name = g.name {
+      usedGroupNames.insert(name)
+    }
+  }
+
+  private init() {}
+  static var none: ParsingContext { .init() }
+
+  /// Check whether a given reference refers to a prior group.
+  func isPriorGroupRef(_ ref: AST.Atom.Reference.Kind) -> Bool {
+    switch ref {
+    case .absolute(let i):
+      return i <= priorGroupCount
+    case .relative(let i):
+      return i < 0
+    case .named(let str):
+      return usedGroupNames.contains(str)
+    }
+  }
+}
+
+private struct Parser {
+  var source: Source
+  var context: ParsingContext = .none
+
   init(_ source: Source) {
     self.source = source
   }
 }
 
 // Diagnostics
 extension Parser {
-  private var isInCustomCharacterClass: Bool {
-    customCharacterClassDepth > 0
-  }
-
   mutating func report(
     _ str: String, _ function: String = #function, _ line: Int = #line
   ) throws -> Never {
@@ -172,6 +196,20 @@ extension Parser {
     return .concatenation(.init(result, loc(_start)))
   }
 
+  /// Perform a recursive parse for the body of a group.
+  mutating func parseGroupBody(
+    start: Source.Position, _ kind: AST.Located<AST.Group.Kind>
+  ) throws -> AST.Group {
+    context.recordGroup(kind.value)
+
+    let child = try parse()
+    // An implicit scoped group has already consumed its closing paren.
+    if !kind.value.hasImplicitScope {
+      try source.expect(")")
+    }
+    return .init(kind, child, loc(start))
+  }
+
   /// Parse a (potentially quantified) component
   ///
   ///     QuantOperand -> Group | CustomCharClass | Atom
@@ -182,24 +220,18 @@ extension Parser {
 
     let _start = source.currentPosition
 
+    // Check if we have the start of a group '('.
     if let kind = try source.lexGroupStart() {
-      priorGroupCount += 1
-      let child = try parse()
-      // An implicit scoped group has already consumed its closing paren.
-      if !kind.value.hasImplicitScope {
-        try source.expect(")")
-      }
-      return .group(.init(kind, child, loc(_start)))
+      return .group(try parseGroupBody(start: _start, kind))
     }
+
+    // Check if we have the start of a custom character class '['.
     if let cccStart = try source.lexCustomCCStart() {
       return .customCharacterClass(
         try parseCustomCharacterClass(cccStart))
     }
 
-    if let atom = try source.lexAtom(
-      isInCustomCharacterClass: isInCustomCharacterClass,
-      priorGroupCount: priorGroupCount
-    ) {
+    if let atom = try source.lexAtom(context: context) {
       // TODO: track source locations
       return .atom(atom)
     }
@@ -224,6 +256,10 @@ extension Parser {
   mutating func parseCustomCharacterClass(
     _ start: Source.Located<CustomCC.Start>
   ) throws -> CustomCC {
+    let alreadyInCCC = context.isInCustomCharacterClass
+    context.isInCustomCharacterClass = true
+    defer { context.isInCustomCharacterClass = alreadyInCCC }
+
     typealias Member = CustomCC.Member
     try source.expectNonEmpty()
 
@@ -279,14 +315,11 @@ extension Parser {
         continue
       }
 
-      guard let atom = try source.lexAtom(
-        isInCustomCharacterClass: true, priorGroupCount: priorGroupCount)
-      else { break }
+      guard let atom = try source.lexAtom(context: context) else { break }
 
       // Range between atoms.
-      if let (dashLoc, rhs) = try source.lexCustomCharClassRangeEnd(
-        priorGroupCount: priorGroupCount
-      ) {
+      if let (dashLoc, rhs) =
+          try source.lexCustomCharClassRangeEnd(context: context) {
         guard atom.literalCharacterValue != nil &&
               rhs.literalCharacterValue != nil else {
           throw ParseError.invalidCharacterClassRangeOperand