Track source location for character class range character

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/CustomCharClass.swift

@@ -21,14 +21,25 @@ extension AST {
       case custom(CustomCharacterClass)
 
       /// A character range `a-z`
-      case range(Atom, Atom)
+      case range(Range)
 
       /// A single character or escape
       case atom(Atom)
 
       /// A binary operator applied to sets of members `abc&&def`
       case setOperation([Member], Located<SetOp>, [Member])
     }
+    public struct Range: Hashable {
+      public var lhs: Atom
+      public var dashLoc: SourceLocation
+      public var rhs: Atom
+
+      public init(_ lhs: Atom, _ dashLoc: SourceLocation, _ rhs: Atom) {
+        self.lhs = lhs
+        self.dashLoc = dashLoc
+        self.rhs = rhs
+      }
+    }
     public enum SetOp: String, Hashable {
       case subtraction = "--"
       case intersection = "&&"
@@ -45,3 +56,18 @@ extension AST {
 extension AST.CustomCharacterClass {
   public var isInverted: Bool { start.value == .inverted }
 }
+
+extension CustomCC.Member {
+  private var _associatedValue: Any {
+    switch self {
+    case .custom(let c): return c
+    case .range(let r): return r
+    case .atom(let a): return a
+    case .setOperation(let lhs, let op, let rhs): return (lhs, op, rhs)
+    }
+  }
+
+  func `as`<T>(_ t: T.Type = T.self) -> T? {
+    _associatedValue as? T
+  }
+}

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -1026,14 +1026,19 @@ extension Source {
   /// of a '-' character followed by an atom.
   mutating func lexCustomCharClassRangeEnd(
     priorGroupCount: Int
-  ) throws -> AST.Atom? {
+  ) 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).
+    let start = currentPosition
     guard peekCCBinOp() == nil && !starts(with: "-]") && tryEat("-") else {
       return nil
     }
-    return try lexAtom(isInCustomCharacterClass: true,
-                       priorGroupCount: priorGroupCount)
+    let dashLoc = Location(start ..< currentPosition)
+    guard let end = try lexAtom(isInCustomCharacterClass: true,
+                                priorGroupCount: priorGroupCount) else {
+      return nil
+    }
+    return (dashLoc, end)
   }
 }
 

Sources/_MatchingEngine/Regex/Parse/Parse.swift

