Add some additional alternation test cases

Including a couple of test cases that make sure
we have correct source ranges for them, as a
later commit will change how we compute their
source range.

Author: hamishknight

Sources/_MatchingEngine/Utility/Misc_2.swift

@@ -93,6 +93,10 @@ extension Collection {
     distance(from: startIndex, to: i)
   }
 
+  public func offsets(of r: Range<Index>) -> Range<Int> {
+    offset(of: r.lowerBound) ..< offset(of: r.upperBound)
+  }
+
   public func convertByOffset<
     C: Collection
   >(_ range: Range<Index>, in c: C) -> Range<C.Index> {

Tests/RegexTests/MatchTests.swift

@@ -9,7 +9,9 @@ func matchTest(
   syntax: SyntaxOptions = .traditional,
   enableTracing: Bool = false,
   dumpAST: Bool = false,
-  xfail: Bool = false
+  xfail: Bool = false,
+  file: StaticString = #filePath,
+  line: UInt = #line
 ) {
   do {
     var consumer = try RegexConsumer<String>(parsing: regex)
@@ -22,13 +24,13 @@ func matchTest(
     }
 
     if xfail {
-      XCTAssertNotEqual(String(input[range]), match)
+      XCTAssertNotEqual(String(input[range]), match, file: file, line: line)
     } else {
-      XCTAssertEqual(String(input[range]), match)
+      XCTAssertEqual(String(input[range]), match, file: file, line: line)
     }
   } catch {
     if !xfail {
-      XCTFail("\(error)")
+      XCTFail("\(error)", file: file, line: line)
     }
     return
   }
@@ -64,6 +66,14 @@ extension RegexTests {
       #"abc\+d*"#, input: "123abc+dddxyz", match: "abc+ddd")
     matchTest(
       "a(b)", input: "123abcxyz", match: "ab")
+
+    matchTest(
+      "(.)*(.*)", input: "123abcxyz", match: "123abcxyz")
+    matchTest(
+      #"abc\d"#, input: "xyzabc123", match: "abc1")
+
+    // MARK: Alternations
+
     matchTest(
       "abc(?:de)+fghi*k|j", input: "123abcdefghijxyz", match: "j")
     matchTest(
@@ -84,10 +94,25 @@ extension RegexTests {
       "a|b?c", input: "123bcxyz", match: "bc")
     matchTest(
       "(a|b)c", input: "123abcxyz", match: "bc")
-    matchTest(
-      "(.)*(.*)", input: "123abcxyz", match: "123abcxyz")
-    matchTest(
-      #"abc\d"#, input: "xyzabc123", match: "abc1")
+
+    // Alternations with empty branches are permitted.
+    matchTest("|", input: "ab", match: "")
+    matchTest("(|)", input: "ab", match: "")
+    matchTest("a|", input: "ab", match: "a")
+    matchTest("a|", input: "ba", match: "")
+    matchTest("|b", input: "ab", match: "")
+    matchTest("|b", input: "ba", match: "")
+    matchTest("|b|", input: "ab", match: "")
+    matchTest("|b|", input: "ba", match: "")
+    matchTest("a|b|", input: "ab", match: "a")
+    matchTest("a|b|", input: "ba", match: "b")
+    matchTest("a|b|", input: "ca", match: "")
+    matchTest("||c|", input: "ab", match: "")
+    matchTest("||c|", input: "cb", match: "")
+    matchTest("|||", input: "ab", match: "")
+    matchTest("a|||d", input: "bc", match: "")
+    matchTest("a|||d", input: "abc", match: "a")
+    matchTest("a|||d", input: "d", match: "")
 
     // MARK: Unicode scalars
 

Tests/RegexTests/ParseTests.swift

@@ -124,6 +124,26 @@ func parseNotEqualTest(
   }
 }
 
+func rangeTest(
+  _ input: String, syntax: SyntaxOptions = .traditional,
+  _ expectedRange: (String) -> Range<Int>,
+  at locFn: (AST) -> SourceLocation = \.location,
+  file: StaticString = #file, line: UInt = #line
+) {
+  let ast = try! parse(input, syntax)
+  let range = input.offsets(of: locFn(ast).range)
+  let expected = expectedRange(input)
+
+  guard range == expected else {
+    XCTFail("""
+            Expected range: "\(expected)"
+            Found range: "\(range)"
+            """,
+            file: file, line: line)
+    return
+  }
+}
+
 extension RegexTests {
   func testParse() {
     parseTest(
@@ -153,6 +173,27 @@ extension RegexTests {
         zeroOrOne(.eager, "a"), zeroOrOne(.reluctant, "b"),
         oneOrMore(.eager, "c"), oneOrMore(.reluctant, "d"),
         zeroOrMore(.eager, "e"), zeroOrMore(.reluctant, "f")))
+
+    parseTest(
+      "(.)*(.*)",
+      concat(
+        zeroOrMore(.eager, capture(atom(.any))),
+        capture(zeroOrMore(.eager, atom(.any)))),
+      captures: .tuple([.array(.atom()), .atom()]))
+    parseTest(
+      "((.))*((.)?)",
+      concat(
+        zeroOrMore(.eager, capture(capture(atom(.any)))),
+        capture(zeroOrOne(.eager, capture(atom(.any))))),
+      captures: .tuple([
+        .array(.atom()), .array(.atom()), .atom(), .optional(.atom())
+      ]))
+    parseTest(
+      #"abc\d"#,
+      concat("a", "b", "c", escaped(.decimalDigit)))
+
+    // MARK: Alternations
+
     parseTest(
       "a|b?c",
       alt("a", concat(zeroOrOne(.eager, "b"), "c")))
@@ -182,23 +223,17 @@ extension RegexTests {
       "(a)|b|(c)d",
       alt(capture("a"), "b", concat(capture("c"), "d")),
       captures: .tuple([.optional(.atom()), .optional(.atom())]))
-    parseTest(
-      "(.)*(.*)",
-      concat(
-        zeroOrMore(.eager, capture(atom(.any))),
-        capture(zeroOrMore(.eager, atom(.any)))),
-      captures: .tuple([.array(.atom()), .atom()]))
-    parseTest(
-      "((.))*((.)?)",
-      concat(
-        zeroOrMore(.eager, capture(capture(atom(.any)))),
-        capture(zeroOrOne(.eager, capture(atom(.any))))),
-      captures: .tuple([
-        .array(.atom()), .array(.atom()), .atom(), .optional(.atom())
-      ]))
-    parseTest(
-      #"abc\d"#,
-      concat("a", "b", "c", escaped(.decimalDigit)))
+
+    // Alternations with empty branches are permitted.
+    parseTest("|", alt(empty(), empty()))
+    parseTest("(|)", capture(alt(empty(), empty())), captures: .atom())
+    parseTest("a|", alt("a", empty()))
+    parseTest("|b", alt(empty(), "b"))
+    parseTest("|b|", alt(empty(), "b", empty()))
+    parseTest("a|b|", alt("a", "b", empty()))
+    parseTest("||c|", alt(empty(), empty(), "c", empty()))
+    parseTest("|||", alt(empty(), empty(), empty(), empty()))
+    parseTest("a|||d", alt("a", empty(), empty(), "d"))
 
     // MARK: Unicode scalars
 
@@ -827,6 +862,10 @@ extension RegexTests {
     parseWithDelimitersTest("'/a b/'", concat("a", " ", "b"))
     parseWithDelimitersTest("'|a b|'", concat("a", "b"))
 
+    parseWithDelimitersTest("'|||'", alt(empty(), empty()))
+    parseWithDelimitersTest("'||||'", alt(empty(), empty(), empty()))
+    parseWithDelimitersTest("'|a||'", alt("a", empty()))
+
     // Make sure dumping output correctly reflects differences in AST.
     parseNotEqualTest(#"abc"#, #"abd"#)
 
@@ -857,9 +896,40 @@ extension RegexTests {
     parseNotEqualTest("(?i-s:)", ("(?i-m:)"))
     parseNotEqualTest("(?y{w}:)", ("(?y{g}:)"))
 
+    parseNotEqualTest("|", "||")
+    parseNotEqualTest("a|", "|")
+    parseNotEqualTest("a|b", "|")
+
     // TODO: failure tests
   }
 
+  func testParseSourceLocations() throws {
+    func entireRange(input: String) -> Range<Int> {
+      0 ..< input.count
+    }
+    func insetRange(by i: Int) -> (String) -> Range<Int> {
+      { i ..< $0.count - i }
+    }
+    func range(_ indices: Range<Int>) -> (String) -> Range<Int> {
+      { _ in indices }
+    }
+
+    // MARK: Alternations
+
+    typealias Alt = AST.Alternation
+
+    let alternations = [
+      "|", "a|", "|b", "a|b", "abc|def", "a|b|c|d", "a|b|", "|||", "a|||d",
+      "||c|"
+    ]
+
+    // Make sure we correctly compute source ranges for alternations.
+    for alt in alternations {
+      rangeTest(alt, entireRange)
+      rangeTest("(\(alt))", insetRange(by: 1), at: \.children![0].location)
+    }
+  }
+
   func testParseErrors() {
 
     func performErrorTest(_ input: String, _ expecting: String) {