Parse conditional patterns

This parses a superset of the conditional syntax
accepted by PCRE, Oniguruma & .NET (ICU and Java
do not support this feature). This includes the
ability for the condition to execute an arbitrary
regex match as a group.

Note there's some ambiguity with expressions of the
form `(?(xxx))`, PCRE always treats this as a named
group reference, whereas .NET only treats it as
such if a group is defined with that name anywhere
in the regex (otherwise it interprets it as
arbitrary regex condition). For now, check to see
if a prior group has been defined with that name.
This will need to be updated in the future to
check for any proceeding groups with that name if
we want to fully match the .NET behavior here.

This commit moves AST.Atom.Reference -> AST.Reference,
as it's now also being used by AST.Conditional.

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -23,6 +23,9 @@ public indirect enum AST:
   /// (...)
   case group(Group)
 
+  /// (?(cond) true-branch | false-branch)
+  case conditional(Conditional)
+
   case quantification(Quantification)
 
   /// \Q...\E
@@ -55,6 +58,7 @@ extension AST {
     case let .alternation(v):          return v
     case let .concatenation(v):        return v
     case let .group(v):                return v
+    case let .conditional(v):          return v
     case let .quantification(v):       return v
     case let .quote(v):                return v
     case let .trivia(v):               return v
@@ -163,6 +167,42 @@ extension AST {
       self.location = location
     }
   }
+
+  public struct Reference: Hashable {
+    @frozen
+    public enum Kind: Hashable {
+      // \n \gn \g{n} \g<n> \g'n' (?n) (?(n)...
+      // Oniguruma: \k<n>, \k'n'
+      case absolute(Int)
+
+      // \g{-n} \g<+n> \g'+n' \g<-n> \g'-n' (?+n) (?-n)
+      // (?(+n)... (?(-n)...
+      // Oniguruma: \k<-n> \k<+n> \k'-n' \k'+n'
+      case relative(Int)
+
+      // \k<name> \k'name' \g{name} \k{name} (?P=name)
+      // \g<name> \g'name' (?&name) (?P>name)
+      // (?(<name>)... (?('name')... (?(name)...
+      case named(String)
+
+      /// (?R), (?(R)..., which are equivalent to (?0), (?(0)...
+      static var recurseWholePattern: Kind { .absolute(0) }
+    }
+    public var kind: Kind
+
+    /// The location of the inner numeric or textual reference, e.g the location
+    /// of '-2' in '\g{-2}'.
+    public var innerLoc: SourceLocation
+
+    public init(_ kind: Kind, innerLoc: SourceLocation) {
+      self.kind = kind
+      self.innerLoc = innerLoc
+    }
+
+    /// Whether this is a reference that recurses the whole pattern, rather than
+    /// a group.
+    public var recursesWholePattern: Bool { kind == .recurseWholePattern }
+  }
 }
 
 // FIXME: Get this out of here

Sources/_MatchingEngine/Regex/AST/Atom.swift

@@ -66,7 +66,6 @@ extension AST {
       // References
       case backreference(Reference)
       case subpattern(Reference)
-      case condition(Reference)
     }
   }
 }
@@ -382,44 +381,6 @@ extension AST.Atom.CharacterProperty {
   }
 }
 
-extension AST.Atom {
-  public struct Reference: Hashable {
-    @frozen
-    public enum Kind: Hashable {
-      // \n \gn \g{n} \g<n> \g'n' (?n) (?(n)...
-      // Oniguruma: \k<n>, \k'n'
-      case absolute(Int)
-
-      // \g{-n} \g<+n> \g'+n' \g<-n> \g'-n' (?+n) (?-n)
-      // (?(+n)... (?(-n)...
-      // Oniguruma: \k<-n> \k<+n> \k'-n' \k'+n'
-      case relative(Int)
-
-      // \k<name> \k'name' \g{name} \k{name} (?P=name)
-      // \g<name> \g'name' (?&name) (?P>name)
-      // (?(<name>)... (?('name')... (?(name)...
-      case named(String)
-
-      /// (?R), (?(R)..., which are equivalent to (?0), (?(0)...
-      static var recurseWholePattern: Kind { .absolute(0) }
-    }
-    public var kind: Kind
-
-    /// The location of the inner numeric or textual reference, e.g the location
-    /// of '-2' in '\g{-2}'.
-    public var innerLoc: SourceLocation
-
-    public init(_ kind: Kind, innerLoc: SourceLocation) {
-      self.kind = kind
-      self.innerLoc = innerLoc
-    }
-
-    /// Whether this is a reference that recurses the whole pattern, rather than
-    /// a group.
-    public var recursesWholePattern: Bool { kind == .recurseWholePattern }
-  }
-}
-
 extension AST.Atom {
   /// Anchors and other built-in zero-width assertions
   @frozen
@@ -497,7 +458,7 @@ extension AST.Atom {
       fallthrough
 
     case .property, .escaped, .any, .startOfLine, .endOfLine,
-        .backreference, .subpattern, .condition, .namedCharacter:
+        .backreference, .subpattern, .namedCharacter:
       return nil
     }
   }