@@ -269,14 +269,14 @@ extension Parser {
       else { break }
 
       // Range between atoms.
-      if let rhs = try source.lexCustomCharClassRangeEnd(
+      if let (dashLoc, rhs) = try source.lexCustomCharClassRangeEnd(
         priorGroupCount: priorGroupCount
       ) {
         guard atom.literalCharacterValue != nil &&
               rhs.literalCharacterValue != nil else {
           throw ParseError.invalidCharacterClassRangeOperand
         }
-        members.append(.range(atom, rhs))
+        members.append(.range(.init(atom, dashLoc, rhs)))
         continue
       }
 

Sources/_MatchingEngine/Regex/Printing/DumpAST.swift

@@ -185,10 +185,15 @@ extension AST.CustomCharacterClass.Member: _ASTPrintable {
     switch self {
     case .custom(let cc): return "\(cc)"
     case .atom(let a): return "\(a)"
-    case .range(let lhs, let rhs):
-      return "range \(lhs) to \(rhs)"
+    case .range(let r): return "\(r)"
     case .setOperation(let lhs, let op, let rhs):
       return "op \(lhs) \(op.value) \(rhs)"
     }
   }
 }
+
+extension AST.CustomCharacterClass.Range: _ASTPrintable {
+  public var _dumpBase: String {
+    "\(lhs)-\(rhs)"
+  }
+}

Sources/_MatchingEngine/Regex/Printing/PrintAsCanonical.swift

@@ -85,10 +85,10 @@ extension PrettyPrinter {
     switch member {
     case .custom(let ccc):
       outputAsCanonical(ccc)
-    case .range(let a, let b):
-      output(a._canonicalBase)
+    case .range(let r):
+      output(r.lhs._canonicalBase)
       output("-")
-      output(b._canonicalBase)
+      output(r.rhs._canonicalBase)
     case .atom(let a):
       output(a._canonicalBase)
     case .setOperation:

Sources/_MatchingEngine/Regex/Printing/PrintAsPattern.swift

@@ -139,16 +139,16 @@ extension PrettyPrinter {
     switch member {
     case .custom(let ccc):
       printAsPattern(ccc)
-    case .range(let a, let b):
-      if let lhs = a.literalStringValue,
-         let rhs = b.literalStringValue {
+    case .range(let r):
+      if let lhs = r.lhs.literalStringValue,
+         let rhs = r.rhs.literalStringValue {
         indent()
         output(lhs._quoted)
         output("...")
         output(rhs._quoted)
         terminateLine()
       } else {
-        print("// TODO: Range \(a) to \(b)")
+        print("// TODO: Range \(r.lhs) to \(r.rhs)")
       }
     case .atom(let a):
       if let s = a.literalStringValue {

Sources/_StringProcessing/ASTBuilder.swift

@@ -263,9 +263,13 @@ func prop_m(
 ) -> AST.CustomCharacterClass.Member {
   atom_m(.property(.init(kind, isInverted: inverted, isPOSIX: false)))
 }
+func range_m(
+  _ lower: AST.Atom, _ upper: AST.Atom
+) -> AST.CustomCharacterClass.Member {
+  .range(.init(lower, .fake, upper))
+}
 func range_m(
   _ lower: AST.Atom.Kind, _ upper: AST.Atom.Kind
 ) -> AST.CustomCharacterClass.Member {
-  .range(atom_a(lower), atom_a(upper))
+  range_m(atom_a(lower), atom_a(upper))
 }
-

Sources/_StringProcessing/CharacterClass.swift

@@ -384,10 +384,10 @@ extension AST.CustomCharacterClass {
             return nil
           }
           result.append(.characterClass(cc))
-        case .range(let lhs, let rhs):
+        case .range(let r):
           result.append(.range(
-            lhs.literalCharacterValue! ...
-            rhs.literalCharacterValue!))
+            r.lhs.literalCharacterValue! ...
+            r.rhs.literalCharacterValue!))
 
         case .atom(let a):
           if let cc = a.characterClass {

Sources/_StringProcessing/ConsumerInterface.swift

@@ -117,12 +117,12 @@ extension AST.CustomCharacterClass.Member {
     case .custom(let ccc):
       return try ccc.generateConsumer(opts)
 
-    case .range(let lower, let upper):
-      guard let lhs = lower.literalCharacterValue else {
-        throw unsupported("\(lower) in range")
+    case .range(let r):
+      guard let lhs = r.lhs.literalCharacterValue else {
+        throw unsupported("\(r.lhs) in range")
       }
-      guard let rhs = upper.literalCharacterValue else {
-        throw unsupported("\(upper) in range")
+      guard let rhs = r.rhs.literalCharacterValue else {
+        throw unsupported("\(r.rhs) in range")
       }
 
       return { input, bounds in

Tests/RegexTests/ParseTests.swift

@@ -278,18 +278,18 @@ extension RegexTests {
       "[-|$^:?+*())(*-+-]",
       charClass(
         "-", "|", "$", "^", ":", "?", "+", "*", "(", ")", ")",
-        "(", .range("*", "+"), "-"))
+        "(", range_m("*", "+"), "-"))
 
     parseTest(
-      "[a-b-c]", charClass(.range("a", "b"), "-", "c"))
+      "[a-b-c]", charClass(range_m("a", "b"), "-", "c"))
 
     parseTest("[-a-]", charClass("-", "a", "-"))
 
-    parseTest("[a-z]", charClass(.range("a", "z")))
+    parseTest("[a-z]", charClass(range_m("a", "z")))
 
     // FIXME: AST builder helpers for custom char class types
     parseTest("[a-d--a-c]", charClass(
-      .setOperation([.range("a", "d")], .init(faking: .subtraction), [.range("a", "c")])
+      .setOperation([range_m("a", "d")], .init(faking: .subtraction), [range_m("a", "c")])
     ))
 
     parseTest("[-]", charClass("-"))
@@ -933,6 +933,12 @@ extension RegexTests {
     rangeTest("a|", range(1 ..< 2), at: { $0.as(Alt.self)!.pipes[0] })
     rangeTest("a|b", range(1 ..< 2), at: { $0.as(Alt.self)!.pipes[0] })
     rangeTest("|||", range(1 ..< 2), at: { $0.as(Alt.self)!.pipes[1] })
+
+    // MARK: Custom character classes
+
+    rangeTest("[a-z]", range(2 ..< 3), at: {
+      $0.as(CustomCC.self)!.members[0].as(CustomCC.Range.self)!.dashLoc
+    })
   }
 
   func testParseErrors() {