Add location info to Reference

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/Atom.swift

@@ -382,34 +382,39 @@ 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)...
+      case recurseWholePattern
+    }
+    public var kind: Kind
 
-// TODO: I haven't thought through this a bunch; this seems like
-// a sensible type to have and break down this way. But it could
-// easily get folded in with the kind of reference
-@frozen
-public enum Reference: 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)
-
-  // TODO: I'm not sure the below goes here
-  //
-  // ?(R) (?(R)...
-  case recurseWholePattern
-}
-
-
+    /// 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
+    }
+  }
+}
 
 extension AST.Atom {
   /// Anchors and other built-in zero-width assertions

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -825,8 +825,8 @@ extension Source {
   ///     NumberRef -> ('+' | '-')? <Decimal Number>
   ///
   private mutating func lexNumberedReference(
-  ) throws -> Located<Reference>? {
-    try recordLoc { src in
+  ) throws -> AST.Atom.Reference? {
+    let kind = try recordLoc { src -> AST.Atom.Reference.Kind? in
       if src.tryEat("+") {
         return .relative(try src.expectNumber().value)
       }
@@ -838,13 +838,16 @@ extension Source {
       }
       return nil
     }
+    guard let kind = kind else { return nil }
+    return .init(kind.value, innerLoc: kind.location)
   }
 
   /// Eat a named reference up to a given closing delimiter.
   private mutating func expectNamedReference(
     endingWith end: String
-  ) throws -> Reference {
-    .named(try expectQuoted(endingWith: end).value)
+  ) throws -> AST.Atom.Reference {
+    let str = try expectQuoted(endingWith: end)
+    return .init(.named(str.value), innerLoc: str.location)
   }
 
   /// Try to lex a numbered reference, or otherwise a named reference.
@@ -853,10 +856,10 @@ extension Source {
   ///
   private mutating func expectNamedOrNumberedReference(
     endingWith ending: String
-  ) throws -> Reference {
+  ) throws -> AST.Atom.Reference {
     if let numbered = try lexNumberedReference() {
       try expect(sequence: ending)
-      return numbered.value
+      return numbered
     }
     return try expectNamedReference(endingWith: ending)
   }
@@ -904,7 +907,7 @@ extension Source {
 
         // PCRE allows \g followed by a bare numeric reference.
         if let ref = try src.lexNumberedReference() {
-          return .backreference(ref.value)
+          return .backreference(ref)
         }
 
         // Fallback to a literal character. We need to return here as we've
@@ -942,8 +945,10 @@ extension Source {
         let num = try Source.validateNumber(digits.string, Int.self, .decimal)
         if num < 10 || digits.first == "8" || digits.first == "9" ||
             num <= priorGroupCount {
+          let _start = src.currentPosition
           src.advance(digits.count)
-          return .backreference(.absolute(num))
+          return .backreference(
+            .init(.absolute(num), innerLoc: Location(_start ..< src.currentPosition)))
         }
       }
       return nil

Sources/_MatchingEngine/Regex/Printing/DumpAST.swift

@@ -107,14 +107,20 @@ extension AST.Atom {
     case .endOfLine:   return "$"
 
     case .backreference(let r), .subpattern(let r), .condition(let r):
-      return "\(r)"
+      return "\(r._dumpBase)"
 
     case .char, .scalar:
       fatalError("Unreachable")
     }
   }
 }
 
+extension AST.Atom.Reference: _ASTPrintable {
+  public var _dumpBase: String {
+    "\(kind)"
+  }
+}
+
 extension AST.Group.Kind: _ASTPrintable {
   public var _dumpBase: String {
     switch self {

Sources/_StringProcessing/ASTBuilder.swift

@@ -233,14 +233,14 @@ func scalar_m(_ s: Unicode.Scalar) -> AST.CustomCharacterClass.Member {
   atom_m(.scalar(s))
 }
 
-func backreference(_ r: Reference) -> AST {
-  atom(.backreference(r))
+func backreference(_ r: AST.Atom.Reference.Kind) -> AST {
+  atom(.backreference(.init(r, innerLoc: .fake)))
 }
-func subpattern(_ r: Reference) -> AST {
-  atom(.subpattern(r))
+func subpattern(_ r: AST.Atom.Reference.Kind) -> AST {
+  atom(.subpattern(.init(r, innerLoc: .fake)))
 }
-func condition(_ r: Reference) -> AST {
-  atom(.condition(r))
+func condition(_ r: AST.Atom.Reference.Kind) -> AST {
+  atom(.condition(.init(r, innerLoc: .fake)))
 }
 
 func prop(