Convert diagnostic tests into parse tests

Match against the parser output rather than unit
testing the lexer, as it is more convenient and
allows us to test a better range of error cases.

Author: hamishknight

Tests/RegexTests/LexTests.swift

@@ -40,13 +40,6 @@ func diagnose(
   }
 }
 
-extension Source {
-  @discardableResult
-  fileprivate mutating func lexBasicAtom() throws -> AST.Atom? {
-    try lexAtom(isInCustomCharacterClass: false, priorGroupCount: 0)
-  }
-}
-
 extension RegexTests {
   func testLexicalAnalysis() {
     diagnose("a", expecting: .expected("b")) { src in
@@ -101,73 +94,6 @@ extension RegexTests {
     diagnoseUniScalarOverflow("{123456789}", base: "u")
     diagnoseUniScalarOverflow("{123456789}", base: "x")
 
-    // Text segment options
-    diagnose("(?-y{g})", expecting: .cannotRemoveTextSegmentOptions) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose("(?-y{w})", expecting: .cannotRemoveTextSegmentOptions) {
-      _ = try $0.lexGroupStart()
-    }
-
-    // Test expected group.
-    diagnose(#"(*"#, expecting: .misc("Quantifier '*' must follow operand")) {
-      _ = try $0.lexGroupStart()
-    }
-
-    // Test expected closing delimiters.
-    diagnose(#"\u{5"#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"\x{5"#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"\N{A"#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"\N{U+A"#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"\p{a"#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"\p{a="#, expecting: .expected("}")) { try $0.lexBasicAtom() }
-    diagnose(#"(?#"#, expecting: .expected(")")) { _ = try $0.lexComment() }
-    diagnose(#"(?x"#, expecting: .expected(")")) { _ = try $0.lexGroupStart() }
-
-    diagnose(#"(?"#, expecting: .expectedGroupSpecifier) {
-      _ = try $0.lexGroupStart()
-    }
-
-    diagnose(#"(?^"#, expecting: .expected(")")) { _ = try $0.lexGroupStart() }
-    diagnose(#"(?^i"#, expecting: .expected(")")) { _ = try $0.lexGroupStart() }
-
-    diagnose(#"(?^-"#, expecting: .cannotRemoveMatchingOptionsAfterCaret) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose(#"(?^-)"#, expecting: .cannotRemoveMatchingOptionsAfterCaret) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose(#"(?^i-"#, expecting: .cannotRemoveMatchingOptionsAfterCaret) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose(#"(?^i-m)"#, expecting: .cannotRemoveMatchingOptionsAfterCaret) {
-      _ = try $0.lexGroupStart()
-    }
-
-    diagnose(#"(?y)"#, expecting: .expected("{")) { _ = try $0.lexGroupStart() }
-    diagnose(#"(?y{)"#, expecting: .expected("g")) { _ = try $0.lexGroupStart() }
-    diagnose(#"(?y{g)"#, expecting: .expected("}")) { _ = try $0.lexGroupStart() }
-    diagnose(#"(?y{x})"#, expecting: .expected("g")) { _ = try $0.lexGroupStart() }
-
-    diagnose(#"(?k)"#, expecting: .unknownGroupKind("?k")) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose(#"(?P#)"#, expecting: .invalidMatchingOption("#")) {
-      _ = try $0.lexGroupStart()
-    }
-    diagnose(#"(?P"#, expecting: .expected(")")) { _ = try $0.lexGroupStart() }
-    diagnose(#"(?R"#, expecting: .expected(")")) { _ = try $0.lexBasicAtom() }
-
-    diagnose(#"\Qab"#, expecting: .expected("\\E")) { _ = try $0.lexQuote() }
-    diagnose(#"\Qab\"#, expecting: .expected("\\E")) { _ = try $0.lexQuote() }
-    diagnose(#""ab"#, expecting: .expected("\""), .experimental) { _ = try $0.lexQuote() }
-    diagnose(#""ab\""#, expecting: .expected("\""), .experimental) { _ = try $0.lexQuote() }
-    diagnose(#""ab\"#, expecting: .unexpectedEndOfInput, .experimental) { _ = try $0.lexQuote() }
-
-    diagnose(#"\k''"#, expecting: .expectedNonEmptyContents) { _ = try $0.lexBasicAtom() }
-    diagnose(#"(?&)"#, expecting: .expectedNonEmptyContents) { _ = try $0.lexBasicAtom() }
-    diagnose(#"(?P>)"#, expecting: .expectedNonEmptyContents) { _ = try $0.lexBasicAtom() }
-
     // TODO: want to dummy print out source ranges, etc, test that.
   }
 

Tests/RegexTests/ParseTests.swift

@@ -155,6 +155,32 @@ func rangeTest(
   }
 }
 
+func diagnosticTest(
+  _ input: String, _ expected: ParseError,
+  syntax: SyntaxOptions = .traditional,
+  file: StaticString = #file, line: UInt = #line
+) {
+  do {
+    let ast = try parse(input, syntax)
+    XCTFail("""
+
+      Passed \(ast)
+      But expected error: \(expected)
+    """, file: file, line: line)
+  } catch let e as Source.LocatedError<ParseError> {
+    guard e.error == expected else {
+      XCTFail("""
+
+        Expected: \(expected)
+        Actual: \(e.error)
+      """, file: file, line: line)
+      return
+    }
+  } catch let e {
+    XCTFail("Error without source location: \(e)", file: file, line: line)
+  }
+}
+
 extension RegexTests {
   func testParse() {
     parseTest(
@@ -435,7 +461,7 @@ extension RegexTests {
 
     // Quotes in character classes.
     parseTest(#"[\Q-\E]"#, charClass(quote_m("-")))
-    parseTest(#"[\Qa-b[[*+\\E]"#, charClass(quote_m(#"a-b[[*+\"#)))
+    parseTest(#"[\Qa-b[[*+\\E]"#, charClass(quote_m("a-b[[*+\\")))
 
     parseTest(#"["-"]"#, charClass(quote_m("-")), syntax: .experimental)
     parseTest(#"["a-b[[*+\""]"#, charClass(quote_m(#"a-b[[*+""#)),
@@ -1038,17 +1064,59 @@ extension RegexTests {
   }
 
   func testParseErrors() {
+    // MARK: Closing delimiters.
 
-    func performErrorTest(_ input: String, _ expecting: String) {
-      //      // Quick pattern match against AST to extract error nodes
-      //      let ast = parse2(input)
-      //      print(ast)
-    }
+    diagnosticTest("(", .expected(")"))
 
-    performErrorTest("(", "")
+    diagnosticTest(#"\u{5"#, .expected("}"))
+    diagnosticTest(#"\x{5"#, .expected("}"))
+    diagnosticTest(#"\N{A"#, .expected("}"))
+    diagnosticTest(#"\N{U+A"#, .expected("}"))
+    diagnosticTest(#"\p{a"#, .expected("}"))
+    diagnosticTest(#"\p{a="#, .expected("}"))
+    diagnosticTest(#"(?#"#, .expected(")"))
+    diagnosticTest(#"(?x"#, .expected(")"))
 
+    diagnosticTest(#"(?"#, .expectedGroupSpecifier)
+    diagnosticTest(#"(?^"#, .expected(")"))
+    diagnosticTest(#"(?^i"#, .expected(")"))
 
-  }
+    diagnosticTest(#"(?y)"#, .expected("{"))
+    diagnosticTest(#"(?y{)"#, .expected("g"))
+    diagnosticTest(#"(?y{g)"#, .expected("}"))
+    diagnosticTest(#"(?y{x})"#, .expected("g"))
 
-}
+    diagnosticTest(#"(?P"#, .expected(")"))
+    diagnosticTest(#"(?R"#, .expected(")"))
 
+    diagnosticTest(#"\Qab"#, .expected("\\E"))
+    diagnosticTest("\\Qab\\", .expected("\\E"))
+    diagnosticTest(#""ab"#, .expected("\""), syntax: .experimental)
+    diagnosticTest(#""ab\""#, .expected("\""), syntax: .experimental)
+
+    // MARK: Text Segment options
+
+    diagnosticTest("(?-y{g})", .cannotRemoveTextSegmentOptions)
+    diagnosticTest("(?-y{w})", .cannotRemoveTextSegmentOptions)
+
+    // MARK: Group specifiers
+
+    diagnosticTest(#"(*"#, .misc("Quantifier '*' must follow operand"))
+
+    diagnosticTest(#"(?k)"#, .unknownGroupKind("?k"))
+    diagnosticTest(#"(?P#)"#, .invalidMatchingOption("#"))
+
+    // MARK: Matching options
+
+    diagnosticTest(#"(?^-"#, .cannotRemoveMatchingOptionsAfterCaret)
+    diagnosticTest(#"(?^-)"#, .cannotRemoveMatchingOptionsAfterCaret)
+    diagnosticTest(#"(?^i-"#, .cannotRemoveMatchingOptionsAfterCaret)
+    diagnosticTest(#"(?^i-m)"#, .cannotRemoveMatchingOptionsAfterCaret)
+
+    // MARK: Quotes
+
+    diagnosticTest(#"\k''"#, .expectedNonEmptyContents)
+    diagnosticTest(#"(?&)"#, .expectedNonEmptyContents)
+    diagnosticTest(#"(?P>)"#, .expectedNonEmptyContents)
+  }
+}