Merge #11120

11120: internal: move parser tests to parser crate r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -16,3 +16,5 @@ limit = { path = "../limit", version = "0.0.0" }
 
 [dev-dependencies]
 expect-test = "1.2"
+sourcegen = { path = "../sourcegen" }
+

crates/parser/Cargo.toml

@@ -463,13 +463,6 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     x.0.bar;
 //     x.0();
 // }
-
-// test_err bad_tuple_index_expr
-// fn foo() {
-//     x.0.;
-//     x.1i32;
-//     x.0x01;
-// }
 fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
     assert!(p.at(T![.]));
     let m = lhs.precede(p);

crates/parser/src/grammar/expressions.rs

@@ -1,3 +1,5 @@
+mod sourcegen_inline_tests;
+
 use std::{
     fmt::Write,
     fs,
@@ -9,15 +11,15 @@ use expect_test::expect_file;
 use crate::LexedStr;
 
 #[test]
-fn valid_lexes_input() {
+fn lex_ok() {
     for case in TestCase::list("lexer/ok") {
         let actual = lex(&case.text);
         expect_file![case.txt].assert_eq(&actual)
     }
 }
 
 #[test]
-fn invalid_lexes_input() {
+fn lex_err() {
     for case in TestCase::list("lexer/err") {
         let actual = lex(&case.text);
         expect_file![case.txt].assert_eq(&actual)
@@ -39,6 +41,79 @@ fn lex(text: &str) -> String {
     res
 }
 
+#[test]
+fn parse_ok() {
+    for case in TestCase::list("parser/ok") {
+        let (actual, errors) = parse(&case.text);
+        assert!(!errors, "errors in an OK file {}:\n{}", case.rs.display(), actual);
+        expect_file![case.txt].assert_eq(&actual);
+    }
+}
+
+#[test]
+fn parse_inline_ok() {
+    for case in TestCase::list("parser/inline/ok") {
+        let (actual, errors) = parse(&case.text);
+        assert!(!errors, "errors in an OK file {}:\n{}", case.rs.display(), actual);
+        expect_file![case.txt].assert_eq(&actual);
+    }
+}
+
+#[test]
+fn parse_err() {
+    for case in TestCase::list("parser/err") {
+        let (actual, errors) = parse(&case.text);
+        assert!(errors, "no errors in an ERR file {}:\n{}", case.rs.display(), actual);
+        expect_file![case.txt].assert_eq(&actual)
+    }
+}
+
+#[test]
+fn parse_inline_err() {
+    for case in TestCase::list("parser/inline/err") {
+        let (actual, errors) = parse(&case.text);
+        assert!(errors, "no errors in an ERR file {}:\n{}", case.rs.display(), actual);
+        expect_file![case.txt].assert_eq(&actual)
+    }
+}
+
+fn parse(text: &str) -> (String, bool) {
+    let lexed = LexedStr::new(text);
+    let input = lexed.to_input();
+    let output = crate::parse_source_file(&input);
+
+    let mut buf = String::new();
+    let mut errors = Vec::new();
+    let mut indent = String::new();
+    lexed.intersperse_trivia(&output, false, &mut |step| match step {
+        crate::StrStep::Token { kind, text } => {
+            write!(buf, "{}", indent).unwrap();
+            write!(buf, "{:?} {:?}\n", kind, text).unwrap();
+        }
+        crate::StrStep::Enter { kind } => {
+            write!(buf, "{}", indent).unwrap();
+            write!(buf, "{:?}\n", kind).unwrap();
+            indent.push_str("  ");
+        }
+        crate::StrStep::Exit => {
+            indent.pop();
+            indent.pop();
+        }
+        crate::StrStep::Error { msg, pos } => errors.push(format!("error {}: {}\n", pos, msg)),
+    });
+
+    for (token, msg) in lexed.errors() {
+        let pos = lexed.text_start(token);
+        errors.push(format!("error {}: {}\n", pos, msg));
+    }
+
+    let has_errors = !errors.is_empty();
+    for e in errors {
+        buf.push_str(&e);
+    }
+    (buf, has_errors)
+}
+
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 struct TestCase {
     rs: PathBuf,

crates/parser/src/tests.rs

@@ -2,21 +2,20 @@
 //! them into tests.
 
 use std::{
+    collections::HashMap,
     fs, iter,
     path::{Path, PathBuf},
 };
 
-use rustc_hash::FxHashMap;
-
 #[test]
 fn sourcegen_parser_tests() {
     let grammar_dir = sourcegen::project_root().join(Path::new("crates/parser/src/grammar"));
     let tests = tests_from_dir(&grammar_dir);
 
-    install_tests(&tests.ok, "crates/syntax/test_data/parser/inline/ok");
-    install_tests(&tests.err, "crates/syntax/test_data/parser/inline/err");
+    install_tests(&tests.ok, "crates/parser/test_data/parser/inline/ok");
+    install_tests(&tests.err, "crates/parser/test_data/parser/inline/err");
 
-    fn install_tests(tests: &FxHashMap<String, Test>, into: &str) {
+    fn install_tests(tests: &HashMap<String, Test>, into: &str) {
         let tests_dir = sourcegen::project_root().join(into);
         if !tests_dir.is_dir() {
             fs::create_dir_all(&tests_dir).unwrap();
@@ -51,8 +50,8 @@ struct Test {
 
 #[derive(Default, Debug)]
 struct Tests {
-    ok: FxHashMap<String, Test>,
-    err: FxHashMap<String, Test>,
+    ok: HashMap<String, Test>,
+    err: HashMap<String, Test>,
 }
 
 fn collect_tests(s: &str) -> Vec<Test> {
@@ -102,8 +101,8 @@ fn tests_from_dir(dir: &Path) -> Tests {
     }
 }
 
-fn existing_tests(dir: &Path, ok: bool) -> FxHashMap<String, (PathBuf, Test)> {
-    let mut res = FxHashMap::default();
+fn existing_tests(dir: &Path, ok: bool) -> HashMap<String, (PathBuf, Test)> {
+    let mut res = HashMap::default();
     for file in fs::read_dir(dir).unwrap() {
         let file = file.unwrap();
         let path = file.path();

crates/syntax/src/tests/sourcegen_tests.rs renamed to crates/parser/src/tests/sourcegen_inline_tests.rs

@@ -0,0 +1,34 @@
+SOURCE_FILE
+  STRUCT
+    STRUCT_KW "struct"
+    WHITESPACE " "
+    NAME
+      IDENT "S"
+    WHITESPACE " "
+    RECORD_FIELD_LIST
+      L_CURLY "{"
+      WHITESPACE "\n    "
+      RECORD_FIELD
+        NAME
+          IDENT "a"
+        COLON ":"
+        WHITESPACE " "
+        PATH_TYPE
+          PATH
+            PATH_SEGMENT
+              NAME_REF
+                IDENT "u32"
+      WHITESPACE "\n    "
+      RECORD_FIELD
+        NAME
+          IDENT "b"
+        COLON ":"
+        WHITESPACE " "
+        PATH_TYPE
+          PATH
+            PATH_SEGMENT
+              NAME_REF
+                IDENT "u32"
+      WHITESPACE "\n"
+      R_CURLY "}"
+error 21: expected COMMA