Upgrade RustPython

Cargo.toml

@@ -34,11 +34,11 @@ proc-macro2 = { version = "1.0.51" }
 quote = { version = "1.0.23" }
 regex = { version = "1.7.1" }
 rustc-hash = { version = "1.1.0" }
-ruff_text_size = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "335780aeeac1e6fcd85994ba001d7b8ce99fcf65" }
-rustpython-ast = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "335780aeeac1e6fcd85994ba001d7b8ce99fcf65", default-features = false, features = ["all-nodes-with-ranges"]}
-rustpython-format = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "335780aeeac1e6fcd85994ba001d7b8ce99fcf65" }
-rustpython-literal = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "335780aeeac1e6fcd85994ba001d7b8ce99fcf65" }
-rustpython-parser = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "335780aeeac1e6fcd85994ba001d7b8ce99fcf65", default-features = false, features = ["full-lexer", "all-nodes-with-ranges"] }
+ruff_text_size = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "7a3eedbf6fb4ea7068a1bf7fe0e97e963ea95ffd" }
+rustpython-ast = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "7a3eedbf6fb4ea7068a1bf7fe0e97e963ea95ffd", default-features = false, features = ["all-nodes-with-ranges"]}
+rustpython-format = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "7a3eedbf6fb4ea7068a1bf7fe0e97e963ea95ffd" }
+rustpython-literal = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "7a3eedbf6fb4ea7068a1bf7fe0e97e963ea95ffd" }
+rustpython-parser = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "7a3eedbf6fb4ea7068a1bf7fe0e97e963ea95ffd", default-features = false, features = ["full-lexer", "all-nodes-with-ranges"] }
 schemars = { version = "0.8.12" }
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.93", features = ["preserve_order"] }

crates/ruff/src/autofix/actions.rs

@@ -424,7 +424,8 @@ pub(crate) fn remove_argument(
 mod tests {
     use anyhow::Result;
     use ruff_text_size::TextSize;
-    use rustpython_parser as parser;
+    use rustpython_parser::ast::Suite;
+    use rustpython_parser::Parse;
 
     use ruff_python_ast::source_code::Locator;
 
@@ -433,19 +434,19 @@ mod tests {
     #[test]
     fn find_semicolon() -> Result<()> {
         let contents = "x = 1";
-        let program = parser::parse_program(contents, "<filename>")?;
+        let program = Suite::parse(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(trailing_semicolon(stmt, &locator), None);
 
         let contents = "x = 1; y = 1";
-        let program = parser::parse_program(contents, "<filename>")?;
+        let program = Suite::parse(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(5)));
 
         let contents = "x = 1 ; y = 1";
-        let program = parser::parse_program(contents, "<filename>")?;
+        let program = Suite::parse(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(6)));
@@ -455,7 +456,7 @@ x = 1 \
   ; y = 1
 "#
         .trim();
-        let program = parser::parse_program(contents, "<filename>")?;
+        let program = Suite::parse(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(10)));

crates/ruff/src/importer/insertion.rs

@@ -139,16 +139,17 @@ fn match_docstring_end(body: &[Stmt]) -> Option<TextSize> {
 mod tests {
     use anyhow::Result;
     use ruff_text_size::TextSize;
-    use rustpython_parser as parser;
+    use rustpython_parser::ast::Suite;
     use rustpython_parser::lexer::LexResult;
+    use rustpython_parser::Parse;
 
     use ruff_python_ast::newlines::LineEnding;
     use ruff_python_ast::source_code::{Locator, Stylist};
 
     use super::Insertion;
 
     fn insert(contents: &str) -> Result<Insertion> {
-        let program = parser::parse_program(contents, "<filename>")?;
+        let program = Suite::parse(contents, "<filename>")?;
         let tokens: Vec<LexResult> = ruff_rustpython::tokenize(contents);
         let locator = Locator::new(contents);
         let stylist = Stylist::from_tokens(&tokens, &locator);

crates/ruff/src/rules/eradicate/detection.rs

@@ -1,7 +1,8 @@
 /// See: [eradicate.py](https://github.com/myint/eradicate/blob/98f199940979c94447a461d50d27862b118b282d/eradicate.py)
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_parser as parser;
+use rustpython_parser::ast::Suite;
+use rustpython_parser::Parse;
 
 static ALLOWLIST_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
@@ -78,7 +79,7 @@ pub(crate) fn comment_contains_code(line: &str, task_tags: &[String]) -> bool {
     }
 
     // Finally, compile the source code.
-    parser::parse_program(&line, "<filename>").is_ok()
+    Suite::parse(&line, "<filename>").is_ok()
 }
 
 /// Returns `true` if a line is probably part of some multiline code.

crates/ruff/src/rules/isort/rules/add_required_imports.rs

@@ -1,7 +1,7 @@
 use log::error;
 use ruff_text_size::{TextRange, TextSize};
-use rustpython_parser as parser;
 use rustpython_parser::ast::{self, Stmt, Suite};
+use rustpython_parser::Parse;
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
@@ -140,7 +140,7 @@ pub(crate) fn add_required_imports(
         .required_imports
         .iter()
         .flat_map(|required_import| {
-            let Ok(body) = parser::parse_program(required_import, "<filename>") else {
+            let Ok(body) = Suite::parse(required_import, "<filename>") else {
                 error!("Failed to parse required import: `{}`", required_import);
                 return vec![];
             };

crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs

@@ -162,7 +162,8 @@ pub(crate) fn function_is_too_complex(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rustpython_parser as parser;
+    use rustpython_parser::ast::Suite;
+    use rustpython_parser::Parse;
 
     use super::get_complexity_number;
 
@@ -172,7 +173,7 @@ mod tests {
 def trivial():
     pass
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -183,7 +184,7 @@ def trivial():
 def expr_as_statement():
     0xF00D
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -196,7 +197,7 @@ def sequential(n):
     s = k + n
     return s
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -212,7 +213,7 @@ def if_elif_else_dead_path(n):
     else:
         return "smaller than or equal to three"
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 3);
         Ok(())
     }
@@ -229,7 +230,7 @@ def nested_ifs():
     else:
         return "smaller than or equal to three"
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 3);
         Ok(())
     }
@@ -241,7 +242,7 @@ def for_loop():
     for i in range(10):
         print(i)
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 2);
         Ok(())
     }
@@ -255,7 +256,7 @@ def for_else(mylist):
     else:
         print(None)
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 2);
         Ok(())
     }
@@ -269,7 +270,7 @@ def recursive(n):
     else:
         return n
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 2);
         Ok(())
     }
