Allow passing ParseOptions to inline tests

The changes here are based on the similar behavior in biome's
[`collect_tests`](https://github.com/biomejs/biome/blob/b9f8ffea9967b098ec4c8bf74fa96826a879f043/xtask/codegen/src/parser_tests.rs#L159)
function, which allows a syntax for inline test headers like

```
label language name [options]
```

Before this PR, we only allowed `label name`, where `label` is either `test_err`
or `test_ok`. This PR adds support for an optional, trailing `options` field,
corresponding to JSON-serialized `ParseOptions`. These get written to a
`*.options.json` file alongside the inline test script and read when that test
is run.

This is currently stacked on #16090 so that I had something to test.

Author: ntBre

Cargo.lock

@@ -13,7 +13,7 @@ license = { workspace = true }
 [lib]
 
 [dependencies]
-ruff_python_ast = { workspace = true }
+ruff_python_ast = { workspace = true, features = ["serde"] }
 ruff_python_trivia = { workspace = true }
 ruff_text_size = { workspace = true }
 
@@ -22,6 +22,7 @@ bstr = { workspace = true }
 compact_str = { workspace = true }
 memchr = { workspace = true }
 rustc-hash = { workspace = true }
+serde = { workspace = true }
 static_assertions = { workspace = true }
 unicode-ident = { workspace = true }
 unicode_names2 = { workspace = true }
@@ -33,6 +34,7 @@ ruff_source_file = { workspace = true }
 
 anyhow = { workspace = true }
 insta = { workspace = true, features = ["glob"] }
+serde_json = { workspace = true }
 walkdir = { workspace = true }
 
 [lints]

crates/ruff_python_parser/Cargo.toml

@@ -0,0 +1 @@
+{ "target_version": "3.9" }

crates/ruff_python_parser/resources/inline/err/match_before_py310.options.json

@@ -0,0 +1,3 @@
+match 2:
+    case 1:
+        pass

crates/ruff_python_parser/resources/inline/err/match_before_py310.py

@@ -0,0 +1 @@
+{ "target_version": "3.10" }

crates/ruff_python_parser/resources/inline/ok/match_after_py310.options.json

@@ -0,0 +1,3 @@
+match 2:
+    case 1:
+        pass

crates/ruff_python_parser/resources/inline/ok/match_after_py310.py

@@ -660,7 +660,8 @@ impl FusedIterator for TokenIterWithContext<'_> {}
 /// Control in the different modes by which a source file can be parsed.
 ///
 /// The mode argument specifies in what way code must be parsed.
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
 pub enum Mode {
     /// The code consists of a sequence of statements.
     Module,

crates/ruff_python_parser/src/lib.rs

@@ -20,11 +20,13 @@ use crate::{AsMode, Mode};
 ///
 /// let options = ParseOptions::from(PySourceType::Python);
 /// ```
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Deserialize)]
 pub struct ParseOptions {
     /// Specify the mode in which the code will be parsed.
+    #[serde(default = "default_mode")]
     pub(crate) mode: Mode,
     /// Target version for detecting version-related syntax errors.
+    #[serde(default)]
     pub(crate) target_version: PythonVersion,
 }
 
@@ -53,3 +55,7 @@ impl From<PySourceType> for ParseOptions {
         }
     }
 }
+
+fn default_mode() -> Mode {
+    Mode::Module
+}

crates/ruff_python_parser/src/parser/options.rs

@@ -2265,6 +2265,16 @@ impl<'src> Parser<'src> {
 
         let cases = self.parse_match_body();
 
+        // test_err match_before_py310 { "target_version": "3.9" }
+        // match 2:
+        //     case 1:
+        //         pass
+
+        // test_ok match_after_py310 { "target_version": "3.10" }
+        // match 2:
+        //     case 1:
+        //         pass
+
         if self.options.target_version < PythonVersion::PY310 {
             self.unsupported_syntax_errors.push(UnsupportedSyntaxError {
                 kind: UnsupportedSyntaxErrorKind::MatchBeforePy310,

crates/ruff_python_parser/src/parser/statement.rs

@@ -5,7 +5,7 @@ use std::path::Path;
 
 use ruff_annotate_snippets::{Level, Renderer, Snippet};
 use ruff_python_ast::visitor::source_order::{walk_module, SourceOrderVisitor, TraversalSignal};
-use ruff_python_ast::{AnyNodeRef, Mod};
+use ruff_python_ast::{AnyNodeRef, Mod, PythonVersion};
 use ruff_python_parser::{parse_unchecked, Mode, ParseErrorType, ParseOptions, Token};
 use ruff_source_file::{LineIndex, OneIndexed, SourceCode};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
@@ -33,8 +33,13 @@ fn inline_err() {
 /// Asserts that the parser generates no syntax errors for a valid program.
 /// Snapshots the AST.
 fn test_valid_syntax(input_path: &Path) {
+    let options_path = input_path.with_extension("options.json");
+    let options = fs::read_to_string(options_path)
+        .ok()
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_else(|| ParseOptions::from(Mode::Module));
     let source = fs::read_to_string(input_path).expect("Expected test file to exist");
-    let parsed = parse_unchecked(&source, ParseOptions::from(Mode::Module));
+    let parsed = parse_unchecked(&source, options);
 
     if !parsed.is_valid() {
         let line_index = LineIndex::from_source_text(&source);
@@ -77,11 +82,20 @@ fn test_valid_syntax(input_path: &Path) {
 /// Assert that the parser generates at least one syntax error for the given input file.
 /// Snapshots the AST and the error messages.
 fn test_invalid_syntax(input_path: &Path) {
+    let options_path = input_path.with_extension("options.json");
+    let options = fs::read_to_string(options_path)
+        .ok()
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_else(|| {
+            ParseOptions::from(Mode::Module).with_target_version(PythonVersion::PY313)
+        });
     let source = fs::read_to_string(input_path).expect("Expected test file to exist");
-    let parsed = parse_unchecked(&source, ParseOptions::from(Mode::Module));
+    let parsed = parse_unchecked(&source, options);
+
+    let is_valid = parsed.is_valid() && parsed.unsupported_syntax_errors().is_empty();
 
     assert!(
-        !parsed.is_valid(),
+        !is_valid,
         "{input_path:?}: Expected parser to generate at least one syntax error for a program containing syntax errors."
     );
 
@@ -110,6 +124,23 @@ fn test_invalid_syntax(input_path: &Path) {
         .unwrap();
     }
 
+    if !parsed.unsupported_syntax_errors().is_empty() {
+        writeln!(&mut output, "## Unsupported Syntax Errors\n").unwrap();
+    }
+
+    for error in parsed.unsupported_syntax_errors() {
+        writeln!(
+            &mut output,
+            "{}\n",
+            CodeFrame {
+                range: error.range,
+                error: &ParseErrorType::OtherError(error.to_string()),
+                source_code: &source_code,
+            }
+        )
+        .unwrap();
+    }
+
     insta::with_settings!({
         omit_expression => true,
         input_file => input_path,