From 32ca704956fa8d1ba9bdaf8bc141a03b16f7fcf2 Mon Sep 17 00:00:00 2001 From: Micha Reiser Date: Fri, 7 Jun 2024 19:01:58 +0200 Subject: [PATCH] Rename `PreorderVisitor` to `SourceOrderVisitor` (#11798) Co-authored-by: Alex Waygood --- crates/red_knot/src/ast_ids.rs | 22 +- crates/red_knot/src/semantic.rs | 10 +- .../ruff/rules/suppression_comment_visitor.rs | 6 +- .../src/rules/ruff/rules/unused_async.rs | 22 +- crates/ruff_python_ast/src/node.rs | 618 +++++++++--------- crates/ruff_python_ast/src/visitor.rs | 6 +- .../visitor/{preorder.rs => source_order.rs} | 247 +++---- ...snap => source_order__bytes_literals.snap} | 0 ... source_order__class_type_parameters.snap} | 0 ...ompare.snap => source_order__compare.snap} | 0 ...ors.snap => source_order__decorators.snap} | 0 ... => source_order__dict_comprehension.snap} | 0 ...ings.snap => source_order__f_strings.snap} | 0 ... => source_order__function_arguments.snap} | 0 ...unction_positional_only_with_default.snap} | 0 ...urce_order__function_type_parameters.snap} | 0 ... => source_order__list_comprehension.snap} | 0 ...=> source_order__match_class_pattern.snap} | 0 ...p => source_order__set_comprehension.snap} | 0 ...nap => source_order__string_literals.snap} | 0 ...s.snap => source_order__type_aliases.snap} | 0 .../tests/{preorder.rs => source_order.rs} | 34 +- .../ruff_python_formatter/src/comments/mod.rs | 4 +- .../src/comments/visitor.rs | 4 +- .../src/expression/mod.rs | 4 +- crates/ruff_python_formatter/src/range.rs | 6 +- crates/ruff_python_parser/tests/fixtures.rs | 4 +- 27 files changed, 496 insertions(+), 491 deletions(-) rename crates/ruff_python_ast/src/visitor/{preorder.rs => source_order.rs} (61%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__bytes_literals.snap => source_order__bytes_literals.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__class_type_parameters.snap => source_order__class_type_parameters.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__compare.snap => source_order__compare.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__decorators.snap => source_order__decorators.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__dict_comprehension.snap => source_order__dict_comprehension.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__f_strings.snap => source_order__f_strings.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__function_arguments.snap => source_order__function_arguments.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__function_positional_only_with_default.snap => source_order__function_positional_only_with_default.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__function_type_parameters.snap => source_order__function_type_parameters.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__list_comprehension.snap => source_order__list_comprehension.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__match_class_pattern.snap => source_order__match_class_pattern.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__set_comprehension.snap => source_order__set_comprehension.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__string_literals.snap => source_order__string_literals.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/snapshots/{preorder__type_aliases.snap => source_order__type_aliases.snap} (100%) rename crates/ruff_python_ast_integration_tests/tests/{preorder.rs => source_order.rs} (76%) diff --git a/crates/red_knot/src/ast_ids.rs b/crates/red_knot/src/ast_ids.rs index 0229fb748e..5d88bf2f46 100644 --- a/crates/red_knot/src/ast_ids.rs +++ b/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>, } -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; diff --git a/crates/red_knot/src/semantic.rs b/crates/red_knot/src/semantic.rs index c78b09fc99..fc8a28498f 100644 --- a/crates/red_knot/src/semantic.rs +++ b/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); } } } diff --git a/crates/ruff_linter/src/rules/ruff/rules/suppression_comment_visitor.rs b/crates/ruff_linter/src/rules/ruff/rules/suppression_comment_visitor.rs index fe7f6ffa61..113f0a000f 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/suppression_comment_visitor.rs +++ b/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 + '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); } } } diff --git a/crates/ruff_linter/src/rules/ruff/rules/unused_async.rs b/crates/ruff_linter/src/rules/ruff/rules/unused_async.rs index ba9a019571..dc5ff79310 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/unused_async.rs +++ b/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 }; diff --git a/crates/ruff_python_ast/src/node.rs b/crates/ruff_python_ast/src/node.rs index d8c2e3eacf..34b8406a5e 100644 --- a/crates/ruff_python_ast/src/node.rs +++ b/crates/ruff_python_ast/src/node.rs @@ -1,4 +1,4 @@ -use crate::visitor::preorder::PreorderVisitor; +use crate::visitor::source_order::SourceOrderVisitor; use crate::{ self as ast, Alias, AnyParameterRef, ArgOrKeyword, Arguments, Comprehension, Decorator, ExceptHandler, Expr, FStringElement, Keyword, MatchCase, Mod, Parameter, ParameterWithDefault, @@ -28,9 +28,9 @@ pub trait AstNode: Ranged { /// Consumes `self` and returns its [`AnyNode`] representation. fn into_any_node(self) -> AnyNode; - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized; + V: SourceOrderVisitor<'a> + ?Sized; } #[derive(Clone, Debug, is_macro::Is, PartialEq)] @@ -677,9 +677,9 @@ impl AstNode for ast::ModModule { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ModModule { body, range: _ } = self; visitor.visit_body(body); @@ -720,9 +720,9 @@ impl AstNode for ast::ModExpression { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ModExpression { body, range: _ } = self; visitor.visit_expr(body); @@ -762,9 +762,9 @@ impl AstNode for ast::StmtFunctionDef { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtFunctionDef { parameters, @@ -826,9 +826,9 @@ impl AstNode for ast::StmtClassDef { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtClassDef { arguments, @@ -886,9 +886,9 @@ impl AstNode for ast::StmtReturn { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtReturn { value, range: _ } = self; if let Some(expr) = value { @@ -929,9 +929,9 @@ impl AstNode for ast::StmtDelete { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtDelete { targets, range: _ } = self; for expr in targets { @@ -972,9 +972,9 @@ impl AstNode for ast::StmtTypeAlias { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtTypeAlias { range: _, @@ -1023,9 +1023,9 @@ impl AstNode for ast::StmtAssign { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtAssign { targets, @@ -1073,9 +1073,9 @@ impl AstNode for ast::StmtAugAssign { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtAugAssign { target, @@ -1122,9 +1122,9 @@ impl AstNode for ast::StmtAnnAssign { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtAnnAssign { target, @@ -1174,9 +1174,9 @@ impl AstNode for ast::StmtFor { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtFor { target, @@ -1225,9 +1225,9 @@ impl AstNode for ast::StmtWhile { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtWhile { test, @@ -1274,9 +1274,9 @@ impl AstNode for ast::StmtIf { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtIf { test, @@ -1325,9 +1325,9 @@ impl AstNode for ast::ElifElseClause { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ElifElseClause { range: _, @@ -1373,9 +1373,9 @@ impl AstNode for ast::StmtWith { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtWith { items, @@ -1423,9 +1423,9 @@ impl AstNode for ast::StmtMatch { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtMatch { subject, @@ -1472,9 +1472,9 @@ impl AstNode for ast::StmtRaise { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtRaise { exc, @@ -1523,9 +1523,9 @@ impl AstNode for ast::StmtTry { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtTry { body, @@ -1577,9 +1577,9 @@ impl AstNode for ast::StmtAssert { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtAssert { test, @@ -1625,9 +1625,9 @@ impl AstNode for ast::StmtImport { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtImport { names, range: _ } = self; @@ -1669,9 +1669,9 @@ impl AstNode for ast::StmtImportFrom { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtImportFrom { range: _, @@ -1719,9 +1719,9 @@ impl AstNode for ast::StmtGlobal { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -1759,9 +1759,9 @@ impl AstNode for ast::StmtNonlocal { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -1798,9 +1798,9 @@ impl AstNode for ast::StmtExpr { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::StmtExpr { value, range: _ } = self; @@ -1841,9 +1841,9 @@ impl AstNode for ast::StmtPass { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -1881,9 +1881,9 @@ impl AstNode for ast::StmtBreak { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -1921,9 +1921,9 @@ impl AstNode for ast::StmtContinue { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -1961,9 +1961,9 @@ impl AstNode for ast::StmtIpyEscapeCommand { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -2000,9 +2000,9 @@ impl AstNode for ast::ExprBoolOp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprBoolOp { op, @@ -2056,9 +2056,9 @@ impl AstNode for ast::ExprNamed { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprNamed { target, @@ -2102,9 +2102,9 @@ impl AstNode for ast::ExprBinOp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprBinOp { left, @@ -2150,9 +2150,9 @@ impl AstNode for ast::ExprUnaryOp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprUnaryOp { op, @@ -2198,9 +2198,9 @@ impl AstNode for ast::ExprLambda { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprLambda { parameters, @@ -2247,9 +2247,9 @@ impl AstNode for ast::ExprIf { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprIf { test, @@ -2297,9 +2297,9 @@ impl AstNode for ast::ExprDict { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprDict { items, range: _ } = self; @@ -2344,9 +2344,9 @@ impl AstNode for ast::ExprSet { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprSet { elts, range: _ } = self; @@ -2388,9 +2388,9 @@ impl AstNode for ast::ExprListComp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprListComp { elt, @@ -2437,9 +2437,9 @@ impl AstNode for ast::ExprSetComp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprSetComp { elt, @@ -2486,9 +2486,9 @@ impl AstNode for ast::ExprDictComp { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprDictComp { key, @@ -2538,9 +2538,9 @@ impl AstNode for ast::ExprGenerator { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprGenerator { elt, @@ -2587,9 +2587,9 @@ impl AstNode for ast::ExprAwait { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprAwait { value, range: _ } = self; visitor.visit_expr(value); @@ -2628,9 +2628,9 @@ impl AstNode for ast::ExprYield { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprYield { value, range: _ } = self; if let Some(expr) = value { @@ -2671,9 +2671,9 @@ impl AstNode for ast::ExprYieldFrom { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprYieldFrom { value, range: _ } = self; visitor.visit_expr(value); @@ -2712,9 +2712,9 @@ impl AstNode for ast::ExprCompare { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprCompare { left, @@ -2764,9 +2764,9 @@ impl AstNode for ast::ExprCall { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprCall { func, @@ -2810,9 +2810,9 @@ impl AstNode for ast::FStringFormatSpec { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { for element in &self.elements { visitor.visit_f_string_element(element); @@ -2852,9 +2852,9 @@ impl AstNode for ast::FStringExpressionElement { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::FStringExpressionElement { expression, @@ -2903,9 +2903,9 @@ impl AstNode for ast::FStringLiteralElement { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -2942,9 +2942,9 @@ impl AstNode for ast::ExprFString { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprFString { value, range: _ } = self; @@ -2993,9 +2993,9 @@ impl AstNode for ast::ExprStringLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprStringLiteral { value, range: _ } = self; @@ -3037,9 +3037,9 @@ impl AstNode for ast::ExprBytesLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprBytesLiteral { value, range: _ } = self; @@ -3081,9 +3081,9 @@ impl AstNode for ast::ExprNumberLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -3120,9 +3120,9 @@ impl AstNode for ast::ExprBooleanLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -3159,9 +3159,9 @@ impl AstNode for ast::ExprNoneLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -3198,9 +3198,9 @@ impl AstNode for ast::ExprEllipsisLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -3237,9 +3237,9 @@ impl AstNode for ast::ExprAttribute { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprAttribute { value, @@ -3284,9 +3284,9 @@ impl AstNode for ast::ExprSubscript { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprSubscript { value, @@ -3331,9 +3331,9 @@ impl AstNode for ast::ExprStarred { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprStarred { value, @@ -3378,9 +3378,9 @@ impl AstNode for ast::ExprName { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprName { id: _, @@ -3422,9 +3422,9 @@ impl AstNode for ast::ExprList { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprList { elts, @@ -3470,9 +3470,9 @@ impl AstNode for ast::ExprTuple { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprTuple { elts, @@ -3518,9 +3518,9 @@ impl AstNode for ast::ExprSlice { fn into_any_node(self) -> AnyNode { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprSlice { lower, @@ -3574,9 +3574,9 @@ impl AstNode for ast::ExprIpyEscapeCommand { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExprIpyEscapeCommand { range: _, @@ -3618,9 +3618,9 @@ impl AstNode for ast::ExceptHandlerExceptHandler { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ExceptHandlerExceptHandler { range: _, @@ -3667,9 +3667,9 @@ impl AstNode for ast::PatternMatchValue { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchValue { value, range: _ } = self; visitor.visit_expr(value); @@ -3708,9 +3708,9 @@ impl AstNode for ast::PatternMatchSingleton { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchSingleton { value, range: _ } = self; visitor.visit_singleton(value); @@ -3749,9 +3749,9 @@ impl AstNode for ast::PatternMatchSequence { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchSequence { patterns, range: _ } = self; for pattern in patterns { @@ -3792,9 +3792,9 @@ impl AstNode for ast::PatternMatchMapping { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchMapping { keys, @@ -3841,9 +3841,9 @@ impl AstNode for ast::PatternMatchClass { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchClass { cls, @@ -3888,9 +3888,9 @@ impl AstNode for ast::PatternMatchStar { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchStar { range: _, name: _ } = self; } @@ -3928,9 +3928,9 @@ impl AstNode for ast::PatternMatchAs { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchAs { pattern, @@ -3975,9 +3975,9 @@ impl AstNode for ast::PatternMatchOr { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::PatternMatchOr { patterns, range: _ } = self; for pattern in patterns { @@ -4018,9 +4018,9 @@ impl AstNode for PatternArguments { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let PatternArguments { range: _, @@ -4070,9 +4070,9 @@ impl AstNode for PatternKeyword { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let PatternKeyword { range: _, @@ -4117,9 +4117,9 @@ impl AstNode for Comprehension { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::Comprehension { range: _, @@ -4169,9 +4169,9 @@ impl AstNode for Arguments { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { for arg_or_keyword in self.arguments_source_order() { match arg_or_keyword { @@ -4214,9 +4214,9 @@ impl AstNode for Parameters { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { for parameter in self { match parameter { @@ -4261,9 +4261,9 @@ impl AstNode for Parameter { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::Parameter { range: _, @@ -4309,9 +4309,9 @@ impl AstNode for ParameterWithDefault { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::ParameterWithDefault { range: _, @@ -4357,9 +4357,9 @@ impl AstNode for Keyword { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::Keyword { range: _, @@ -4404,9 +4404,9 @@ impl AstNode for Alias { } #[inline] - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::Alias { range: _, @@ -4448,9 +4448,9 @@ impl AstNode for WithItem { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::WithItem { range: _, @@ -4498,9 +4498,9 @@ impl AstNode for MatchCase { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::MatchCase { range: _, @@ -4550,9 +4550,9 @@ impl AstNode for Decorator { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::Decorator { range: _, @@ -4595,9 +4595,9 @@ impl AstNode for ast::TypeParams { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::TypeParams { range: _, @@ -4642,9 +4642,9 @@ impl AstNode for ast::TypeParamTypeVar { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::TypeParamTypeVar { bound, @@ -4695,9 +4695,9 @@ impl AstNode for ast::TypeParamTypeVarTuple { } #[inline] - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::TypeParamTypeVarTuple { range: _, @@ -4743,9 +4743,9 @@ impl AstNode for ast::TypeParamParamSpec { } #[inline] - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::TypeParamParamSpec { range: _, @@ -4790,9 +4790,9 @@ impl AstNode for ast::FString { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { let ast::FString { elements, @@ -4838,9 +4838,9 @@ impl AstNode for ast::StringLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -4877,9 +4877,9 @@ impl AstNode for ast::BytesLiteral { AnyNode::from(self) } - fn visit_preorder<'a, V>(&'a self, _visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, _visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { } } @@ -5241,36 +5241,36 @@ impl AstNode for Stmt { } } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { match self { - 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::Assign(stmt) => stmt.visit_preorder(visitor), - Stmt::AugAssign(stmt) => stmt.visit_preorder(visitor), - Stmt::AnnAssign(stmt) => stmt.visit_preorder(visitor), - Stmt::TypeAlias(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::Global(stmt) => stmt.visit_preorder(visitor), - Stmt::Nonlocal(stmt) => stmt.visit_preorder(visitor), - Stmt::Expr(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::IpyEscapeCommand(stmt) => stmt.visit_preorder(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::Assign(stmt) => stmt.visit_source_order(visitor), + Stmt::AugAssign(stmt) => stmt.visit_source_order(visitor), + Stmt::AnnAssign(stmt) => stmt.visit_source_order(visitor), + Stmt::TypeAlias(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::Global(stmt) => stmt.visit_source_order(visitor), + Stmt::Nonlocal(stmt) => stmt.visit_source_order(visitor), + Stmt::Expr(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::IpyEscapeCommand(stmt) => stmt.visit_source_order(visitor), } } } @@ -5324,14 +5324,14 @@ impl AstNode for TypeParam { } } - fn visit_preorder<'a, V>(&'a self, visitor: &mut V) + fn visit_source_order<'a, V>(&'a self, visitor: &mut V) where - V: PreorderVisitor<'a> + ?Sized, + V: SourceOrderVisitor<'a> + ?Sized, { match self { - TypeParam::TypeVar(node) => node.visit_preorder(visitor), - TypeParam::TypeVarTuple(node) => node.visit_preorder(visitor), - TypeParam::ParamSpec(node) => node.visit_preorder(visitor), + TypeParam::TypeVar(node) => node.visit_source_order(visitor), + TypeParam::TypeVarTuple(node) => node.visit_source_order(visitor), + TypeParam::ParamSpec(node) => node.visit_source_order(visitor), } } } @@ -6871,101 +6871,101 @@ impl<'a> AnyNodeRef<'a> { pub fn visit_preorder<'b, V>(self, visitor: &mut V) where - V: PreorderVisitor<'b> + ?Sized, + V: SourceOrderVisitor<'b> + ?Sized, 'a: 'b, { match self { - AnyNodeRef::ModModule(node) => node.visit_preorder(visitor), - AnyNodeRef::ModExpression(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtFunctionDef(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtClassDef(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtReturn(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtDelete(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtTypeAlias(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtAssign(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtAugAssign(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtAnnAssign(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtFor(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtWhile(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtIf(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtWith(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtMatch(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtRaise(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtTry(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtAssert(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtImport(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtImportFrom(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtGlobal(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtNonlocal(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtExpr(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtPass(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtBreak(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtContinue(node) => node.visit_preorder(visitor), - AnyNodeRef::StmtIpyEscapeCommand(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprBoolOp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprNamed(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprBinOp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprUnaryOp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprLambda(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprIf(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprDict(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprSet(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprListComp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprSetComp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprDictComp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprGenerator(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprAwait(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprYield(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprYieldFrom(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprCompare(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprCall(node) => node.visit_preorder(visitor), - AnyNodeRef::FStringExpressionElement(node) => node.visit_preorder(visitor), - AnyNodeRef::FStringLiteralElement(node) => node.visit_preorder(visitor), - AnyNodeRef::FStringFormatSpec(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprFString(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprStringLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprBytesLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprNumberLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprBooleanLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprNoneLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprEllipsisLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprAttribute(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprSubscript(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprStarred(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprName(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprList(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprTuple(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprSlice(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprIpyEscapeCommand(node) => node.visit_preorder(visitor), - AnyNodeRef::ExceptHandlerExceptHandler(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchValue(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchSingleton(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchSequence(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchMapping(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchClass(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchStar(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchAs(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternMatchOr(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternArguments(node) => node.visit_preorder(visitor), - AnyNodeRef::PatternKeyword(node) => node.visit_preorder(visitor), - AnyNodeRef::Comprehension(node) => node.visit_preorder(visitor), - AnyNodeRef::Arguments(node) => node.visit_preorder(visitor), - AnyNodeRef::Parameters(node) => node.visit_preorder(visitor), - AnyNodeRef::Parameter(node) => node.visit_preorder(visitor), - AnyNodeRef::ParameterWithDefault(node) => node.visit_preorder(visitor), - AnyNodeRef::Keyword(node) => node.visit_preorder(visitor), - AnyNodeRef::Alias(node) => node.visit_preorder(visitor), - AnyNodeRef::WithItem(node) => node.visit_preorder(visitor), - AnyNodeRef::MatchCase(node) => node.visit_preorder(visitor), - AnyNodeRef::Decorator(node) => node.visit_preorder(visitor), - AnyNodeRef::TypeParams(node) => node.visit_preorder(visitor), - AnyNodeRef::TypeParamTypeVar(node) => node.visit_preorder(visitor), - AnyNodeRef::TypeParamTypeVarTuple(node) => node.visit_preorder(visitor), - AnyNodeRef::TypeParamParamSpec(node) => node.visit_preorder(visitor), - AnyNodeRef::FString(node) => node.visit_preorder(visitor), - AnyNodeRef::StringLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::BytesLiteral(node) => node.visit_preorder(visitor), - AnyNodeRef::ElifElseClause(node) => node.visit_preorder(visitor), + AnyNodeRef::ModModule(node) => node.visit_source_order(visitor), + AnyNodeRef::ModExpression(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtFunctionDef(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtClassDef(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtReturn(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtDelete(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtTypeAlias(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtAssign(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtAugAssign(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtAnnAssign(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtFor(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtWhile(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtIf(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtWith(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtMatch(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtRaise(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtTry(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtAssert(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtImport(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtImportFrom(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtGlobal(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtNonlocal(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtExpr(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtPass(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtBreak(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtContinue(node) => node.visit_source_order(visitor), + AnyNodeRef::StmtIpyEscapeCommand(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprBoolOp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprNamed(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprBinOp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprUnaryOp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprLambda(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprIf(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprDict(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprSet(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprListComp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprSetComp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprDictComp(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprGenerator(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprAwait(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprYield(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprYieldFrom(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprCompare(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprCall(node) => node.visit_source_order(visitor), + AnyNodeRef::FStringExpressionElement(node) => node.visit_source_order(visitor), + AnyNodeRef::FStringLiteralElement(node) => node.visit_source_order(visitor), + AnyNodeRef::FStringFormatSpec(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprFString(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprStringLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprBytesLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprNumberLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprBooleanLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprNoneLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprEllipsisLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprAttribute(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprSubscript(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprStarred(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprName(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprList(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprTuple(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprSlice(node) => node.visit_source_order(visitor), + AnyNodeRef::ExprIpyEscapeCommand(node) => node.visit_source_order(visitor), + AnyNodeRef::ExceptHandlerExceptHandler(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchValue(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchSingleton(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchSequence(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchMapping(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchClass(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchStar(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchAs(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternMatchOr(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternArguments(node) => node.visit_source_order(visitor), + AnyNodeRef::PatternKeyword(node) => node.visit_source_order(visitor), + AnyNodeRef::Comprehension(node) => node.visit_source_order(visitor), + AnyNodeRef::Arguments(node) => node.visit_source_order(visitor), + AnyNodeRef::Parameters(node) => node.visit_source_order(visitor), + AnyNodeRef::Parameter(node) => node.visit_source_order(visitor), + AnyNodeRef::ParameterWithDefault(node) => node.visit_source_order(visitor), + AnyNodeRef::Keyword(node) => node.visit_source_order(visitor), + AnyNodeRef::Alias(node) => node.visit_source_order(visitor), + AnyNodeRef::WithItem(node) => node.visit_source_order(visitor), + AnyNodeRef::MatchCase(node) => node.visit_source_order(visitor), + AnyNodeRef::Decorator(node) => node.visit_source_order(visitor), + AnyNodeRef::TypeParams(node) => node.visit_source_order(visitor), + AnyNodeRef::TypeParamTypeVar(node) => node.visit_source_order(visitor), + AnyNodeRef::TypeParamTypeVarTuple(node) => node.visit_source_order(visitor), + AnyNodeRef::TypeParamParamSpec(node) => node.visit_source_order(visitor), + AnyNodeRef::FString(node) => node.visit_source_order(visitor), + AnyNodeRef::StringLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::BytesLiteral(node) => node.visit_source_order(visitor), + AnyNodeRef::ElifElseClause(node) => node.visit_source_order(visitor), } } diff --git a/crates/ruff_python_ast/src/visitor.rs b/crates/ruff_python_ast/src/visitor.rs index bf14e5a0cf..b462125daf 100644 --- a/crates/ruff_python_ast/src/visitor.rs +++ b/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> { diff --git a/crates/ruff_python_ast/src/visitor/preorder.rs b/crates/ruff_python_ast/src/visitor/source_order.rs similarity index 61% rename from crates/ruff_python_ast/src/visitor/preorder.rs rename to crates/ruff_python_ast/src/visitor/source_order.rs index f6c70678d4..894835b965 100644 --- a/crates/ruff_python_ast/src/visitor/preorder.rs +++ b/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); } diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__bytes_literals.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__bytes_literals.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__bytes_literals.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__bytes_literals.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__class_type_parameters.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__class_type_parameters.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__class_type_parameters.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__class_type_parameters.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__compare.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__compare.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__compare.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__compare.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__decorators.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__decorators.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__decorators.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__decorators.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__dict_comprehension.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__dict_comprehension.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__dict_comprehension.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__dict_comprehension.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__f_strings.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__f_strings.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__f_strings.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__f_strings.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_arguments.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_arguments.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_arguments.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_arguments.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_positional_only_with_default.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_positional_only_with_default.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_positional_only_with_default.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_positional_only_with_default.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_type_parameters.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_type_parameters.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__function_type_parameters.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__function_type_parameters.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__list_comprehension.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__list_comprehension.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__list_comprehension.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__list_comprehension.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__match_class_pattern.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__match_class_pattern.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__match_class_pattern.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__match_class_pattern.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__set_comprehension.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__set_comprehension.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__set_comprehension.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__set_comprehension.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__string_literals.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__string_literals.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__string_literals.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__string_literals.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__type_aliases.snap b/crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__type_aliases.snap similarity index 100% rename from crates/ruff_python_ast_integration_tests/tests/snapshots/preorder__type_aliases.snap rename to crates/ruff_python_ast_integration_tests/tests/snapshots/source_order__type_aliases.snap diff --git a/crates/ruff_python_ast_integration_tests/tests/preorder.rs b/crates/ruff_python_ast_integration_tests/tests/source_order.rs similarity index 76% rename from crates/ruff_python_ast_integration_tests/tests/preorder.rs rename to crates/ruff_python_ast_integration_tests/tests/source_order.rs index 8c375da3e0..fdfce78c38 100644 --- a/crates/ruff_python_ast_integration_tests/tests/preorder.rs +++ b/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; diff --git a/crates/ruff_python_formatter/src/comments/mod.rs b/crates/ruff_python_formatter/src/comments/mod.rs index 3731a082e6..9d6f1a6817 100644 --- a/crates/ruff_python_formatter/src/comments/mod.rs +++ b/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(); diff --git a/crates/ruff_python_formatter/src/comments/visitor.rs b/crates/ruff_python_formatter/src/comments/visitor.rs index ede7180107..6ba2879eab 100644 --- a/crates/ruff_python_formatter/src/comments/visitor.rs +++ b/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(); diff --git a/crates/ruff_python_formatter/src/expression/mod.rs b/crates/ruff_python_formatter/src/expression/mod.rs index dd8b94c027..0e2e76adba 100644 --- a/crates/ruff_python_formatter/src/expression/mod.rs +++ b/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); diff --git a/crates/ruff_python_formatter/src/range.rs b/crates/ruff_python_formatter/src/range.rs index 7e5f152ad7..a41510f1dd 100644 --- a/crates/ruff_python_formatter/src/range.rs +++ b/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; diff --git a/crates/ruff_python_parser/tests/fixtures.rs b/crates/ruff_python_parser/tests/fixtures.rs index 2a3dce311a..63b7bec857 100644 --- a/crates/ruff_python_parser/tests/fixtures.rs +++ b/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,