pass ParseOptions::target_version in the linter

Author: ntBre

crates/ruff_linter/src/linter.rs

@@ -10,10 +10,10 @@ use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_notebook::Notebook;
-use ruff_python_ast::{ModModule, PySourceType};
+use ruff_python_ast::{ModModule, PySourceType, PythonVersion};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-use ruff_python_parser::{ParseError, Parsed, SyntaxError};
+use ruff_python_parser::{ParseError, ParseOptions, Parsed, SyntaxError};
 use ruff_source_file::SourceFileBuilder;
 use ruff_text_size::Ranged;
 
@@ -330,7 +330,8 @@ pub fn add_noqa_to_path(
     settings: &LinterSettings,
 ) -> Result<usize> {
     // Parse once.
-    let parsed = ruff_python_parser::parse_unchecked_source(source_kind.source_code(), source_type);
+    // TODO(brent) resolve_target_version(path) here
+    let parsed = parse_unchecked_source(source_kind, source_type, settings.target_version);
 
     // Map row and column locations to byte slices (lazily).
     let locator = Locator::new(source_kind.source_code());
@@ -388,7 +389,8 @@ pub fn lint_only(
     source_type: PySourceType,
     source: ParseSource,
 ) -> LinterResult {
-    let parsed = source.into_parsed(source_kind, source_type);
+    // TODO(brent) resolve_target_version(path) here
+    let parsed = source.into_parsed(source_kind, source_type, settings.target_version);
 
     // Map row and column locations to byte slices (lazily).
     let locator = Locator::new(source_kind.source_code());
@@ -496,8 +498,8 @@ pub fn lint_fix<'a>(
     // Continuously fix until the source code stabilizes.
     loop {
         // Parse once.
-        let parsed =
-            ruff_python_parser::parse_unchecked_source(transformed.source_code(), source_type);
+        // TODO(brent) resolve_target_version(path) here
+        let parsed = parse_unchecked_source(&transformed, source_type, settings.target_version);
 
         // Map row and column locations to byte slices (lazily).
         let locator = Locator::new(transformed.source_code());
@@ -683,16 +685,33 @@ pub enum ParseSource {
 impl ParseSource {
     /// Consumes the [`ParseSource`] and returns the parsed [`Parsed`], parsing the source code if
     /// necessary.
-    fn into_parsed(self, source_kind: &SourceKind, source_type: PySourceType) -> Parsed<ModModule> {
+    fn into_parsed(
+        self,
+        source_kind: &SourceKind,
+        source_type: PySourceType,
+        target_version: PythonVersion,
+    ) -> Parsed<ModModule> {
         match self {
-            ParseSource::None => {
-                ruff_python_parser::parse_unchecked_source(source_kind.source_code(), source_type)
-            }
+            ParseSource::None => parse_unchecked_source(source_kind, source_type, target_version),
             ParseSource::Precomputed(parsed) => parsed,
         }
     }
 }
 
+fn parse_unchecked_source(
+    source_kind: &SourceKind,
+    source_type: PySourceType,
+    target_version: PythonVersion,
+) -> Parsed<ModModule> {
+    let options = ParseOptions::from(source_type).with_target_version(target_version);
+    // SAFETY: Safe because `PySourceType` always parses to a `ModModule`. See
+    // `ruff_python_parser::parse_unchecked_source`. We use `parse_unchecked` (and thus
+    // have to unwrap) in order to pass the `PythonVersion` via `ParseOptions`.
+    ruff_python_parser::parse_unchecked(source_kind.source_code(), options)
+        .try_into_module()
+        .expect("PySourceType always parses into a module")
+}
+
 #[cfg(test)]
 mod tests {
     use std::path::Path;

crates/ruff_linter/src/rules/pyflakes/mod.rs

@@ -11,6 +11,7 @@ mod tests {
 
     use anyhow::Result;
     use regex::Regex;
+    use ruff_python_parser::ParseOptions;
     use rustc_hash::FxHashMap;
     use test_case::test_case;
 
@@ -744,8 +745,10 @@ mod tests {
         let source_type = PySourceType::default();
         let source_kind = SourceKind::Python(contents.to_string());
         let settings = LinterSettings::for_rules(Linter::Pyflakes.rules());
-        let parsed =
-            ruff_python_parser::parse_unchecked_source(source_kind.source_code(), source_type);
+        let options = ParseOptions::from(source_type).with_target_version(settings.target_version);
+        let parsed = ruff_python_parser::parse_unchecked(source_kind.source_code(), options)
+            .try_into_module()
+            .expect("PySourceType always parses into a module");
         let locator = Locator::new(&contents);
         let stylist = Stylist::from_tokens(parsed.tokens(), locator.contents());
         let indexer = Indexer::from_tokens(parsed.tokens(), locator.contents());

crates/ruff_linter/src/test.rs

@@ -16,7 +16,7 @@ use ruff_notebook::NotebookError;
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-use ruff_python_parser::ParseError;
+use ruff_python_parser::{ParseError, ParseOptions};
 use ruff_python_trivia::textwrap::dedent;
 use ruff_source_file::SourceFileBuilder;
 use ruff_text_size::Ranged;
@@ -110,7 +110,10 @@ pub(crate) fn test_contents<'a>(
     settings: &LinterSettings,
 ) -> (Vec<Message>, Cow<'a, SourceKind>) {
     let source_type = PySourceType::from(path);
-    let parsed = ruff_python_parser::parse_unchecked_source(source_kind.source_code(), source_type);
+    let options = ParseOptions::from(source_type).with_target_version(settings.target_version);
+    let parsed = ruff_python_parser::parse_unchecked(source_kind.source_code(), options.clone())
+        .try_into_module()
+        .expect("PySourceType always parses into a module");
     let locator = Locator::new(source_kind.source_code());
     let stylist = Stylist::from_tokens(parsed.tokens(), locator.contents());
     let indexer = Indexer::from_tokens(parsed.tokens(), locator.contents());
@@ -174,7 +177,9 @@ pub(crate) fn test_contents<'a>(
             transformed = Cow::Owned(transformed.updated(fixed_contents, &source_map));
 
             let parsed =
-                ruff_python_parser::parse_unchecked_source(transformed.source_code(), source_type);
+                ruff_python_parser::parse_unchecked(transformed.source_code(), options.clone())
+                    .try_into_module()
+                    .expect("PySourceType always parses into a module");
             let locator = Locator::new(transformed.source_code());
             let stylist = Stylist::from_tokens(parsed.tokens(), locator.contents());
             let indexer = Indexer::from_tokens(parsed.tokens(), locator.contents());