Rename PreorderVisitor to SourceOrderVisitor (#11798)

Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>

crates/red_knot/src/ast_ids.rs

@@ -6,8 +6,8 @@ use std::marker::PhantomData;
 use rustc_hash::FxHashMap;
 
 use ruff_index::{Idx, IndexVec};
-use ruff_python_ast::visitor::preorder;
-use ruff_python_ast::visitor::preorder::{PreorderVisitor, TraversalSignal};
+use ruff_python_ast::visitor::source_order;
+use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
 use ruff_python_ast::{
     AnyNodeRef, AstNode, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule,
     NodeKind, Parameter, Stmt, StmtAnnAssign, StmtAssign, StmtAugAssign, StmtClassDef,
@@ -91,9 +91,9 @@ impl AstIds {
         while let Some(deferred) = visitor.deferred.pop() {
             match deferred {
                 DeferredNode::FunctionDefinition(def) => {
-                    def.visit_preorder(&mut visitor);
+                    def.visit_source_order(&mut visitor);
                 }
-                DeferredNode::ClassDefinition(def) => def.visit_preorder(&mut visitor),
+                DeferredNode::ClassDefinition(def) => def.visit_source_order(&mut visitor),
             }
         }
 
@@ -182,7 +182,7 @@ impl<'a> AstIdsVisitor<'a> {
     }
 }
 
-impl<'a> PreorderVisitor<'a> for AstIdsVisitor<'a> {
+impl<'a> SourceOrderVisitor<'a> for AstIdsVisitor<'a> {
     fn visit_stmt(&mut self, stmt: &'a Stmt) {
         match stmt {
             Stmt::FunctionDef(def) => {
@@ -226,14 +226,14 @@ impl<'a> PreorderVisitor<'a> for AstIdsVisitor<'a> {
             Stmt::IpyEscapeCommand(_) => {}
         }
 
-        preorder::walk_stmt(self, stmt);
+        source_order::walk_stmt(self, stmt);
     }
 
     fn visit_expr(&mut self, _expr: &'a Expr) {}
 
     fn visit_parameter(&mut self, parameter: &'a Parameter) {
         self.create_id(parameter);
-        preorder::walk_parameter(self, parameter);
+        source_order::walk_parameter(self, parameter);
     }
 
     fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
@@ -243,17 +243,17 @@ impl<'a> PreorderVisitor<'a> for AstIdsVisitor<'a> {
             }
         }
 
-        preorder::walk_except_handler(self, except_handler);
+        source_order::walk_except_handler(self, except_handler);
     }
 
     fn visit_with_item(&mut self, with_item: &'a WithItem) {
         self.create_id(with_item);
-        preorder::walk_with_item(self, with_item);
+        source_order::walk_with_item(self, with_item);
     }
 
     fn visit_match_case(&mut self, match_case: &'a MatchCase) {
         self.create_id(match_case);
-        preorder::walk_match_case(self, match_case);
+        source_order::walk_match_case(self, match_case);
     }
 
     fn visit_type_param(&mut self, type_param: &'a TypeParam) {
@@ -309,7 +309,7 @@ struct FindNodeKeyVisitor<'a> {
     result: Option<AnyNodeRef<'a>>,
 }
 
-impl<'a> PreorderVisitor<'a> for FindNodeKeyVisitor<'a> {
+impl<'a> SourceOrderVisitor<'a> for FindNodeKeyVisitor<'a> {
     fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
         if self.result.is_some() {
             return TraversalSignal::Skip;

crates/red_knot/src/semantic.rs

@@ -1,7 +1,7 @@
 use std::num::NonZeroU32;
 
 use ruff_python_ast as ast;
-use ruff_python_ast::visitor::preorder::PreorderVisitor;
+use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
 
 use crate::ast_ids::{NodeKey, TypedNodeKey};
 use crate::cache::KeyValueCache;
@@ -238,7 +238,7 @@ impl SemanticIndexer {
     }
 }
 
-impl PreorderVisitor<'_> for SemanticIndexer {
+impl SourceOrderVisitor<'_> for SemanticIndexer {
     fn visit_expr(&mut self, expr: &ast::Expr) {
         let expression_id = self
             .flow_graph_builder
@@ -267,7 +267,7 @@ impl PreorderVisitor<'_> for SemanticIndexer {
                         self.add_or_update_symbol_with_def(id, curdef);
                     }
                 }
-                ast::visitor::preorder::walk_expr(self, expr);
+                ast::visitor::source_order::walk_expr(self, expr);
             }
             ast::Expr::Named(node) => {
                 debug_assert!(self.current_definition.is_none());
@@ -304,7 +304,7 @@ impl PreorderVisitor<'_> for SemanticIndexer {
                 self.set_current_flow_node(post_else);
             }
             _ => {
-                ast::visitor::preorder::walk_expr(self, expr);
+                ast::visitor::source_order::walk_expr(self, expr);
             }
         }
     }
