Allow passing ParseOptions to inline tests

crates/ruff_python_parser/Cargo.toml

@@ -22,6 +22,7 @@ bstr = { workspace = true }
 compact_str = { workspace = true }
 memchr = { workspace = true }
 rustc-hash = { workspace = true }
+serde = { workspace = true, optional = true }
 static_assertions = { workspace = true }
 unicode-ident = { workspace = true }
 unicode_names2 = { workspace = true }
@@ -33,7 +34,11 @@ ruff_source_file = { workspace = true }
 
 anyhow = { workspace = true }
 insta = { workspace = true, features = ["glob"] }
+serde_json = { workspace = true }
 walkdir = { workspace = true }
 
+[features]
+serde = ["dep:serde", "ruff_python_ast/serde"]
+
 [lints]
 workspace = true

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

@@ -0,0 +1,4 @@
+# parse_options: { "target_version": "3.9" }
+match 2:
+    case 1:
+        pass

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

@@ -0,0 +1,4 @@
+# parse_options: { "target_version": "3.10" }
+match 2:
+    case 1:
+        pass

crates/ruff_python_parser/src/lib.rs

@@ -661,6 +661,11 @@ impl FusedIterator for TokenIterWithContext<'_> {}
 ///
 /// The mode argument specifies in what way code must be parsed.
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Deserialize),
+    serde(rename_all = "lowercase")
+)]
 pub enum Mode {
     /// The code consists of a sequence of statements.
     Module,

crates/ruff_python_parser/src/parser/options.rs

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

crates/ruff_python_parser/src/parser/statement.rs

@@ -2265,6 +2265,18 @@ impl<'src> Parser<'src> {
 
         let cases = self.parse_match_body();
 
+        // test_err match_before_py310
+        // # parse_options: { "target_version": "3.9" }
+        // match 2:
+        //     case 1:
+        //         pass
+
+        // test_ok match_after_py310
+        // # parse_options: { "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/tests/fixtures.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};
@@ -34,9 +34,14 @@ fn inline_err() {
 /// Snapshots the AST.
 fn test_valid_syntax(input_path: &Path) {
     let source = fs::read_to_string(input_path).expect("Expected test file to exist");
-    let parsed = parse_unchecked(&source, ParseOptions::from(Mode::Module));
+    let options = extract_options(&source).unwrap_or_else(|| {
+        ParseOptions::from(Mode::Module).with_target_version(PythonVersion::latest())
+    });
+    let parsed = parse_unchecked(&source, options);
 
-    if !parsed.is_valid() {
+    let is_valid = parsed.is_valid() && parsed.unsupported_syntax_errors().is_empty();
+
+    if !is_valid {
         let line_index = LineIndex::from_source_text(&source);
         let source_code = SourceCode::new(&source, &line_index);
 
@@ -55,6 +60,19 @@ fn test_valid_syntax(input_path: &Path) {
             .unwrap();
         }
 
+        for error in parsed.unsupported_syntax_errors() {
+            writeln!(
+                &mut message,
+                "{}\n",
+                CodeFrame {
+                    range: error.range,
+                    error: &ParseErrorType::OtherError(error.to_string()),
+                    source_code: &source_code,
+                }
+            )
+            .unwrap();
+        }
+
         panic!("{input_path:?}: {message}");
     }
 
@@ -78,10 +96,15 @@ fn test_valid_syntax(input_path: &Path) {
 /// Snapshots the AST and the error messages.
 fn test_invalid_syntax(input_path: &Path) {
     let source = fs::read_to_string(input_path).expect("Expected test file to exist");
-    let parsed = parse_unchecked(&source, ParseOptions::from(Mode::Module));
+    let options = extract_options(&source).unwrap_or_else(|| {
+        ParseOptions::from(Mode::Module).with_target_version(PythonVersion::latest())
+    });
+    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."
     );
 
@@ -92,11 +115,13 @@ fn test_invalid_syntax(input_path: &Path) {
     writeln!(&mut output, "## AST").unwrap();
     writeln!(&mut output, "\n```\n{:#?}\n```", parsed.syntax()).unwrap();
 
-    writeln!(&mut output, "## Errors\n").unwrap();
-
     let line_index = LineIndex::from_source_text(&source);
     let source_code = SourceCode::new(&source, &line_index);
 
+    if !parsed.errors().is_empty() {
+        writeln!(&mut output, "## Errors\n").unwrap();
+    }
+
     for error in parsed.errors() {
         writeln!(
             &mut output,
@@ -110,6 +135,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,
@@ -119,6 +161,20 @@ fn test_invalid_syntax(input_path: &Path) {
     });
 }
 
+/// Extract [`ParseOptions`] from an initial pragma line, if present.
+///
+/// For example,
+///
+/// ```python
+/// # parse_options: { "target_version": "3.10" }
+/// def f(): ...
+fn extract_options(source: &str) -> Option<ParseOptions> {
+    // extract options from pragma on the first line
+    let header = source.lines().next()?;
+    let (_label, options) = header.split_once("# parse_options: ")?;
+    serde_json::from_str(options.trim()).ok()
+}
+
 // Test that is intentionally ignored by default.
 // Use it for quickly debugging a parser issue.
 #[test]

crates/ruff_python_parser/tests/snapshots/invalid_syntax@match_before_py310.py.snap

@@ -0,0 +1,63 @@
+---
+source: crates/ruff_python_parser/tests/fixtures.rs
+input_file: crates/ruff_python_parser/resources/inline/err/match_before_py310.py
+---
+## AST
+
+```
+Module(
+    ModModule {
+        range: 0..79,
+        body: [
+            Match(
+                StmtMatch {
+                    range: 45..78,
+                    subject: NumberLiteral(
+                        ExprNumberLiteral {
+                            range: 51..52,
+                            value: Int(
+                                2,
+                            ),
+                        },
+                    ),
+                    cases: [
+                        MatchCase {
+                            range: 58..78,
+                            pattern: MatchValue(
+                                PatternMatchValue {
+                                    range: 63..64,
+                                    value: NumberLiteral(
+                                        ExprNumberLiteral {
+                                            range: 63..64,
+                                            value: Int(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                },
+                            ),
+                            guard: None,
+                            body: [
+                                Pass(
+                                    StmtPass {
+                                        range: 74..78,
+                                    },
+                                ),
+                            ],
+                        },
+                    ],
+                },
+            ),
+        ],
+    },
+)
+```
+## Unsupported Syntax Errors
+
+  |
+1 | # parse_options: { "target_version": "3.9" }
+2 | match 2:
+  | ^^^^^ Syntax Error: Cannot use `match` statement on Python 3.9 (syntax was added in Python 3.10)
+3 |     case 1:
+4 |         pass
+  |

crates/ruff_python_parser/tests/snapshots/valid_syntax@match_after_py310.py.snap

@@ -0,0 +1,54 @@
+---
+source: crates/ruff_python_parser/tests/fixtures.rs
+input_file: crates/ruff_python_parser/resources/inline/ok/match_after_py310.py
+---
+## AST
+
+```
+Module(
+    ModModule {
+        range: 0..80,
+        body: [
+            Match(
+                StmtMatch {
+                    range: 46..79,
+                    subject: NumberLiteral(
+                        ExprNumberLiteral {
+                            range: 52..53,
+                            value: Int(
+                                2,
+                            ),
+                        },
+                    ),
+                    cases: [
+                        MatchCase {
+                            range: 59..79,
+                            pattern: MatchValue(
+                                PatternMatchValue {
+                                    range: 64..65,
+                                    value: NumberLiteral(
+                                        ExprNumberLiteral {
+                                            range: 64..65,
+                                            value: Int(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                },
+                            ),
+                            guard: None,
+                            body: [
+                                Pass(
+                                    StmtPass {
+                                        range: 75..79,
+                                    },
+                                ),
+                            ],
+                        },
+                    ],
+                },
+            ),
+        ],
+    },
+)
+```

crates/ruff_server/src/lint.rs

@@ -199,6 +199,22 @@ pub(crate) fn check(
             .flatten(),
     );
 
+    let lsp_diagnostics = lsp_diagnostics.chain(
+        show_syntax_errors
+            .then(|| {
+                parsed.unsupported_syntax_errors().iter().map(|error| {
+                    unsupported_syntax_error_to_lsp_diagnostic(
+                        error,
+                        &source_kind,
+                        locator.to_index(),
+                        encoding,
+                    )
+                })
+            })
+            .into_iter()
+            .flatten(),
+    );
+
     if let Some(notebook) = query.as_notebook() {
         for (index, diagnostic) in lsp_diagnostics {
             let Some(uri) = notebook.cell_uri_by_index(index) else {