@@ -286,7 +287,7 @@ def nested_functions():
 
     a()
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 3);
         Ok(())
     }
@@ -304,7 +305,7 @@ def try_else():
     else:
         print(4)
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 4);
         Ok(())
     }
@@ -321,7 +322,7 @@ def nested_try_finally():
     finally:
         print(3)
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -338,7 +339,7 @@ async def foobar(a, b, c):
     async for x in a:
         pass
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 3);
         Ok(())
     }
@@ -349,7 +350,7 @@ async def foobar(a, b, c):
 def annotated_assign():
     x: Any = None
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -385,7 +386,7 @@ class Class:
 
         return ServiceProvider(Logger())
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 9);
         Ok(())
     }
@@ -399,7 +400,7 @@ def process_detect_lines():
     finally:
         pass
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 1);
         Ok(())
     }
@@ -414,7 +415,7 @@ def process_detect_lines():
         if res:
             errors.append(f"Non-zero exit code {res}")
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 2);
         Ok(())
     }
@@ -427,7 +428,7 @@ def with_lock():
         if foo:
             print('bar')
 "#;
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(get_complexity_number(&stmts), 2);
         Ok(())
     }

crates/ruff/src/rules/pylint/rules/too_many_branches.rs

@@ -185,12 +185,13 @@ pub(crate) fn too_many_branches(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rustpython_parser as parser;
+    use rustpython_parser::ast::Suite;
+    use rustpython_parser::Parse;
 
     use super::num_branches;
 
     fn test_helper(source: &str, expected_num_branches: usize) -> Result<()> {
-        let branches = parser::parse_program(source, "<filename>")?;
+        let branches = Suite::parse(source, "<filename>")?;
         assert_eq!(num_branches(&branches), expected_num_branches);
         Ok(())
     }

crates/ruff/src/rules/pylint/rules/too_many_return_statements.rs

@@ -99,12 +99,13 @@ pub(crate) fn too_many_return_statements(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rustpython_parser as parser;
+    use rustpython_parser::ast::Suite;
+    use rustpython_parser::Parse;
 
     use super::num_returns;
 
     fn test_helper(source: &str, expected: usize) -> Result<()> {
-        let stmts = parser::parse_program(source, "<filename>")?;
+        let stmts = Suite::parse(source, "<filename>")?;
         assert_eq!(num_returns(&stmts), expected);
         Ok(())
     }