@@ -507,7 +507,7 @@ impl PreorderVisitor<'_> for SemanticIndexer {
                 self.set_current_flow_node(post_prior_clause);
             }
             _ => {
-                ast::visitor::preorder::walk_stmt(self, stmt);
+                ast::visitor::source_order::walk_stmt(self, stmt);
             }
         }
     }

crates/ruff_linter/src/rules/ruff/rules/suppression_comment_visitor.rs

@@ -2,7 +2,7 @@ use std::iter::Peekable;
 
 use ruff_python_ast::{
     helpers::comment_indentation_after,
-    visitor::preorder::{self, PreorderVisitor, TraversalSignal},
+    visitor::source_order::{self, SourceOrderVisitor, TraversalSignal},
     AnyNodeRef, Suite,
 };
 use ruff_python_trivia::{
@@ -62,7 +62,7 @@ where
     }
 }
 
-impl<'ast, I> PreorderVisitor<'ast> for SuppressionCommentVisitor<'ast, '_, I>
+impl<'ast, I> SourceOrderVisitor<'ast> for SuppressionCommentVisitor<'ast, '_, I>
 where
     I: Iterator<Item = SuppressionComment> + 'ast,
 {
@@ -187,7 +187,7 @@ where
                     self.visit_stmt(first);
                     self.preceding_node = Some(last.into());
                 } else {
-                    preorder::walk_body(self, body);
+                    source_order::walk_body(self, body);
                 }
             }
         }

crates/ruff_linter/src/rules/ruff/rules/unused_async.rs

@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::identifier::Identifier;
-use ruff_python_ast::visitor::preorder;
+use ruff_python_ast::visitor::source_order;
 use ruff_python_ast::{self as ast, AnyNodeRef, Expr, Stmt};
 use ruff_python_semantic::analyze::function_type::is_stub;
 
