Remove parser dependency from ruff-python-ast (#6096)

Cargo.lock

@@ -1905,13 +1905,16 @@ dependencies = [
  "ruff_index",
  "ruff_macros",
  "ruff_python_ast",
+ "ruff_python_codegen",
+ "ruff_python_index",
+ "ruff_python_parser",
  "ruff_python_semantic",
  "ruff_python_stdlib",
  "ruff_python_trivia",
- "ruff_rustpython",
+ "ruff_source_file",
  "ruff_text_size",
- "ruff_textwrap",
  "rustc-hash",
+ "rustpython-ast",
  "rustpython-format",
  "rustpython-parser",
  "schemars",
@@ -1944,6 +1947,7 @@ dependencies = [
  "ruff",
  "ruff_python_ast",
  "ruff_python_formatter",
+ "rustpython-ast",
  "rustpython-parser",
  "serde",
  "serde_json",
@@ -1999,8 +2003,9 @@ dependencies = [
  "ruff_python_ast",
  "ruff_python_formatter",
  "ruff_python_stdlib",
+ "ruff_python_trivia",
+ "ruff_source_file",
  "ruff_text_size",
- "ruff_textwrap",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -2034,9 +2039,11 @@ dependencies = [
  "ruff_cli",
  "ruff_diagnostics",
  "ruff_formatter",
+ "ruff_python_codegen",
  "ruff_python_formatter",
  "ruff_python_stdlib",
- "ruff_textwrap",
+ "ruff_python_trivia",
+ "rustpython-ast",
  "rustpython-format",
  "rustpython-parser",
  "schemars",
@@ -2089,7 +2096,7 @@ dependencies = [
  "itertools",
  "proc-macro2",
  "quote",
- "ruff_textwrap",
+ "ruff_python_trivia",
  "syn 2.0.23",
 ]
 
@@ -2097,25 +2104,35 @@ dependencies = [
 name = "ruff_python_ast"
 version = "0.0.0"
 dependencies = [
- "anyhow",
  "bitflags 2.3.3",
  "insta",
  "is-macro",
- "itertools",
  "memchr",
  "num-bigint",
  "num-traits",
  "once_cell",
  "ruff_python_trivia",
+ "ruff_source_file",
  "ruff_text_size",
  "rustc-hash",
  "rustpython-ast",
- "rustpython-literal",
  "rustpython-parser",
  "serde",
  "smallvec",
 ]
 
+[[package]]
+name = "ruff_python_codegen"
+version = "0.0.0"
+dependencies = [
+ "once_cell",
+ "ruff_python_ast",
+ "ruff_source_file",
+ "rustpython-ast",
+ "rustpython-literal",
+ "rustpython-parser",
+]
+
 [[package]]
 name = "ruff_python_formatter"
 version = "0.0.0"
@@ -2130,9 +2147,12 @@ dependencies = [
  "once_cell",
  "ruff_formatter",
  "ruff_python_ast",
+ "ruff_python_index",
  "ruff_python_trivia",
+ "ruff_source_file",
  "ruff_text_size",
  "rustc-hash",
+ "rustpython-ast",
  "rustpython-parser",
  "serde",
  "serde_json",
@@ -2141,6 +2161,30 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "ruff_python_index"
+version = "0.0.0"
+dependencies = [
+ "itertools",
+ "ruff_python_trivia",
+ "ruff_source_file",
+ "ruff_text_size",
+ "rustpython-ast",
+ "rustpython-parser",
+]
+
+[[package]]
+name = "ruff_python_parser"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "is-macro",
+ "ruff_python_ast",
+ "ruff_text_size",
+ "rustpython-ast",
+ "rustpython-parser",
+]
+
 [[package]]
 name = "ruff_python_resolver"
 version = "0.0.0"
@@ -2161,8 +2205,10 @@ dependencies = [
  "ruff_index",
  "ruff_python_ast",
  "ruff_python_stdlib",
+ "ruff_source_file",
  "ruff_text_size",
  "rustc-hash",
+ "rustpython-ast",
  "rustpython-parser",
  "smallvec",
 ]
@@ -2177,19 +2223,14 @@ version = "0.0.0"
 dependencies = [
  "insta",
  "memchr",
+ "ruff_source_file",
  "ruff_text_size",
+ "rustpython-ast",
+ "rustpython-parser",
  "smallvec",
  "unic-ucd-ident",
 ]
 
-[[package]]
-name = "ruff_rustpython"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "rustpython-parser",
-]
-
 [[package]]
 name = "ruff_shrinking"
 version = "0.1.0"
@@ -2199,13 +2240,24 @@ dependencies = [
  "fs-err",
  "regex",
  "ruff_python_ast",
- "ruff_rustpython",
+ "ruff_python_parser",
  "rustpython-ast",
  "shlex",
  "tracing",
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "ruff_source_file"
+version = "0.0.0"
+dependencies = [
+ "insta",
+ "memchr",
+ "once_cell",
+ "ruff_text_size",
+ "serde",
+]
+
 [[package]]
 name = "ruff_text_size"
 version = "0.0.0"
@@ -2215,14 +2267,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "ruff_textwrap"
-version = "0.0.0"
-dependencies = [
- "ruff_python_trivia",
- "ruff_text_size",
-]
-
 [[package]]
 name = "ruff_wasm"
 version = "0.0.0"
@@ -2234,8 +2278,11 @@ dependencies = [
  "ruff",
  "ruff_diagnostics",
  "ruff_python_ast",
+ "ruff_python_codegen",
  "ruff_python_formatter",
- "ruff_rustpython",
+ "ruff_python_index",
+ "ruff_python_parser",
+ "ruff_source_file",
  "rustpython-parser",
  "serde",
  "serde-wasm-bindgen",

crates/ruff/Cargo.toml

@@ -19,13 +19,15 @@ ruff_cache = { path = "../ruff_cache" }
 ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
 ruff_index = { path = "../ruff_index" }
 ruff_macros = { path = "../ruff_macros" }
-ruff_python_trivia = { path = "../ruff_python_trivia" }
 ruff_python_ast = { path = "../ruff_python_ast", features = ["serde"] }
+ruff_python_codegen = { path = "../ruff_python_codegen" }
+ruff_python_index = { path = "../ruff_python_index" }
 ruff_python_semantic = { path = "../ruff_python_semantic" }
 ruff_python_stdlib = { path = "../ruff_python_stdlib" }
-ruff_rustpython = { path = "../ruff_rustpython" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_source_file = { path = "../ruff_source_file" }
 ruff_text_size = { workspace = true }
-ruff_textwrap = { path = "../ruff_textwrap" }
 
 annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { workspace = true }
@@ -61,6 +63,7 @@ result-like = { version = "0.4.6" }
 rustc-hash = { workspace = true }
 rustpython-format = { workspace = true }
 rustpython-parser = { workspace = true }
+rustpython-ast = { workspace = true }
 schemars = { workspace = true, optional = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }

crates/ruff/src/autofix/codemods.rs

@@ -4,9 +4,10 @@ use anyhow::{bail, Result};
 use libcst_native::{
     Codegen, CodegenState, ImportNames, ParenthesizableWhitespace, SmallStatement, Statement,
 };
-use rustpython_parser::ast::{Ranged, Stmt};
+use rustpython_ast::{Ranged, Stmt};
 
-use ruff_python_ast::source_code::{Locator, Stylist};
+use ruff_python_codegen::Stylist;
+use ruff_source_file::Locator;
 
 use crate::cst::helpers::compose_module_path;
 use crate::cst::matchers::match_statement;

crates/ruff/src/autofix/edits.rs

@@ -1,13 +1,14 @@
 //! Interface for generating autofix edits from higher-level actions (e.g., "remove an argument").
 use anyhow::{bail, Result};
 use ruff_text_size::{TextLen, TextRange, TextSize};
-use rustpython_parser::ast::{self, ExceptHandler, Expr, Keyword, Ranged, Stmt};
+use rustpython_ast::{self as ast, ExceptHandler, Expr, Keyword, Ranged, Stmt};
 use rustpython_parser::{lexer, Mode};
 
 use ruff_diagnostics::Edit;
-use ruff_python_ast::helpers;
-use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-use ruff_python_trivia::{is_python_whitespace, NewlineWithTrailingNewline, PythonWhitespace};
+use ruff_python_codegen::Stylist;
+use ruff_python_index::Indexer;
+use ruff_python_trivia::{has_leading_content, is_python_whitespace, PythonWhitespace};
+use ruff_source_file::{Locator, NewlineWithTrailingNewline};
 
 use crate::autofix::codemods;
 
@@ -41,11 +42,9 @@ pub(crate) fn delete_stmt(
         if let Some(semicolon) = trailing_semicolon(stmt.end(), locator) {
             let next = next_stmt_break(semicolon, locator);
             Edit::deletion(stmt.start(), next)
-        } else if helpers::has_leading_content(stmt.start(), locator) {
+        } else if has_leading_content(stmt.start(), locator) {
             Edit::range_deletion(stmt.range())
-        } else if let Some(start) =
-            helpers::preceded_by_continuations(stmt.start(), locator, indexer)
-        {
+        } else if let Some(start) = indexer.preceded_by_continuations(stmt.start(), locator) {
             Edit::range_deletion(TextRange::new(start, stmt.end()))
         } else {
             let range = locator.full_lines_range(stmt.range());
@@ -296,10 +295,10 @@ fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
 mod tests {
     use anyhow::Result;
     use ruff_text_size::TextSize;
-    use rustpython_parser::ast::{Ranged, Suite};
+    use rustpython_ast::{Ranged, Suite};
     use rustpython_parser::Parse;
 
-    use ruff_python_ast::source_code::Locator;
+    use ruff_source_file::Locator;
 
     use crate::autofix::edits::{next_stmt_break, trailing_semicolon};
 

crates/ruff/src/autofix/mod.rs

@@ -5,7 +5,7 @@ use ruff_text_size::{TextLen, TextRange, TextSize};
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix, IsolationLevel};
-use ruff_python_ast::source_code::Locator;
+use ruff_source_file::Locator;
 
 use crate::autofix::source_map::SourceMap;
 use crate::linter::FixTable;
@@ -146,7 +146,7 @@ mod tests {
     use ruff_diagnostics::Diagnostic;
     use ruff_diagnostics::Edit;
     use ruff_diagnostics::Fix;
-    use ruff_python_ast::source_code::Locator;
+    use ruff_source_file::Locator;
 
     use crate::autofix::source_map::SourceMarker;
     use crate::autofix::{apply_fixes, FixResult};

crates/ruff/src/checkers/ast/analyze/argument.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Arg, Ranged};
+use rustpython_ast::{Arg, Ranged};
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/arguments.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Arguments;
+use rustpython_ast::Arguments;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/comprehension.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Comprehension;
+use rustpython_ast::Comprehension;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/deferred_for_loops.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Stmt};
+use rustpython_ast::{self as ast, Stmt};
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/definitions.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::str::raw_contents_range;
 use ruff_text_size::TextRange;
-use rustpython_parser::ast::Ranged;
+use rustpython_ast::Ranged;
 
 use ruff_python_semantic::{BindingKind, ContextualizedDefinition, Export};
 

crates/ruff/src/checkers/ast/analyze/except_handler.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, ExceptHandler, Ranged};
+use rustpython_ast::{self as ast, ExceptHandler, Ranged};
 
 use crate::checkers::ast::Checker;
 use crate::registry::Rule;

crates/ruff/src/checkers/ast/analyze/expression.rs

@@ -1,5 +1,5 @@
+use rustpython_ast::{self as ast, Constant, Expr, ExprContext, Operator, Ranged};
 use rustpython_format::cformat::{CFormatError, CFormatErrorType};
-use rustpython_parser::ast::{self, Constant, Expr, ExprContext, Operator, Ranged};
 
 use ruff_diagnostics::Diagnostic;
 

crates/ruff/src/checkers/ast/analyze/module.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Suite;
+use rustpython_ast::Suite;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/statement.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Expr, Ranged, Stmt};
+use rustpython_ast::{self as ast, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::helpers;

crates/ruff/src/checkers/ast/analyze/suite.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Stmt;
+use rustpython_ast::Stmt;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/deferred.rs

@@ -1,5 +1,5 @@
 use ruff_text_size::TextRange;
-use rustpython_parser::ast::Expr;
+use rustpython_ast::Expr;
 
 use ruff_python_semantic::{ScopeId, Snapshot};
 

crates/ruff/src/checkers/ast/mod.rs

@@ -31,20 +31,21 @@ use std::path::Path;
 use itertools::Itertools;
 use log::error;
 use ruff_text_size::{TextRange, TextSize};
-use rustpython_parser::ast::{
-    self, Arg, ArgWithDefault, Arguments, Comprehension, Constant, ElifElseClause, ExceptHandler,
-    Expr, ExprContext, Keyword, Pattern, Ranged, Stmt, Suite, UnaryOp,
+use rustpython_ast::{
+    self as ast, Arg, ArgWithDefault, Arguments, Comprehension, Constant, ElifElseClause,
+    ExceptHandler, Expr, ExprContext, Keyword, Pattern, Ranged, Stmt, Suite, UnaryOp,
 };
 
 use ruff_diagnostics::{Diagnostic, IsolationLevel};
 use ruff_python_ast::all::{extract_all_names, DunderAllFlags};
 use ruff_python_ast::helpers::{extract_handled_exceptions, to_module_path};
 use ruff_python_ast::identifier::Identifier;
-use ruff_python_ast::source_code::{Generator, Indexer, Locator, Quote, Stylist};
 use ruff_python_ast::str::trailing_quote;
-use ruff_python_ast::typing::{parse_type_annotation, AnnotationKind};
 use ruff_python_ast::visitor::{walk_except_handler, walk_pattern, Visitor};
 use ruff_python_ast::{helpers, str, visitor};
+use ruff_python_codegen::{Generator, Quote, Stylist};
+use ruff_python_index::Indexer;
+use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
 use ruff_python_semantic::analyze::{typing, visibility};
 use ruff_python_semantic::{
     BindingFlags, BindingId, BindingKind, Exceptions, Export, FromImport, Globals, Import, Module,
@@ -52,6 +53,7 @@ use ruff_python_semantic::{
 };
 use ruff_python_stdlib::builtins::{BUILTINS, MAGIC_GLOBALS};
 use ruff_python_stdlib::path::is_python_stub_file;
+use ruff_source_file::Locator;
 
 use crate::checkers::ast::deferred::Deferred;
 use crate::docstrings::extraction::ExtractionTarget;
@@ -1690,7 +1692,9 @@ impl<'a> Checker<'a> {
         while !self.deferred.string_type_definitions.is_empty() {
             let type_definitions = std::mem::take(&mut self.deferred.string_type_definitions);
             for (range, value, snapshot) in type_definitions {
-                if let Ok((expr, kind)) = parse_type_annotation(value, range, self.locator) {
+                if let Ok((expr, kind)) =
+                    parse_type_annotation(value, range, self.locator.contents())
+                {
                     let expr = allocator.alloc(expr);
 
                     self.semantic.restore(snapshot);

crates/ruff/src/checkers/imports.rs

@@ -2,14 +2,16 @@
 use std::borrow::Cow;
 use std::path::Path;
 
-use rustpython_parser::ast::{self, Ranged, Stmt, Suite};
+use rustpython_ast::{self as ast, Ranged, Stmt, Suite};
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::helpers::to_module_path;
 use ruff_python_ast::imports::{ImportMap, ModuleImport};
-use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
 use ruff_python_ast::statement_visitor::StatementVisitor;
+use ruff_python_codegen::Stylist;
+use ruff_python_index::Indexer;
 use ruff_python_stdlib::path::is_python_stub_file;
+use ruff_source_file::Locator;
 
 use crate::directives::IsortDirectives;
 use crate::registry::Rule;

crates/ruff/src/checkers/logical_lines.rs

@@ -2,8 +2,9 @@ use ruff_text_size::TextRange;
 use rustpython_parser::lexer::LexResult;
 
 use ruff_diagnostics::{Diagnostic, DiagnosticKind};
-use ruff_python_ast::source_code::{Locator, Stylist};
-use ruff_python_ast::token_kind::TokenKind;
+use ruff_python_codegen::Stylist;
+use ruff_python_parser::token_kind::TokenKind;
+use ruff_source_file::Locator;
 
 use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle::rules::logical_lines::{

crates/ruff/src/checkers/noqa.rs

@@ -4,10 +4,10 @@ use std::path::Path;
 
 use itertools::Itertools;
 use ruff_text_size::{TextLen, TextRange, TextSize};
-use rustpython_parser::ast::Ranged;
+use rustpython_ast::Ranged;
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
-use ruff_python_ast::source_code::Locator;
+use ruff_source_file::Locator;
 
 use crate::noqa;
 use crate::noqa::{Directive, FileExemption, NoqaDirectives, NoqaMapping};

crates/ruff/src/checkers/physical_lines.rs

@@ -2,8 +2,9 @@
 use ruff_text_size::TextSize;
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-use ruff_python_trivia::UniversalNewlines;
+use ruff_python_codegen::Stylist;
+use ruff_python_index::Indexer;
+use ruff_source_file::{Locator, UniversalNewlines};
 
 use crate::registry::Rule;
 use crate::rules::flake8_copyright::rules::missing_copyright_notice;
@@ -121,7 +122,9 @@ mod tests {
     use rustpython_parser::lexer::lex;
     use rustpython_parser::Mode;
 
-    use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
+    use ruff_python_codegen::Stylist;
+    use ruff_python_index::Indexer;
+    use ruff_source_file::Locator;
 
     use crate::line_width::LineLength;
     use crate::registry::Rule;

crates/ruff/src/checkers/tokens.rs

@@ -6,7 +6,8 @@ use rustpython_parser::lexer::LexResult;
 use rustpython_parser::Tok;
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::source_code::{Indexer, Locator};
+use ruff_python_index::Indexer;
+use ruff_source_file::Locator;
 
 use crate::directives::TodoComment;
 use crate::lex::docstring_detection::StateMachine;

crates/ruff/src/directives.rs

@@ -7,7 +7,8 @@ use ruff_text_size::{TextLen, TextRange, TextSize};
 use rustpython_parser::lexer::LexResult;
 use rustpython_parser::Tok;
 
-use ruff_python_ast::source_code::{Indexer, Locator};
+use ruff_python_index::Indexer;
+use ruff_source_file::Locator;
 
 use crate::noqa::NoqaMapping;
 use crate::settings::Settings;
@@ -352,7 +353,8 @@ mod tests {
     use rustpython_parser::lexer::LexResult;
     use rustpython_parser::{lexer, Mode};
 
-    use ruff_python_ast::source_code::{Indexer, Locator};
+    use ruff_python_index::Indexer;
+    use ruff_source_file::Locator;
 
     use crate::directives::{
         extract_isort_directives, extract_noqa_line_for, TodoDirective, TodoDirectiveKind,

crates/ruff/src/doc_lines.rs

@@ -4,13 +4,12 @@
 use std::iter::FusedIterator;
 
 use ruff_text_size::TextSize;
-use rustpython_parser::ast::{self, Constant, Expr, Ranged, Stmt, Suite};
+use rustpython_ast::{self as ast, Constant, Expr, Ranged, Stmt, Suite};
 use rustpython_parser::lexer::LexResult;
 use rustpython_parser::Tok;
 
-use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
-use ruff_python_trivia::UniversalNewlineIterator;
+use ruff_source_file::{Locator, UniversalNewlineIterator};
 
 /// Extract doc lines (standalone comments) from a token sequence.
 pub(crate) fn doc_lines_from_tokens(lxr: &[LexResult]) -> DocLines {

crates/ruff/src/docstrings/extraction.rs

@@ -1,6 +1,6 @@
 //! Extract docstrings from an AST.
 
-use rustpython_parser::ast::{self, Constant, Expr, Stmt};
+use rustpython_ast::{self as ast, Constant, Expr, Stmt};
 
 use ruff_python_semantic::{Definition, DefinitionId, Definitions, Member, MemberKind};
 

crates/ruff/src/docstrings/mod.rs

@@ -2,7 +2,7 @@ use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
 
 use ruff_text_size::{TextRange, TextSize};
-use rustpython_parser::ast::{Expr, Ranged};
+use rustpython_ast::{Expr, Ranged};
 
 use ruff_python_semantic::Definition;
 

crates/ruff/src/docstrings/sections.rs

@@ -5,7 +5,7 @@ use ruff_python_ast::docstrings::{leading_space, leading_words};
 use ruff_text_size::{TextLen, TextRange, TextSize};
 use strum_macros::EnumIter;
 
-use ruff_python_trivia::{Line, UniversalNewlineIterator, UniversalNewlines};
+use ruff_source_file::{Line, UniversalNewlineIterator, UniversalNewlines};
 
 use crate::docstrings::styles::SectionStyle;
 use crate::docstrings::{Docstring, DocstringBody};

crates/ruff/src/importer/insertion.rs

@@ -2,14 +2,14 @@
 use std::ops::Add;
 
 use ruff_text_size::TextSize;
-use rustpython_parser::ast::{Ranged, Stmt};
+use rustpython_ast::{Ranged, Stmt};
 use rustpython_parser::{lexer, Mode, Tok};
 
 use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers::is_docstring_stmt;
-use ruff_python_ast::source_code::{Locator, Stylist};
-use ruff_python_trivia::{PythonWhitespace, UniversalNewlineIterator};
-use ruff_textwrap::indent;
+use ruff_python_codegen::Stylist;
+use ruff_python_trivia::{textwrap::indent, PythonWhitespace};
+use ruff_source_file::{Locator, UniversalNewlineIterator};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) enum Placement<'a> {
@@ -300,12 +300,12 @@ fn match_leading_semicolon(s: &str) -> Option<TextSize> {
 mod tests {
     use anyhow::Result;
     use ruff_text_size::TextSize;
-    use rustpython_parser::ast::Suite;
+    use rustpython_ast::Suite;
     use rustpython_parser::lexer::LexResult;
     use rustpython_parser::Parse;
 
-    use ruff_python_ast::source_code::{Locator, Stylist};
-    use ruff_python_trivia::LineEnding;
+    use ruff_python_codegen::Stylist;
+    use ruff_source_file::{LineEnding, Locator};
 
     use super::Insertion;
 
@@ -313,7 +313,7 @@ mod tests {
     fn start_of_file() -> Result<()> {
         fn insert(contents: &str) -> Result<Insertion> {
             let program = Suite::parse(contents, "<filename>")?;
-            let tokens: Vec<LexResult> = ruff_rustpython::tokenize(contents);
+            let tokens: Vec<LexResult> = ruff_python_parser::tokenize(contents);
             let locator = Locator::new(contents);
             let stylist = Stylist::from_tokens(&tokens, &locator);
             Ok(Insertion::start_of_file(&program, &locator, &stylist))
@@ -424,7 +424,7 @@ x = 1
     #[test]
     fn start_of_block() {
         fn insert(contents: &str, offset: TextSize) -> Insertion {
-            let tokens: Vec<LexResult> = ruff_rustpython::tokenize(contents);
+            let tokens: Vec<LexResult> = ruff_python_parser::tokenize(contents);
             let locator = Locator::new(contents);
             let stylist = Stylist::from_tokens(&tokens, &locator);
             Insertion::start_of_block(offset, &locator, &stylist)

crates/ruff/src/importer/mod.rs

@@ -8,13 +8,14 @@ use std::error::Error;
 use anyhow::Result;
 use libcst_native::{ImportAlias, Name, NameOrAttribute};
 use ruff_text_size::TextSize;
-use rustpython_parser::ast::{self, Ranged, Stmt, Suite};
+use rustpython_ast::{self as ast, Ranged, Stmt, Suite};
 
 use ruff_diagnostics::Edit;
 use ruff_python_ast::imports::{AnyImport, Import, ImportFrom};
-use ruff_python_ast::source_code::{Locator, Stylist};
+use ruff_python_codegen::Stylist;
 use ruff_python_semantic::SemanticModel;
-use ruff_textwrap::indent;
+use ruff_python_trivia::textwrap::indent;
+use ruff_source_file::Locator;
 
 use crate::autofix;
 use crate::autofix::codemods::CodegenStylist;

crates/ruff/src/jupyter/notebook.rs

@@ -10,7 +10,7 @@ use serde::Serialize;
 use serde_json::error::Category;
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_trivia::{NewlineWithTrailingNewline, UniversalNewlineIterator};
+use ruff_source_file::{NewlineWithTrailingNewline, UniversalNewlineIterator};
 use ruff_text_size::{TextRange, TextSize};
 use rustpython_parser::lexer::lex;
 use rustpython_parser::Mode;

crates/ruff/src/lib.rs

@@ -5,7 +5,6 @@
 //!
 //! [Ruff]: https://github.com/astral-sh/ruff
 
-pub use ruff_python_ast::source_code::round_trip;
 pub use rule_selector::RuleSelector;
 pub use rules::pycodestyle::rules::IOError;
 

crates/ruff/src/linter.rs

@@ -12,8 +12,10 @@ use rustpython_parser::ParseError;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::imports::ImportMap;
-use ruff_python_ast::source_code::{Indexer, Locator, SourceFileBuilder, Stylist};
+use ruff_python_codegen::Stylist;
+use ruff_python_index::Indexer;
 use ruff_python_stdlib::path::is_python_stub_file;
+use ruff_source_file::{Locator, SourceFileBuilder};
 
 use crate::autofix::{fix_file, FixResult};
 use crate::checkers::ast::check_ast;
@@ -136,7 +138,7 @@ pub fn check_path(
             .iter_enabled()
             .any(|rule_code| rule_code.lint_source().is_imports());
     if use_ast || use_imports || use_doc_lines {
-        match ruff_rustpython::parse_program_tokens(tokens, &path.to_string_lossy()) {
+        match ruff_python_parser::parse_program_tokens(tokens, &path.to_string_lossy()) {
             Ok(python_ast) => {
                 if use_ast {
                     diagnostics.extend(check_ast(
@@ -258,7 +260,7 @@ pub fn add_noqa_to_path(path: &Path, package: Option<&Path>, settings: &Settings
     let contents = std::fs::read_to_string(path)?;
 
     // Tokenize once.
-    let tokens: Vec<LexResult> = ruff_rustpython::tokenize(&contents);
+    let tokens: Vec<LexResult> = ruff_python_parser::tokenize(&contents);
 
     // Map row and column locations to byte slices (lazily).
     let locator = Locator::new(&contents);
@@ -326,7 +328,7 @@ pub fn lint_only(
     source_kind: Option<&SourceKind>,
 ) -> LinterResult<(Vec<Message>, Option<ImportMap>)> {
     // Tokenize once.
-    let tokens: Vec<LexResult> = ruff_rustpython::tokenize(contents);
+    let tokens: Vec<LexResult> = ruff_python_parser::tokenize(contents);
 
     // Map row and column locations to byte slices (lazily).
     let locator = Locator::new(contents);
@@ -418,7 +420,7 @@ pub fn lint_fix<'a>(
     // Continuously autofix until the source code stabilizes.
     loop {
         // Tokenize once.
-        let tokens: Vec<LexResult> = ruff_rustpython::tokenize(&transformed);
+        let tokens: Vec<LexResult> = ruff_python_parser::tokenize(&transformed);
 
         // Map row and column locations to byte slices (lazily).
         let locator = Locator::new(&transformed);

crates/ruff/src/logging.rs

@@ -9,7 +9,7 @@ use log::Level;
 use once_cell::sync::Lazy;
 use rustpython_parser::{ParseError, ParseErrorType};
 
-use ruff_python_ast::source_code::{OneIndexed, SourceCode, SourceLocation};
+use ruff_source_file::{OneIndexed, SourceCode, SourceLocation};
 
 use crate::fs;
 use crate::jupyter::Notebook;

crates/ruff/src/message/azure.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use ruff_python_ast::source_code::SourceLocation;
+use ruff_source_file::SourceLocation;
 
 use crate::message::{Emitter, EmitterContext, Message};
 use crate::registry::AsRule;

crates/ruff/src/message/diff.rs

@@ -7,7 +7,7 @@ use ruff_text_size::{TextRange, TextSize};
 use similar::{ChangeTag, TextDiff};
 
 use ruff_diagnostics::{Applicability, Fix};
-use ruff_python_ast::source_code::{OneIndexed, SourceFile};
+use ruff_source_file::{OneIndexed, SourceFile};
 
 use crate::message::Message;
 

crates/ruff/src/message/github.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use ruff_python_ast::source_code::SourceLocation;
+use ruff_source_file::SourceLocation;
 
 use crate::fs::relativize_path;
 use crate::message::{Emitter, EmitterContext, Message};

crates/ruff/src/message/gitlab.rs

@@ -6,7 +6,7 @@ use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 use serde_json::json;
 
-use ruff_python_ast::source_code::SourceLocation;
+use ruff_source_file::SourceLocation;
 
 use crate::fs::{relativize_path, relativize_path_to};
 use crate::message::{Emitter, EmitterContext, Message};

crates/ruff/src/message/grouped.rs

@@ -4,7 +4,7 @@ use std::num::NonZeroUsize;
 
 use colored::Colorize;
 
-use ruff_python_ast::source_code::OneIndexed;
+use ruff_source_file::OneIndexed;
 
 use crate::fs::relativize_path;
 use crate::jupyter::{JupyterIndex, Notebook};

crates/ruff/src/message/json.rs

@@ -5,7 +5,7 @@ use serde::{Serialize, Serializer};
 use serde_json::{json, Value};
 
 use ruff_diagnostics::Edit;
-use ruff_python_ast::source_code::SourceCode;
+use ruff_source_file::SourceCode;
 
 use crate::message::{Emitter, EmitterContext, Message};
 use crate::registry::AsRule;

crates/ruff/src/message/junit.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 
 use quick_junit::{NonSuccessKind, Report, TestCase, TestCaseStatus, TestSuite};
 
-use ruff_python_ast::source_code::SourceLocation;
+use ruff_source_file::SourceLocation;
 
 use crate::message::{
     group_messages_by_filename, Emitter, EmitterContext, Message, MessageWithLocation,

crates/ruff/src/message/mod.rs

@@ -16,7 +16,7 @@ pub use json_lines::JsonLinesEmitter;
 pub use junit::JunitEmitter;
 pub use pylint::PylintEmitter;
 use ruff_diagnostics::{Diagnostic, DiagnosticKind, Fix};
-use ruff_python_ast::source_code::{SourceFile, SourceLocation};
+use ruff_source_file::{SourceFile, SourceLocation};
 pub use text::TextEmitter;
 
 mod azure;
@@ -155,7 +155,7 @@ mod tests {
     use rustc_hash::FxHashMap;
 
     use ruff_diagnostics::{Diagnostic, DiagnosticKind, Edit, Fix};
-    use ruff_python_ast::source_code::SourceFileBuilder;
+    use ruff_source_file::SourceFileBuilder;
 
     use crate::message::{Emitter, EmitterContext, Message};
 

crates/ruff/src/message/pylint.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use ruff_python_ast::source_code::OneIndexed;
+use ruff_source_file::OneIndexed;
 
 use crate::fs::relativize_path;
 use crate::message::{Emitter, EmitterContext, Message};

crates/ruff/src/message/text.rs

@@ -8,7 +8,7 @@ use bitflags::bitflags;
 use colored::Colorize;
 use ruff_text_size::{TextRange, TextSize};
 
-use ruff_python_ast::source_code::{OneIndexed, SourceLocation};
+use ruff_source_file::{OneIndexed, SourceLocation};
 
 use crate::fs::relativize_path;
 use crate::jupyter::{JupyterIndex, Notebook};

crates/ruff/src/noqa.rs

@@ -9,11 +9,10 @@ use anyhow::Result;
 use itertools::Itertools;
 use log::warn;
 use ruff_text_size::{TextLen, TextRange, TextSize};
-use rustpython_parser::ast::Ranged;
+use rustpython_ast::Ranged;
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::source_code::Locator;
-use ruff_python_trivia::LineEnding;
+use ruff_source_file::{LineEnding, Locator};
 
 use crate::codes::NoqaCode;
 use crate::fs::relativize_path;
@@ -782,8 +781,7 @@ mod tests {
     use ruff_text_size::{TextRange, TextSize};
 
     use ruff_diagnostics::Diagnostic;
-    use ruff_python_ast::source_code::Locator;
-    use ruff_python_trivia::LineEnding;
+    use ruff_source_file::{LineEnding, Locator};
 
     use crate::noqa::{add_noqa_inner, Directive, NoqaMapping, ParsedFileExemption};
     use crate::rules::pycodestyle::rules::AmbiguousVariableName;

crates/ruff/src/pyproject_toml.rs

@@ -5,7 +5,7 @@ use ruff_text_size::{TextRange, TextSize};
 use serde::{Deserialize, Serialize};
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::source_code::SourceFile;
+use ruff_source_file::SourceFile;
 
 use crate::message::Message;
 use crate::registry::Rule;

crates/ruff/src/rules/airflow/rules/task_variable_name.rs

@@ -1,10 +1,10 @@
+use rustpython_ast::{Expr, Ranged};
 use rustpython_parser::ast;
-use rustpython_parser::ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::find_keyword;
-use rustpython_parser::ast::Constant;
+use rustpython_ast::Constant;
 
 use crate::checkers::ast::Checker;
 

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

@@ -1,7 +1,7 @@
 /// See: [eradicate.py](https://github.com/myint/eradicate/blob/98f199940979c94447a461d50d27862b118b282d/eradicate.py)
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_parser::ast::Suite;
+use rustpython_ast::Suite;
 use rustpython_parser::Parse;
 
 static ALLOWLIST_REGEX: Lazy<Regex> = Lazy::new(|| {

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

@@ -1,6 +1,7 @@
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::source_code::{Indexer, Locator};
+use ruff_python_index::Indexer;
+use ruff_source_file::Locator;
 
 use crate::registry::Rule;
 use crate::settings::Settings;

crates/ruff/src/rules/flake8_2020/helpers.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Expr;
+use rustpython_ast::Expr;
 
 use ruff_python_semantic::SemanticModel;
 

crates/ruff/src/rules/flake8_2020/rules/compare.rs

@@ -1,5 +1,5 @@
 use num_bigint::BigInt;
-use rustpython_parser::ast::{self, CmpOp, Constant, Expr, Ranged};
+use rustpython_ast::{self as ast, CmpOp, Constant, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_2020/rules/name_or_attribute.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Ranged};
+use rustpython_ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_2020/rules/subscript.rs

@@ -1,5 +1,5 @@
 use num_bigint::BigInt;
-use rustpython_parser::ast::{self, Constant, Expr, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_annotations/fixes.rs

@@ -1,9 +1,9 @@
 use anyhow::{bail, Result};
-use rustpython_parser::ast::{Ranged, Stmt};
+use rustpython_ast::{Ranged, Stmt};
 use rustpython_parser::{lexer, Mode, Tok};
 
 use ruff_diagnostics::Edit;
-use ruff_python_ast::source_code::Locator;
+use ruff_source_file::Locator;
 
 /// ANN204
 pub(crate) fn add_return_annotation(

crates/ruff/src/rules/flake8_annotations/helpers.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Arguments, Expr, Stmt};
+use rustpython_ast::{self as ast, Arguments, Expr, Stmt};
 
 use ruff_python_ast::cast;
 use ruff_python_semantic::analyze::visibility;

crates/ruff/src/rules/flake8_annotations/rules/definition.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, ArgWithDefault, Constant, Expr, Ranged, Stmt};
+use rustpython_ast::{self as ast, ArgWithDefault, Constant, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -6,7 +6,7 @@ use ruff_python_ast::cast;
 use ruff_python_ast::helpers::ReturnStatementVisitor;
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::statement_visitor::StatementVisitor;
-use ruff_python_ast::typing::parse_type_annotation;
+use ruff_python_parser::typing::parse_type_annotation;
 use ruff_python_semantic::analyze::visibility;
 use ruff_python_semantic::{Definition, Member, MemberKind};
 use ruff_python_stdlib::typing::simple_magic_return_type;
@@ -462,7 +462,8 @@ fn check_dynamically_typed<F>(
     }) = annotation
     {
         // Quoted annotations
-        if let Ok((parsed_annotation, _)) = parse_type_annotation(string, *range, checker.locator())
+        if let Ok((parsed_annotation, _)) =
+            parse_type_annotation(string, *range, checker.locator().contents())
         {
             if type_hint_resolves_to_any(
                 &parsed_annotation,

crates/ruff/src/rules/flake8_async/rules/blocking_http_call.rs

@@ -1,5 +1,5 @@
+use rustpython_ast::{Expr, Ranged};
 use rustpython_parser::ast;
-use rustpython_parser::ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_async/rules/blocking_os_call.rs

@@ -1,5 +1,5 @@
+use rustpython_ast::{Expr, Ranged};
 use rustpython_parser::ast;
-use rustpython_parser::ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_async/rules/open_sleep_or_subprocess_call.rs

@@ -1,5 +1,5 @@
+use rustpython_ast::{Expr, Ranged};
 use rustpython_parser::ast;
-use rustpython_parser::ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/helpers.rs

@@ -1,6 +1,6 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_parser::ast::{self, Constant, Expr};
+use rustpython_ast::{self as ast, Constant, Expr};
 
 use ruff_python_semantic::SemanticModel;
 

crates/ruff/src/rules/flake8_bandit/rules/assert_used.rs

@@ -1,5 +1,5 @@
 use ruff_text_size::{TextLen, TextRange};
-use rustpython_parser::ast::{Ranged, Stmt};
+use rustpython_ast::{Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/bad_file_permissions.rs

@@ -1,5 +1,5 @@
 use num_traits::ToPrimitive;
-use rustpython_parser::ast::{self, Constant, Expr, Keyword, Operator, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Keyword, Operator, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/exec_used.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Ranged};
+use rustpython_ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_default.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Arg, ArgWithDefault, Arguments, Expr, Ranged};
+use rustpython_ast::{Arg, ArgWithDefault, Arguments, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_func_arg.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Keyword, Ranged};
+use rustpython_ast::{Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_string.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Constant, Expr, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_sql_expression.rs

@@ -1,6 +1,6 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_parser::ast::{self, Expr, Operator, Ranged};
+use rustpython_ast::{self as ast, Expr, Operator, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Ranged};
+use rustpython_ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/hashlib_insecure_hash_functions.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Keyword, Ranged};
+use rustpython_ast::{Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/jinja2_autoescape_false.rs

@@ -1,5 +1,5 @@
 use ruff_python_ast::helpers::find_keyword;
-use rustpython_parser::ast::{self, Constant, Expr, Keyword, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/logging_config_insecure_listen.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Keyword, Ranged};
+use rustpython_ast::{Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/paramiko_calls.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Ranged};
+use rustpython_ast::{Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/request_with_no_cert_validation.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Keyword, Ranged};
+use rustpython_ast::{Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/request_without_timeout.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Keyword, Ranged};
+use rustpython_ast::{Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/shell_injection.rs

@@ -1,6 +1,6 @@
 //! Checks relating to shell injection.
 
-use rustpython_parser::ast::{self, Constant, Expr, Keyword, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/snmp_insecure_version.rs

@@ -1,5 +1,5 @@
 use num_traits::{One, Zero};
-use rustpython_parser::ast::{self, Constant, Expr, Keyword, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/snmp_weak_cryptography.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{Expr, Keyword, Ranged};
+use rustpython_ast::{Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/suspicious_function_call.rs

@@ -1,7 +1,7 @@
 //! Check for calls to suspicious functions, or calls into suspicious modules.
 //!
 //! See: <https://bandit.readthedocs.io/en/latest/blacklists/blacklist_calls.html>
-use rustpython_parser::ast::{self, Expr, Ranged};
+use rustpython_ast::{self as ast, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, DiagnosticKind, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/try_except_continue.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{ExceptHandler, Expr, Ranged, Stmt};
+use rustpython_ast::{ExceptHandler, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/try_except_pass.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{ExceptHandler, Expr, Ranged, Stmt};
+use rustpython_ast::{ExceptHandler, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bandit/rules/unsafe_yaml_load.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Expr, Keyword, Ranged};
+use rustpython_ast::{self as ast, Expr, Keyword, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_blind_except/rules/blind_except.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Expr, Ranged, Stmt};
+use rustpython_ast::{self as ast, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_boolean_trap/helpers.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Constant, Expr, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, DiagnosticKind};
 

crates/ruff/src/rules/flake8_boolean_trap/rules/check_boolean_default_value_in_function_definition.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{ArgWithDefault, Arguments, Decorator};
+use rustpython_ast::{ArgWithDefault, Arguments, Decorator};
 
 use ruff_diagnostics::Violation;
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_boolean_trap/rules/check_boolean_positional_value_in_function_call.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::Expr;
+use rustpython_ast::Expr;
 
 use ruff_diagnostics::Violation;
 

crates/ruff/src/rules/flake8_boolean_trap/rules/check_positional_boolean_in_def.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, ArgWithDefault, Arguments, Constant, Decorator, Expr, Ranged};
+use rustpython_ast::{self as ast, ArgWithDefault, Arguments, Constant, Decorator, Expr, Ranged};
 
 use ruff_diagnostics::Diagnostic;
 use ruff_diagnostics::Violation;

crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Constant, Expr, Keyword, Ranged, Stmt};
+use rustpython_ast::{self as ast, Constant, Expr, Keyword, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/assert_false.rs

@@ -1,5 +1,5 @@
 use ruff_text_size::TextRange;
-use rustpython_parser::ast::{self, Expr, ExprContext, Ranged, Stmt};
+use rustpython_ast::{self as ast, Expr, ExprContext, Ranged, Stmt};
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/assert_raises_exception.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use rustpython_parser::ast::{self, Expr, Ranged, WithItem};
+use rustpython_ast::{self as ast, Expr, Ranged, WithItem};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/assignment_to_os_environ.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Expr, Ranged};
+use rustpython_ast::{self as ast, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/cached_instance_method.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Decorator, Expr, Ranged};
+use rustpython_ast::{self as ast, Decorator, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/duplicate_exceptions.rs

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use ruff_text_size::TextRange;
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustpython_parser::ast::{self, ExceptHandler, Expr, ExprContext, Ranged};
+use rustpython_ast::{self as ast, ExceptHandler, Expr, ExprContext, Ranged};
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Violation};
 use ruff_diagnostics::{Diagnostic, Edit, Fix};

crates/ruff/src/rules/flake8_bugbear/rules/duplicate_value.rs

@@ -1,5 +1,5 @@
 use rustc_hash::FxHashSet;
-use rustpython_parser::ast::{self, Expr, Ranged};
+use rustpython_ast::{self as ast, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/except_with_empty_tuple.rs

@@ -1,5 +1,5 @@
-use rustpython_parser::ast::{self, Ranged};
-use rustpython_parser::ast::{ExceptHandler, Expr};
+use rustpython_ast::{self as ast, Ranged};
+use rustpython_ast::{ExceptHandler, Expr};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/except_with_non_exception_classes.rs

@@ -1,6 +1,6 @@
 use std::collections::VecDeque;
 
-use rustpython_parser::ast::{self, ExceptHandler, Expr, Ranged};
+use rustpython_ast::{self as ast, ExceptHandler, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/f_string_docstring.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Stmt};
+use rustpython_ast::{self as ast, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/function_call_in_argument_default.rs

@@ -1,5 +1,5 @@
 use ruff_text_size::TextRange;
-use rustpython_parser::ast::{self, ArgWithDefault, Arguments, Expr, Ranged};
+use rustpython_ast::{self as ast, ArgWithDefault, Arguments, Expr, Ranged};
 
 use ruff_diagnostics::Violation;
 use ruff_diagnostics::{Diagnostic, DiagnosticKind};

crates/ruff/src/rules/flake8_bugbear/rules/function_uses_loop_variable.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Comprehension, Expr, ExprContext, Ranged, Stmt};
+use rustpython_ast::{self as ast, Comprehension, Expr, ExprContext, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/getattr_with_constant.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Constant, Expr, Ranged};
+use rustpython_ast::{self as ast, Constant, Expr, Ranged};
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::ast::{self, Ranged, Stmt};
+use rustpython_ast::{self as ast, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};

crates/ruff/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs

@@ -1,5 +1,5 @@
 use rustc_hash::FxHashMap;
-use rustpython_parser::ast::{self, ArgWithDefault, Expr, Ranged};
+use rustpython_ast::{self as ast, ArgWithDefault, Expr, Ranged};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};