Diagnose backreferences to the whole pattern

Only subpatterns support whole-pattern recursion.
In addition, plumb through the `eatEnding` param.

Author: hamishknight

Sources/_MatchingEngine/Regex/Parse/Diagnostics.swift

@@ -33,6 +33,8 @@ enum ParseError: Error, Hashable {
   case expectedNonEmptyContents
   case expectedEscape
 
+  case cannotReferToWholePattern
+
   case unknownGroupKind(String)
 
   case invalidMatchingOption(Character)
@@ -73,6 +75,8 @@ extension ParseError: CustomStringConvertible {
       return "expected non-empty contents"
     case .expectedEscape:
       return "expected escape sequence"
+    case .cannotReferToWholePattern:
+      return "cannot refer to whole pattern here"
     case let .unknownGroupKind(str):
       return "unknown group kind '(\(str)'"
     case let .invalidMatchingOption(c):

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -854,6 +854,7 @@ extension Source {
   ///     NumberRef -> ('+' | '-')? <Decimal Number>
   ///
   private mutating func lexNumberedReference(
+    allowWholePatternRef: Bool = false
   ) throws -> AST.Atom.Reference? {
     let kind = try recordLoc { src -> AST.Atom.Reference.Kind? in
       // Note this logic should match canLexNumberedReference.
@@ -869,6 +870,9 @@ extension Source {
       return nil
     }
     guard let kind = kind else { return nil }
+    guard allowWholePatternRef || kind.value != .recurseWholePattern else {
+      throw ParseError.cannotReferToWholePattern
+    }
     return .init(kind.value, innerLoc: kind.location)
   }
 
@@ -882,10 +886,10 @@ extension Source {
 
   /// Eat a named reference up to a given closing delimiter.
   private mutating func expectNamedReference(
-    endingWith end: String
+    endingWith end: String, eatEnding: Bool = true
   ) throws -> AST.Atom.Reference {
     // TODO: Group name validation, see comment in lexGroupStart.
-    let str = try expectQuoted(endingWith: end)
+    let str = try expectQuoted(endingWith: end, eatEnding: eatEnding)
     return .init(.named(str.value), innerLoc: str.location)
   }
 
@@ -894,13 +898,18 @@ extension Source {
   ///     NameOrNumberRef -> NumberRef | <String>
   ///
   private mutating func expectNamedOrNumberedReference(
-    endingWith ending: String
+    endingWith ending: String, eatEnding: Bool = true,
+    allowWholePatternRef: Bool = false
   ) throws -> AST.Atom.Reference {
-    if let numbered = try lexNumberedReference() {
-      try expect(sequence: ending)
+    if let numbered = try lexNumberedReference(
+      allowWholePatternRef: allowWholePatternRef
+    ) {
+      if eatEnding {
+        try expect(sequence: ending)
+      }
       return numbered
     }
-    return try expectNamedReference(endingWith: ending)
+    return try expectNamedReference(endingWith: ending, eatEnding: eatEnding)
   }
 
   private static func getClosingDelimiter(
@@ -943,8 +952,8 @@ extension Source {
           // Oniguruma-style subpatterns.
           if let openChar = src.tryEat(anyOf: "<", "'") {
             let closing = String(Source.getClosingDelimiter(for: openChar))
-            return .subpattern(
-              try src.expectNamedOrNumberedReference(endingWith: closing))
+            return .subpattern(try src.expectNamedOrNumberedReference(
+              endingWith: closing, allowWholePatternRef: true))
           }
 
           // PCRE allows \g followed by a bare numeric reference.
@@ -1029,7 +1038,7 @@ extension Source {
         }
 
         // Numbered subpattern reference.
-        if let ref = try src.lexNumberedReference() {
+        if let ref = try src.lexNumberedReference(allowWholePatternRef: true) {
           try src.expect(")")
           return .subpattern(ref)
         }

Tests/RegexTests/ParseTests.swift

@@ -1119,5 +1119,9 @@ extension RegexTests {
     diagnosticTest(#"\k''"#, .expectedNonEmptyContents)
     diagnosticTest(#"(?&)"#, .expectedNonEmptyContents)
     diagnosticTest(#"(?P>)"#, .expectedNonEmptyContents)
+
+    // MARK: References
+
+    diagnosticTest(#"\g{0}"#, .cannotReferToWholePattern)
   }
 }