@@ -50,12 +50,12 @@ struct AsyncExprVisitor {
 /// Traverse a function's body to find whether it contains an await-expr, an async-with, or an
 /// async-for. Stop traversing after one is found. The bodies of inner-functions and inner-classes
 /// aren't traversed.
-impl<'a> preorder::PreorderVisitor<'a> for AsyncExprVisitor {
-    fn enter_node(&mut self, _node: AnyNodeRef<'a>) -> preorder::TraversalSignal {
+impl<'a> source_order::SourceOrderVisitor<'a> for AsyncExprVisitor {
+    fn enter_node(&mut self, _node: AnyNodeRef<'a>) -> source_order::TraversalSignal {
         if self.found_await_or_async {
-            preorder::TraversalSignal::Skip
+            source_order::TraversalSignal::Skip
         } else {
-            preorder::TraversalSignal::Traverse
+            source_order::TraversalSignal::Traverse
         }
     }
     fn visit_stmt(&mut self, stmt: &'a Stmt) {
@@ -73,7 +73,7 @@ impl<'a> preorder::PreorderVisitor<'a> for AsyncExprVisitor {
             Stmt::ClassDef(class_def) => {
                 class_def_visit_preorder_except_body(class_def, self);
             }
-            _ => preorder::walk_stmt(self, stmt),
+            _ => source_order::walk_stmt(self, stmt),
         }
     }
     fn visit_expr(&mut self, expr: &'a Expr) {
@@ -81,14 +81,14 @@ impl<'a> preorder::PreorderVisitor<'a> for AsyncExprVisitor {
             Expr::Await(_) => {
                 self.found_await_or_async = true;
             }
-            _ => preorder::walk_expr(self, expr),
+            _ => source_order::walk_expr(self, expr),
         }
     }
     fn visit_comprehension(&mut self, comprehension: &'a ast::Comprehension) {
         if comprehension.is_async {
             self.found_await_or_async = true;
         } else {
-            preorder::walk_comprehension(self, comprehension);
+            source_order::walk_comprehension(self, comprehension);
         }
     }
 }
@@ -99,7 +99,7 @@ fn function_def_visit_preorder_except_body<'a, V>(
     function_def: &'a ast::StmtFunctionDef,
     visitor: &mut V,
 ) where
-    V: preorder::PreorderVisitor<'a>,
+    V: source_order::SourceOrderVisitor<'a>,
 {
     let ast::StmtFunctionDef {
         parameters,
@@ -128,7 +128,7 @@ fn function_def_visit_preorder_except_body<'a, V>(
 /// crucially, doesn't traverse the body.
 fn class_def_visit_preorder_except_body<'a, V>(class_def: &'a ast::StmtClassDef, visitor: &mut V)
 where
-    V: preorder::PreorderVisitor<'a>,
+    V: source_order::SourceOrderVisitor<'a>,
 {
     let ast::StmtClassDef {
         arguments,
@@ -175,7 +175,7 @@ pub(crate) fn unused_async(
 
     let found_await_or_async = {
         let mut visitor = AsyncExprVisitor::default();
-        preorder::walk_body(&mut visitor, body);
+        source_order::walk_body(&mut visitor, body);
         visitor.found_await_or_async
     };
 

crates/ruff_python_ast/src/visitor.rs

@@ -1,6 +1,6 @@
 //! AST visitor trait and walk functions.
 
-pub mod preorder;
+pub mod source_order;
 pub mod transformer;
 
 use crate::{
@@ -16,8 +16,8 @@ use crate::{
 /// Prefer [`crate::statement_visitor::StatementVisitor`] for visitors that only need to visit
 /// statements.
 ///
-/// Use the [`PreorderVisitor`](preorder::PreorderVisitor) if you want to visit the nodes
-/// in pre-order rather than evaluation order.
+/// Use the [`PreorderVisitor`](source_order::SourceOrderVisitor) if you want to visit the nodes
+/// in source-order rather than evaluation order.
 ///
 /// Use the [`Transformer`](transformer::Transformer) if you want to modify the nodes.
 pub trait Visitor<'a> {

crates/ruff_python_ast/src/visitor/source_order.rs

@@ -6,8 +6,11 @@ use crate::{
 };
 use crate::{AnyNodeRef, AstNode};
 
-/// Visitor that traverses all nodes recursively in pre-order.
-pub trait PreorderVisitor<'a> {
+/// Visitor that traverses all nodes recursively in the order they appear in the source.
+///
+/// If you need a visitor that visits the nodes in the order they're evaluated at runtime,
+/// use [`Visitor`](super::Visitor) instead.
+pub trait SourceOrderVisitor<'a> {
     #[inline]
     fn enter_node(&mut self, _node: AnyNodeRef<'a>) -> TraversalSignal {
         TraversalSignal::Traverse
@@ -171,13 +174,13 @@ pub trait PreorderVisitor<'a> {
 
 pub fn walk_module<'a, V>(visitor: &mut V, module: &'a Mod)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(module);
     if visitor.enter_node(node).is_traverse() {
         match module {
-            Mod::Module(module) => module.visit_preorder(visitor),
-            Mod::Expression(module) => module.visit_preorder(visitor),
+            Mod::Module(module) => module.visit_source_order(visitor),
+            Mod::Expression(module) => module.visit_source_order(visitor),
         }
     }
 
@@ -186,7 +189,7 @@ where
 
 pub fn walk_body<'a, V>(visitor: &mut V, body: &'a [Stmt])
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     for stmt in body {
         visitor.visit_stmt(stmt);
@@ -195,37 +198,37 @@ where
 
 pub fn walk_stmt<'a, V>(visitor: &mut V, stmt: &'a Stmt)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(stmt);
 
     if visitor.enter_node(node).is_traverse() {
         match stmt {
-            Stmt::Expr(stmt) => stmt.visit_preorder(visitor),
-            Stmt::FunctionDef(stmt) => stmt.visit_preorder(visitor),
-            Stmt::ClassDef(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Return(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Delete(stmt) => stmt.visit_preorder(visitor),
-            Stmt::TypeAlias(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Assign(stmt) => stmt.visit_preorder(visitor),
-            Stmt::AugAssign(stmt) => stmt.visit_preorder(visitor),
-            Stmt::AnnAssign(stmt) => stmt.visit_preorder(visitor),
-            Stmt::For(stmt) => stmt.visit_preorder(visitor),
-            Stmt::While(stmt) => stmt.visit_preorder(visitor),
-            Stmt::If(stmt) => stmt.visit_preorder(visitor),
-            Stmt::With(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Match(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Raise(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Try(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Assert(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Import(stmt) => stmt.visit_preorder(visitor),
-            Stmt::ImportFrom(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Pass(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Break(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Continue(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Global(stmt) => stmt.visit_preorder(visitor),
-            Stmt::Nonlocal(stmt) => stmt.visit_preorder(visitor),
-            Stmt::IpyEscapeCommand(stmt) => stmt.visit_preorder(visitor),
+            Stmt::Expr(stmt) => stmt.visit_source_order(visitor),
+            Stmt::FunctionDef(stmt) => stmt.visit_source_order(visitor),
+            Stmt::ClassDef(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Return(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Delete(stmt) => stmt.visit_source_order(visitor),
+            Stmt::TypeAlias(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Assign(stmt) => stmt.visit_source_order(visitor),
+            Stmt::AugAssign(stmt) => stmt.visit_source_order(visitor),
+            Stmt::AnnAssign(stmt) => stmt.visit_source_order(visitor),
+            Stmt::For(stmt) => stmt.visit_source_order(visitor),
+            Stmt::While(stmt) => stmt.visit_source_order(visitor),
+            Stmt::If(stmt) => stmt.visit_source_order(visitor),
+            Stmt::With(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Match(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Raise(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Try(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Assert(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Import(stmt) => stmt.visit_source_order(visitor),
+            Stmt::ImportFrom(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Pass(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Break(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Continue(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Global(stmt) => stmt.visit_source_order(visitor),
+            Stmt::Nonlocal(stmt) => stmt.visit_source_order(visitor),
+            Stmt::IpyEscapeCommand(stmt) => stmt.visit_source_order(visitor),
         }
     }
 
@@ -244,7 +247,7 @@ impl TraversalSignal {
     }
 }
 
-pub fn walk_annotation<'a, V: PreorderVisitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
+pub fn walk_annotation<'a, V: SourceOrderVisitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
     let node = AnyNodeRef::from(expr);
     if visitor.enter_node(node).is_traverse() {
         visitor.visit_expr(expr);
@@ -255,11 +258,11 @@ pub fn walk_annotation<'a, V: PreorderVisitor<'a> + ?Sized>(visitor: &mut V, exp
 
 pub fn walk_decorator<'a, V>(visitor: &mut V, decorator: &'a Decorator)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(decorator);
     if visitor.enter_node(node).is_traverse() {
-        decorator.visit_preorder(visitor);
+        decorator.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -267,43 +270,43 @@ where
 
 pub fn walk_expr<'a, V>(visitor: &mut V, expr: &'a Expr)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(expr);
     if visitor.enter_node(node).is_traverse() {
         match expr {
-            Expr::BoolOp(expr) => expr.visit_preorder(visitor),
-            Expr::Named(expr) => expr.visit_preorder(visitor),
-            Expr::BinOp(expr) => expr.visit_preorder(visitor),
-            Expr::UnaryOp(expr) => expr.visit_preorder(visitor),
-            Expr::Lambda(expr) => expr.visit_preorder(visitor),
-            Expr::If(expr) => expr.visit_preorder(visitor),
-            Expr::Dict(expr) => expr.visit_preorder(visitor),
-            Expr::Set(expr) => expr.visit_preorder(visitor),
-            Expr::ListComp(expr) => expr.visit_preorder(visitor),
-            Expr::SetComp(expr) => expr.visit_preorder(visitor),
-            Expr::DictComp(expr) => expr.visit_preorder(visitor),
-            Expr::Generator(expr) => expr.visit_preorder(visitor),
-            Expr::Await(expr) => expr.visit_preorder(visitor),
-            Expr::Yield(expr) => expr.visit_preorder(visitor),
-            Expr::YieldFrom(expr) => expr.visit_preorder(visitor),
-            Expr::Compare(expr) => expr.visit_preorder(visitor),
-            Expr::Call(expr) => expr.visit_preorder(visitor),
-            Expr::FString(expr) => expr.visit_preorder(visitor),
-            Expr::StringLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::BytesLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::NumberLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::BooleanLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::NoneLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::EllipsisLiteral(expr) => expr.visit_preorder(visitor),
-            Expr::Attribute(expr) => expr.visit_preorder(visitor),
-            Expr::Subscript(expr) => expr.visit_preorder(visitor),
-            Expr::Starred(expr) => expr.visit_preorder(visitor),
-            Expr::Name(expr) => expr.visit_preorder(visitor),
-            Expr::List(expr) => expr.visit_preorder(visitor),
-            Expr::Tuple(expr) => expr.visit_preorder(visitor),
-            Expr::Slice(expr) => expr.visit_preorder(visitor),
-            Expr::IpyEscapeCommand(expr) => expr.visit_preorder(visitor),
+            Expr::BoolOp(expr) => expr.visit_source_order(visitor),
+            Expr::Named(expr) => expr.visit_source_order(visitor),
+            Expr::BinOp(expr) => expr.visit_source_order(visitor),
+            Expr::UnaryOp(expr) => expr.visit_source_order(visitor),
+            Expr::Lambda(expr) => expr.visit_source_order(visitor),
+            Expr::If(expr) => expr.visit_source_order(visitor),
+            Expr::Dict(expr) => expr.visit_source_order(visitor),
+            Expr::Set(expr) => expr.visit_source_order(visitor),
+            Expr::ListComp(expr) => expr.visit_source_order(visitor),
+            Expr::SetComp(expr) => expr.visit_source_order(visitor),
+            Expr::DictComp(expr) => expr.visit_source_order(visitor),
+            Expr::Generator(expr) => expr.visit_source_order(visitor),
+            Expr::Await(expr) => expr.visit_source_order(visitor),
+            Expr::Yield(expr) => expr.visit_source_order(visitor),
+            Expr::YieldFrom(expr) => expr.visit_source_order(visitor),
+            Expr::Compare(expr) => expr.visit_source_order(visitor),
+            Expr::Call(expr) => expr.visit_source_order(visitor),
+            Expr::FString(expr) => expr.visit_source_order(visitor),
+            Expr::StringLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::BytesLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::NumberLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::BooleanLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::NoneLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::EllipsisLiteral(expr) => expr.visit_source_order(visitor),
+            Expr::Attribute(expr) => expr.visit_source_order(visitor),
+            Expr::Subscript(expr) => expr.visit_source_order(visitor),
+            Expr::Starred(expr) => expr.visit_source_order(visitor),
+            Expr::Name(expr) => expr.visit_source_order(visitor),
+            Expr::List(expr) => expr.visit_source_order(visitor),
+            Expr::Tuple(expr) => expr.visit_source_order(visitor),
+            Expr::Slice(expr) => expr.visit_source_order(visitor),
+            Expr::IpyEscapeCommand(expr) => expr.visit_source_order(visitor),
         }
     }
 
@@ -312,11 +315,11 @@ where
 
 pub fn walk_comprehension<'a, V>(visitor: &mut V, comprehension: &'a Comprehension)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(comprehension);
     if visitor.enter_node(node).is_traverse() {
-        comprehension.visit_preorder(visitor);
+        comprehension.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -324,11 +327,11 @@ where
 
 pub fn walk_elif_else_clause<'a, V>(visitor: &mut V, elif_else_clause: &'a ElifElseClause)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(elif_else_clause);
     if visitor.enter_node(node).is_traverse() {
-        elif_else_clause.visit_preorder(visitor);
+        elif_else_clause.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -336,18 +339,20 @@ where
 
 pub fn walk_except_handler<'a, V>(visitor: &mut V, except_handler: &'a ExceptHandler)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(except_handler);
     if visitor.enter_node(node).is_traverse() {
         match except_handler {
-            ExceptHandler::ExceptHandler(except_handler) => except_handler.visit_preorder(visitor),
+            ExceptHandler::ExceptHandler(except_handler) => {
+                except_handler.visit_source_order(visitor);
+            }
         }
     }
     visitor.leave_node(node);
 }
 
-pub fn walk_format_spec<'a, V: PreorderVisitor<'a> + ?Sized>(
+pub fn walk_format_spec<'a, V: SourceOrderVisitor<'a> + ?Sized>(
     visitor: &mut V,
     format_spec: &'a Expr,
 ) {
@@ -361,11 +366,11 @@ pub fn walk_format_spec<'a, V: PreorderVisitor<'a> + ?Sized>(
 
 pub fn walk_arguments<'a, V>(visitor: &mut V, arguments: &'a Arguments)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(arguments);
     if visitor.enter_node(node).is_traverse() {
-        arguments.visit_preorder(visitor);
+        arguments.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -373,11 +378,11 @@ where
 
 pub fn walk_parameters<'a, V>(visitor: &mut V, parameters: &'a Parameters)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(parameters);
     if visitor.enter_node(node).is_traverse() {
-        parameters.visit_preorder(visitor);
+        parameters.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -385,12 +390,12 @@ where
 
 pub fn walk_parameter<'a, V>(visitor: &mut V, parameter: &'a Parameter)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(parameter);
 
     if visitor.enter_node(node).is_traverse() {
-        parameter.visit_preorder(visitor);
+        parameter.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
@@ -399,11 +404,11 @@ pub fn walk_parameter_with_default<'a, V>(
     visitor: &mut V,
     parameter_with_default: &'a ParameterWithDefault,
 ) where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(parameter_with_default);
     if visitor.enter_node(node).is_traverse() {
-        parameter_with_default.visit_preorder(visitor);
+        parameter_with_default.visit_source_order(visitor);
     }
 
     visitor.leave_node(node);
@@ -412,48 +417,48 @@ pub fn walk_parameter_with_default<'a, V>(
 #[inline]
 pub fn walk_keyword<'a, V>(visitor: &mut V, keyword: &'a Keyword)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(keyword);
 
     if visitor.enter_node(node).is_traverse() {
-        keyword.visit_preorder(visitor);
+        keyword.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
 
 pub fn walk_with_item<'a, V>(visitor: &mut V, with_item: &'a WithItem)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(with_item);
     if visitor.enter_node(node).is_traverse() {
-        with_item.visit_preorder(visitor);
+        with_item.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
 
 pub fn walk_type_params<'a, V>(visitor: &mut V, type_params: &'a TypeParams)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(type_params);
     if visitor.enter_node(node).is_traverse() {
-        type_params.visit_preorder(visitor);
+        type_params.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
 
 pub fn walk_type_param<'a, V>(visitor: &mut V, type_param: &'a TypeParam)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(type_param);
     if visitor.enter_node(node).is_traverse() {
         match type_param {
-            TypeParam::TypeVar(type_param) => type_param.visit_preorder(visitor),
-            TypeParam::TypeVarTuple(type_param) => type_param.visit_preorder(visitor),
-            TypeParam::ParamSpec(type_param) => type_param.visit_preorder(visitor),
+            TypeParam::TypeVar(type_param) => type_param.visit_source_order(visitor),
+            TypeParam::TypeVarTuple(type_param) => type_param.visit_source_order(visitor),
+            TypeParam::ParamSpec(type_param) => type_param.visit_source_order(visitor),
         }
     }
     visitor.leave_node(node);
@@ -461,30 +466,30 @@ where
 
 pub fn walk_match_case<'a, V>(visitor: &mut V, match_case: &'a MatchCase)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(match_case);
     if visitor.enter_node(node).is_traverse() {
-        match_case.visit_preorder(visitor);
+        match_case.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
 
 pub fn walk_pattern<'a, V>(visitor: &mut V, pattern: &'a Pattern)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(pattern);
     if visitor.enter_node(node).is_traverse() {
         match pattern {
-            Pattern::MatchValue(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchSingleton(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchSequence(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchMapping(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchClass(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchStar(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchAs(pattern) => pattern.visit_preorder(visitor),
-            Pattern::MatchOr(pattern) => pattern.visit_preorder(visitor),
+            Pattern::MatchValue(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchSingleton(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchSequence(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchMapping(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchClass(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchStar(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchAs(pattern) => pattern.visit_source_order(visitor),
+            Pattern::MatchOr(pattern) => pattern.visit_source_order(visitor),
         }
     }
     visitor.leave_node(node);
@@ -492,7 +497,7 @@ where
 
 pub fn walk_pattern_arguments<'a, V>(visitor: &mut V, pattern_arguments: &'a PatternArguments)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(pattern_arguments);
     if visitor.enter_node(node).is_traverse() {
@@ -508,7 +513,7 @@ where
 
 pub fn walk_pattern_keyword<'a, V>(visitor: &mut V, pattern_keyword: &'a PatternKeyword)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(pattern_keyword);
     if visitor.enter_node(node).is_traverse() {
@@ -517,15 +522,15 @@ where
     visitor.leave_node(node);
 }
 
-pub fn walk_f_string_element<'a, V: PreorderVisitor<'a> + ?Sized>(
+pub fn walk_f_string_element<'a, V: SourceOrderVisitor<'a> + ?Sized>(
     visitor: &mut V,
     f_string_element: &'a FStringElement,
 ) {
     let node = AnyNodeRef::from(f_string_element);
     if visitor.enter_node(node).is_traverse() {
         match f_string_element {
-            FStringElement::Expression(element) => element.visit_preorder(visitor),
-            FStringElement::Literal(element) => element.visit_preorder(visitor),
+            FStringElement::Expression(element) => element.visit_source_order(visitor),
+            FStringElement::Literal(element) => element.visit_source_order(visitor),
         }
     }
     visitor.leave_node(node);
@@ -533,39 +538,39 @@ pub fn walk_f_string_element<'a, V: PreorderVisitor<'a> + ?Sized>(
 
 pub fn walk_bool_op<'a, V>(_visitor: &mut V, _bool_op: &'a BoolOp)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
 }
 
 #[inline]
 pub fn walk_operator<'a, V>(_visitor: &mut V, _operator: &'a Operator)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
 }
 
 #[inline]
 pub fn walk_unary_op<'a, V>(_visitor: &mut V, _unary_op: &'a UnaryOp)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
 }
 
 #[inline]
 pub fn walk_cmp_op<'a, V>(_visitor: &mut V, _cmp_op: &'a CmpOp)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
 }
 
 #[inline]
 pub fn walk_f_string<'a, V>(visitor: &mut V, f_string: &'a FString)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(f_string);
     if visitor.enter_node(node).is_traverse() {
-        f_string.visit_preorder(visitor);
+        f_string.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
@@ -573,11 +578,11 @@ where
 #[inline]
 pub fn walk_string_literal<'a, V>(visitor: &mut V, string_literal: &'a StringLiteral)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(string_literal);
     if visitor.enter_node(node).is_traverse() {
-        string_literal.visit_preorder(visitor);
+        string_literal.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
@@ -585,11 +590,11 @@ where
 #[inline]
 pub fn walk_bytes_literal<'a, V>(visitor: &mut V, bytes_literal: &'a BytesLiteral)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(bytes_literal);
     if visitor.enter_node(node).is_traverse() {
-        bytes_literal.visit_preorder(visitor);
+        bytes_literal.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }
@@ -597,11 +602,11 @@ where
 #[inline]
 pub fn walk_alias<'a, V>(visitor: &mut V, alias: &'a Alias)
 where
-    V: PreorderVisitor<'a> + ?Sized,
+    V: SourceOrderVisitor<'a> + ?Sized,
 {
     let node = AnyNodeRef::from(alias);
     if visitor.enter_node(node).is_traverse() {
-        alias.visit_preorder(visitor);
+        alias.visit_source_order(visitor);
     }
     visitor.leave_node(node);
 }

crates/ruff_python_ast_integration_tests/tests/source_order.rs

@@ -2,7 +2,7 @@ use std::fmt::{Debug, Write};
 
 use insta::assert_snapshot;
 
-use ruff_python_ast::visitor::preorder::{PreorderVisitor, TraversalSignal};
+use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
 use ruff_python_ast::{AnyNodeRef, BoolOp, CmpOp, Operator, Singleton, UnaryOp};
 use ruff_python_parser::{parse, Mode};
 
@@ -10,7 +10,7 @@ use ruff_python_parser::{parse, Mode};
 fn function_arguments() {
     let source = r"def a(b, c,/, d, e = 20, *args, named=5, other=20, **kwargs): pass";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -19,7 +19,7 @@ fn function_arguments() {
 fn function_positional_only_with_default() {
     let source = r"def a(b, c = 34,/, e = 20, *args): pass";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -28,7 +28,7 @@ fn function_positional_only_with_default() {
 fn compare() {
     let source = r"4 < x < 5";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -37,7 +37,7 @@ fn compare() {
 fn list_comprehension() {
     let source = "[x for x in numbers]";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -46,7 +46,7 @@ fn list_comprehension() {
 fn dict_comprehension() {
     let source = "{x: x**2 for x in numbers}";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -55,7 +55,7 @@ fn dict_comprehension() {
 fn set_comprehension() {
     let source = "{x for x in numbers}";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -70,7 +70,7 @@ match x:
         ...
 ";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -87,7 +87,7 @@ class A:
     pass
 ";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -96,7 +96,7 @@ class A:
 fn type_aliases() {
     let source = r"type X[T: str, U, *Ts, **P] = list[T]";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -105,7 +105,7 @@ fn type_aliases() {
 fn class_type_parameters() {
     let source = r"class X[T: str, U, *Ts, **P]: ...";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -114,7 +114,7 @@ fn class_type_parameters() {
 fn function_type_parameters() {
     let source = r"def X[T: str, U, *Ts, **P](): ...";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -123,7 +123,7 @@ fn function_type_parameters() {
 fn string_literals() {
     let source = r"'a' 'b' 'c'";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -132,7 +132,7 @@ fn string_literals() {
 fn bytes_literals() {
     let source = r"b'a' b'b' b'c'";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
@@ -141,12 +141,12 @@ fn bytes_literals() {
 fn f_strings() {
     let source = r"'pre' f'foo {bar:.{x}f} baz'";
 
-    let trace = trace_preorder_visitation(source);
+    let trace = trace_source_order_visitation(source);
 
     assert_snapshot!(trace);
 }
 
-fn trace_preorder_visitation(source: &str) -> String {
+fn trace_source_order_visitation(source: &str) -> String {
     let parsed = parse(source, Mode::Module).unwrap();
 
     let mut visitor = RecordVisitor::default();
@@ -173,7 +173,7 @@ impl RecordVisitor {
     }
 }
 
-impl<'a> PreorderVisitor<'a> for RecordVisitor {
+impl<'a> SourceOrderVisitor<'a> for RecordVisitor {
     fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
         self.emit(&node.kind());
         self.depth += 1;

crates/ruff_python_formatter/src/comments/mod.rs

@@ -406,11 +406,11 @@ impl<'a> Comments<'a> {
     /// normally if `node` is the first or last node of a suppression range.
     #[cfg(debug_assertions)]
     pub(crate) fn mark_verbatim_node_comments_formatted(&self, node: AnyNodeRef) {
-        use ruff_python_ast::visitor::preorder::{PreorderVisitor, TraversalSignal};
+        use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
 
         struct MarkVerbatimCommentsAsFormattedVisitor<'a>(&'a Comments<'a>);
 
-        impl<'a> PreorderVisitor<'a> for MarkVerbatimCommentsAsFormattedVisitor<'a> {
+        impl<'a> SourceOrderVisitor<'a> for MarkVerbatimCommentsAsFormattedVisitor<'a> {
             fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
                 for comment in self.0.leading_dangling_trailing(node) {
                     comment.mark_formatted();

crates/ruff_python_formatter/src/comments/visitor.rs

@@ -7,7 +7,7 @@ use ruff_python_ast::{Mod, Stmt};
 // The interface is designed to only export the members relevant for iterating nodes in
 // pre-order.
 #[allow(clippy::wildcard_imports)]
-use ruff_python_ast::visitor::preorder::*;
+use ruff_python_ast::visitor::source_order::*;
 use ruff_python_trivia::{CommentLinePosition, CommentRanges};
 use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextRange, TextSize};
@@ -70,7 +70,7 @@ impl<'a, 'builder> CommentsVisitor<'a, 'builder> {
     }
 }
 
-impl<'ast> PreorderVisitor<'ast> for CommentsVisitor<'ast, '_> {
+impl<'ast> SourceOrderVisitor<'ast> for CommentsVisitor<'ast, '_> {
     fn enter_node(&mut self, node: AnyNodeRef<'ast>) -> TraversalSignal {
         let node_range = node.range();
 

crates/ruff_python_formatter/src/expression/mod.rs

@@ -6,7 +6,7 @@ use ruff_formatter::{
 };
 use ruff_python_ast as ast;
 use ruff_python_ast::parenthesize::parentheses_iterator;
-use ruff_python_ast::visitor::preorder::{walk_expr, PreorderVisitor};
+use ruff_python_ast::visitor::source_order::{walk_expr, SourceOrderVisitor};
 use ruff_python_ast::{AnyNodeRef, Expr, ExpressionRef, Operator};
 use ruff_python_trivia::CommentRanges;
 use ruff_text_size::Ranged;
@@ -806,7 +806,7 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> {
     }
 }
 
-impl<'input> PreorderVisitor<'input> for CanOmitOptionalParenthesesVisitor<'input> {
+impl<'input> SourceOrderVisitor<'input> for CanOmitOptionalParenthesesVisitor<'input> {
     fn visit_expr(&mut self, expr: &'input Expr) {
         self.last = Some(expr);
 

crates/ruff_python_formatter/src/range.rs

@@ -4,7 +4,7 @@ use ruff_formatter::printer::SourceMapGeneration;
 use ruff_formatter::{
     format, FormatContext, FormatError, FormatOptions, IndentStyle, PrintedRange, SourceCode,
 };
-use ruff_python_ast::visitor::preorder::{walk_body, PreorderVisitor, TraversalSignal};
+use ruff_python_ast::visitor::source_order::{walk_body, SourceOrderVisitor, TraversalSignal};
 use ruff_python_ast::{AnyNodeRef, Stmt, StmtMatch, StmtTry};
 use ruff_python_parser::{parse, AsMode};
 use ruff_python_trivia::{indentation_at_offset, BackwardsTokenizer, SimpleToken, SimpleTokenKind};
@@ -181,7 +181,7 @@ impl<'a, 'ast> FindEnclosingNode<'a, 'ast> {
     }
 }
 
-impl<'ast> PreorderVisitor<'ast> for FindEnclosingNode<'_, 'ast> {
+impl<'ast> SourceOrderVisitor<'ast> for FindEnclosingNode<'_, 'ast> {
     fn enter_node(&mut self, node: AnyNodeRef<'ast>) -> TraversalSignal {
         if !(is_logical_line(node) || node.is_mod_module()) {
             return TraversalSignal::Skip;
@@ -336,7 +336,7 @@ struct NarrowRange<'a> {
     level: usize,
 }
 
-impl PreorderVisitor<'_> for NarrowRange<'_> {
+impl SourceOrderVisitor<'_> for NarrowRange<'_> {
     fn enter_node(&mut self, node: AnyNodeRef<'_>) -> TraversalSignal {
         if !(is_logical_line(node) || node.is_mod_module()) {
             return TraversalSignal::Skip;

crates/ruff_python_parser/tests/fixtures.rs

@@ -6,7 +6,7 @@ use std::path::Path;
 use annotate_snippets::display_list::{DisplayList, FormatOptions};
 use annotate_snippets::snippet::{AnnotationType, Slice, Snippet, SourceAnnotation};
 
-use ruff_python_ast::visitor::preorder::{walk_module, PreorderVisitor, TraversalSignal};
+use ruff_python_ast::visitor::source_order::{walk_module, SourceOrderVisitor, TraversalSignal};
 use ruff_python_ast::{AnyNodeRef, Mod};
 use ruff_python_parser::{parse_unchecked, Mode, ParseErrorType};
 use ruff_source_file::{LineIndex, OneIndexed, SourceCode};
@@ -258,7 +258,7 @@ impl<'a> ValidateAstVisitor<'a> {
     }
 }
 
-impl<'ast> PreorderVisitor<'ast> for ValidateAstVisitor<'ast> {
+impl<'ast> SourceOrderVisitor<'ast> for ValidateAstVisitor<'ast> {
     fn enter_node(&mut self, node: AnyNodeRef<'ast>) -> TraversalSignal {
         assert!(
             node.end() <= self.source_length,