@@ -522,7 +483,7 @@ extension AST.Atom {
       return "\\M-\\C-\(x)"
 
     case .property, .escaped, .any, .startOfLine, .endOfLine,
-        .backreference, .subpattern, .condition, .namedCharacter:
+        .backreference, .subpattern, .namedCharacter:
       return nil
     }
   }
@@ -534,8 +495,8 @@ extension AST {
     case .atom(let a): return a.literalStringValue
 
     case .alternation, .concatenation, .group,
-        .quantification, .quote, .trivia,
-        .customCharacterClass, .empty,
+        .conditional, .quantification, .quote,
+        .trivia, .customCharacterClass, .empty,
         .groupTransform:
       return nil
     }

Sources/_MatchingEngine/Regex/AST/Conditional.swift

@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+extension AST {
+  public struct Conditional: Hashable, _ASTNode {
+    public var location: SourceLocation
+    public var condition: Condition
+
+    public var trueBranch: AST
+    public var pipe: SourceLocation?
+    public var falseBranch: AST
+
+    public init(
+      _ condition: Condition, trueBranch: AST, pipe: SourceLocation?,
+      falseBranch: AST, _ location: SourceLocation
+    ) {
+      self.location = location
+      self.condition = condition
+      self.trueBranch = trueBranch
+      self.pipe = pipe
+      self.falseBranch = falseBranch
+    }
+  }
+}
+
+extension AST.Conditional {
+  public struct Condition: Hashable {
+    public enum Kind: Hashable {
+      /// Check to see if a certain group was matched.
+      case groupMatched(AST.Reference)
+
+      // Check for recursion.
+      case recursionCheck
+      case groupRecursionCheck(AST.Reference)
+
+      /// Define a new group that can be referenced elsewhere.
+      case defineGroup
+
+      /// A PCRE version check.
+      case pcreVersionCheck(PCREVersionCheck)
+
+      /// A group condition, which checks to see if an arbitrary bit of regex
+      /// matches. Note that the semantics of this differs by engine, .NET only
+      /// treats it as a lookahead, whereas Oniguruma can evaluate separately
+      /// from the body of the conditional.
+      case group(AST.Group)
+    }
+
+    public var kind: Kind
+    public var location: SourceLocation
+
+    public init(_ kind: Kind, _ location: SourceLocation) {
+      self.kind = kind
+      self.location = location
+    }
+  }
+}
+
+extension AST.Conditional.Condition {
+  public struct PCREVersionNumber: Hashable {
+    public var major: Int
+    public var minor: Int
+    public var location: SourceLocation
+
+    public init(major: Int, minor: Int, _ location: SourceLocation) {
+      self.major = major
+      self.minor = minor
+      self.location = location
+    }
+  }
+  public struct PCREVersionCheck: Hashable {
+    public enum Kind: Hashable {
+      case equal, greaterThanOrEqual
+    }
+    public var kind: AST.Located<Kind>
+    public var num: PCREVersionNumber
+
+    public init(_ kind: AST.Located<Kind>, _ num: PCREVersionNumber) {
+      self.kind = kind
+      self.num = num
+    }
+  }
+}

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -47,6 +47,21 @@ extension AST {
       default:
         return innerCaptures
       }
+    case .conditional(let c):
+      // A conditional's capture structure is effectively that of an alternation
+      // between the true and false branches. However the condition may also
+      // have captures in the case of a group condition.
+      var captures = CaptureStructure.empty
+      switch c.condition.kind {
+      case .group(let g):
+        captures = captures + AST.group(g).captureStructure
+      default:
+        break
+      }
+      let branchCaptures = c.trueBranch.captureStructure +
+                           c.falseBranch.captureStructure
+      return captures + branchCaptures.map(CaptureStructure.optional)
+
     case .quantification(let quantification):
       return quantification.child.captureStructure.map(
         quantification.amount.value == .zeroOrOne

Sources/_MatchingEngine/Regex/Parse/Diagnostics.swift

@@ -28,6 +28,8 @@ enum ParseError: Error, Hashable {
   // Something happened, fall-back for now
   case misc(String)
 
+  case tooManyBranchesInConditional(Int)
+
   case expectedASCII(Character)
 
   case expectedNonEmptyContents
@@ -77,6 +79,8 @@ extension ParseError: CustomStringConvertible {
       return "expected escape sequence"
     case .cannotReferToWholePattern:
       return "cannot refer to whole pattern here"
+    case let .tooManyBranchesInConditional(i):
+      return "expected 2 branches in conditional, have \(i)"
     case let .unknownGroupKind(str):
       return "unknown group kind '(\(str)'"
     case let .invalidMatchingOption(c):