diff --git a/crates/ruff_linter/src/checkers/ast/analyze/expression.rs b/crates/ruff_linter/src/checkers/ast/analyze/expression.rs index 14385ce2bc..375e5743ef 100644 --- a/crates/ruff_linter/src/checkers/ast/analyze/expression.rs +++ b/crates/ruff_linter/src/checkers/ast/analyze/expression.rs @@ -1327,8 +1327,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) { } } } - Expr::IfExp( - if_exp @ ast::ExprIfExp { + Expr::If( + if_exp @ ast::ExprIf { test, body, orelse, @@ -1450,8 +1450,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) { flake8_bugbear::rules::static_key_dict_comprehension(checker, dict_comp); } } - Expr::GeneratorExp( - generator @ ast::ExprGeneratorExp { + Expr::Generator( + generator @ ast::ExprGenerator { generators, elt: _, range: _, @@ -1517,7 +1517,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) { ruff::rules::parenthesize_chained_logical_operators(checker, bool_op); } } - Expr::NamedExpr(..) => { + Expr::Named(..) => { if checker.enabled(Rule::AssignmentInAssert) { ruff::rules::assignment_in_assert(checker, expr); } diff --git a/crates/ruff_linter/src/checkers/ast/mod.rs b/crates/ruff_linter/src/checkers/ast/mod.rs index 0ed3800a59..feabe4aded 100644 --- a/crates/ruff_linter/src/checkers/ast/mod.rs +++ b/crates/ruff_linter/src/checkers/ast/mod.rs @@ -1000,7 +1000,7 @@ impl<'a> Visitor<'a> for Checker<'a> { generators, range: _, }) - | Expr::GeneratorExp(ast::ExprGeneratorExp { + | Expr::Generator(ast::ExprGenerator { elt, generators, range: _, @@ -1048,7 +1048,7 @@ impl<'a> Visitor<'a> for Checker<'a> { self.visit.lambdas.push(self.semantic.snapshot()); self.analyze.lambdas.push(self.semantic.snapshot()); } - Expr::IfExp(ast::ExprIfExp { + Expr::If(ast::ExprIf { test, body, orelse, @@ -1372,7 +1372,7 @@ impl<'a> Visitor<'a> for Checker<'a> { self.semantic.flags |= SemanticModelFlags::F_STRING; visitor::walk_expr(self, expr); } - Expr::NamedExpr(ast::ExprNamedExpr { + Expr::Named(ast::ExprNamed { target, value, range: _, @@ -1388,7 +1388,7 @@ impl<'a> Visitor<'a> for Checker<'a> { // Step 3: Clean-up match expr { Expr::Lambda(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::ListComp(_) | Expr::DictComp(_) | Expr::SetComp(_) => { diff --git a/crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs b/crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs index 963c933b09..b43fccbb95 100644 --- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs +++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs @@ -88,7 +88,7 @@ impl<'a> Visitor<'a> for NameFinder<'a> { Expr::ListComp(ast::ExprListComp { generators, .. }) | Expr::DictComp(ast::ExprDictComp { generators, .. }) | Expr::SetComp(ast::ExprSetComp { generators, .. }) - | Expr::GeneratorExp(ast::ExprGeneratorExp { generators, .. }) => { + | Expr::Generator(ast::ExprGenerator { generators, .. }) => { for comp in generators { self.visit_expr(&comp.iter); } diff --git a/crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs b/crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs index 269c4c3715..2b39e349af 100644 --- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs +++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs @@ -217,7 +217,7 @@ impl<'a> Visitor<'a> for GroupNameFinder<'a> { } fn visit_expr(&mut self, expr: &'a Expr) { - if let Expr::NamedExpr(ast::ExprNamedExpr { target, .. }) = expr { + if let Expr::Named(ast::ExprNamed { target, .. }) = expr { if self.name_matches(target) { self.overridden = true; } diff --git a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs index 30a52354f3..4e72a558ad 100644 --- a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs +++ b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs @@ -58,7 +58,7 @@ pub(crate) fn unnecessary_generator_dict( else { return; }; - let Expr::GeneratorExp(ast::ExprGeneratorExp { elt, .. }) = argument else { + let Expr::Generator(ast::ExprGenerator { elt, .. }) = argument else { return; }; let Expr::Tuple(ast::ExprTuple { elts, .. }) = elt.as_ref() else { diff --git a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs index e9d89a1940..8de73493b0 100644 --- a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs +++ b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs @@ -56,7 +56,7 @@ pub(crate) fn unnecessary_generator_list(checker: &mut Checker, call: &ast::Expr if !checker.semantic().is_builtin("list") { return; } - if argument.is_generator_exp_expr() { + if argument.is_generator_expr() { let mut diagnostic = Diagnostic::new(UnnecessaryGeneratorList, call.range()); // Convert `list(x for x in y)` to `[x for x in y]`. diff --git a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs index 3fdb3efe86..b5fcc4b315 100644 --- a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs +++ b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs @@ -57,7 +57,7 @@ pub(crate) fn unnecessary_generator_set(checker: &mut Checker, call: &ast::ExprC if !checker.semantic().is_builtin("set") { return; } - if argument.is_generator_exp_expr() { + if argument.is_generator_expr() { let mut diagnostic = Diagnostic::new(UnnecessaryGeneratorSet, call.range()); // Convert `set(x for x in y)` to `{x for x in y}`. diff --git a/crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs b/crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs index 50a3558fed..3e24677363 100644 --- a/crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs +++ b/crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs @@ -267,7 +267,7 @@ pub(crate) fn twisted_arms_in_ifexpr( let node = body.clone(); let node1 = orelse.clone(); let node2 = orelse.clone(); - let node3 = ast::ExprIfExp { + let node3 = ast::ExprIf { test: Box::new(node2), body: Box::new(node1), orelse: Box::new(node), diff --git a/crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs b/crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs index c44c3d2a1c..3acdb8dbc4 100644 --- a/crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs +++ b/crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs @@ -152,7 +152,7 @@ pub(crate) fn if_else_block_instead_of_if_exp(checker: &mut Checker, stmt_if: &a } fn ternary(target_var: &Expr, body_value: &Expr, test: &Expr, orelse_value: &Expr) -> Stmt { - let node = ast::ExprIfExp { + let node = ast::ExprIf { test: Box::new(test.clone()), body: Box::new(body_value.clone()), orelse: Box::new(orelse_value.clone()), diff --git a/crates/ruff_linter/src/rules/flake8_simplify/rules/if_with_same_arms.rs b/crates/ruff_linter/src/rules/flake8_simplify/rules/if_with_same_arms.rs index 2e6ad2beb7..6494e262f6 100644 --- a/crates/ruff_linter/src/rules/flake8_simplify/rules/if_with_same_arms.rs +++ b/crates/ruff_linter/src/rules/flake8_simplify/rules/if_with_same_arms.rs @@ -143,7 +143,7 @@ fn merge_branches( op: ast::BoolOp::Or, .. }) | Expr::Lambda(_) - | Expr::NamedExpr(_) + | Expr::Named(_) ) { Cow::Owned(format!("({})", locator.slice(following_branch.test))) } else { diff --git a/crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs b/crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs index 30273ace9d..7dd5cc5d14 100644 --- a/crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs +++ b/crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs @@ -372,7 +372,7 @@ fn match_sibling_return<'a>(stmt: &'a Stmt, sibling: &'a Stmt) -> Option String { - let node = ast::ExprGeneratorExp { + let node = ast::ExprGenerator { elt: Box::new(test.clone()), generators: vec![Comprehension { target: target.clone(), diff --git a/crates/ruff_linter/src/rules/pandas_vet/helpers.rs b/crates/ruff_linter/src/rules/pandas_vet/helpers.rs index c88555659d..03a24ad295 100644 --- a/crates/ruff_linter/src/rules/pandas_vet/helpers.rs +++ b/crates/ruff_linter/src/rules/pandas_vet/helpers.rs @@ -29,7 +29,7 @@ pub(super) fn test_expression(expr: &Expr, semantic: &SemanticModel) -> Resoluti | Expr::SetComp(_) | Expr::ListComp(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) => Resolution::IrrelevantExpression, + | Expr::Generator(_) => Resolution::IrrelevantExpression, Expr::Name(name) => { semantic .resolve_name(name) diff --git a/crates/ruff_linter/src/rules/pyflakes/rules/strings.rs b/crates/ruff_linter/src/rules/pyflakes/rules/strings.rs index e4545e139b..f4f5f94ed9 100644 --- a/crates/ruff_linter/src/rules/pyflakes/rules/strings.rs +++ b/crates/ruff_linter/src/rules/pyflakes/rules/strings.rs @@ -537,7 +537,7 @@ pub(crate) fn percent_format_expected_mapping( | Expr::Set(_) | Expr::ListComp(_) | Expr::SetComp(_) - | Expr::GeneratorExp(_) => checker + | Expr::Generator(_) => checker .diagnostics .push(Diagnostic::new(PercentFormatExpectedMapping, location)), _ => {} diff --git a/crates/ruff_linter/src/rules/pylint/rules/literal_membership.rs b/crates/ruff_linter/src/rules/pylint/rules/literal_membership.rs index 00a9b72db3..6759eb6983 100644 --- a/crates/ruff_linter/src/rules/pylint/rules/literal_membership.rs +++ b/crates/ruff_linter/src/rules/pylint/rules/literal_membership.rs @@ -76,7 +76,7 @@ pub(crate) fn literal_membership(checker: &mut Checker, compare: &ast::ExprCompa | Expr::ListComp(_) | Expr::SetComp(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::Await(_) | Expr::Yield(_) | Expr::YieldFrom(_) => true, diff --git a/crates/ruff_linter/src/rules/pylint/rules/named_expr_without_context.rs b/crates/ruff_linter/src/rules/pylint/rules/named_expr_without_context.rs index 13f935bf73..5f6ddbe6c3 100644 --- a/crates/ruff_linter/src/rules/pylint/rules/named_expr_without_context.rs +++ b/crates/ruff_linter/src/rules/pylint/rules/named_expr_without_context.rs @@ -36,7 +36,7 @@ impl Violation for NamedExprWithoutContext { /// PLW0131 pub(crate) fn named_expr_without_context(checker: &mut Checker, value: &Expr) { - if let Expr::NamedExpr(ast::ExprNamedExpr { range, .. }) = value { + if let Expr::Named(ast::ExprNamed { range, .. }) = value { checker .diagnostics .push(Diagnostic::new(NamedExprWithoutContext, *range)); diff --git a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dict_index_lookup.rs b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dict_index_lookup.rs index 913279081f..f6929ae9dc 100644 --- a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dict_index_lookup.rs +++ b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dict_index_lookup.rs @@ -70,7 +70,7 @@ pub(crate) fn unnecessary_dict_index_lookup(checker: &mut Checker, stmt_for: &St /// PLR1733 pub(crate) fn unnecessary_dict_index_lookup_comprehension(checker: &mut Checker, expr: &Expr) { - let (Expr::GeneratorExp(ast::ExprGeneratorExp { + let (Expr::Generator(ast::ExprGenerator { elt, generators, .. }) | Expr::DictComp(ast::ExprDictComp { diff --git a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs index 6af9bfe4e5..34efe925bb 100644 --- a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs +++ b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs @@ -392,8 +392,8 @@ fn can_be_represented_without_parentheses(expr: &Expr) -> bool { || expr.is_literal_expr() || expr.is_call_expr() || expr.is_lambda_expr() - || expr.is_if_exp_expr() - || expr.is_generator_exp_expr() + || expr.is_if_expr() + || expr.is_generator_expr() || expr.is_subscript_expr() || expr.is_starred_expr() || expr.is_slice_expr() diff --git a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_list_index_lookup.rs b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_list_index_lookup.rs index 67cf9d7469..ee319ef621 100644 --- a/crates/ruff_linter/src/rules/pylint/rules/unnecessary_list_index_lookup.rs +++ b/crates/ruff_linter/src/rules/pylint/rules/unnecessary_list_index_lookup.rs @@ -72,7 +72,7 @@ pub(crate) fn unnecessary_list_index_lookup(checker: &mut Checker, stmt_for: &St /// PLR1736 pub(crate) fn unnecessary_list_index_lookup_comprehension(checker: &mut Checker, expr: &Expr) { - let (Expr::GeneratorExp(ast::ExprGeneratorExp { + let (Expr::Generator(ast::ExprGenerator { elt, generators, .. }) | Expr::DictComp(ast::ExprDictComp { diff --git a/crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs b/crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs index e813979276..7f3b9d7adf 100644 --- a/crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs +++ b/crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs @@ -146,9 +146,9 @@ fn parenthesize(expr: &Expr, text: &str, context: FormatContext) -> bool { Expr::BinOp(_) | Expr::UnaryOp(_) | Expr::BoolOp(_) - | Expr::NamedExpr(_) + | Expr::Named(_) | Expr::Compare(_) - | Expr::IfExp(_) + | Expr::If(_) | Expr::Lambda(_) | Expr::Await(_) | Expr::Yield(_) @@ -166,7 +166,7 @@ fn parenthesize(expr: &Expr, text: &str, context: FormatContext) -> bool { // E.g., `{x, y}` should be parenthesized in `f"{(x, y)}"`. ( _, - Expr::GeneratorExp(_) + Expr::Generator(_) | Expr::Dict(_) | Expr::Set(_) | Expr::SetComp(_) @@ -175,7 +175,7 @@ fn parenthesize(expr: &Expr, text: &str, context: FormatContext) -> bool { (_, Expr::Subscript(ast::ExprSubscript { value, .. })) => { matches!( value.as_ref(), - Expr::GeneratorExp(_) + Expr::Generator(_) | Expr::Dict(_) | Expr::Set(_) | Expr::SetComp(_) @@ -185,7 +185,7 @@ fn parenthesize(expr: &Expr, text: &str, context: FormatContext) -> bool { (_, Expr::Attribute(ast::ExprAttribute { value, .. })) => { matches!( value.as_ref(), - Expr::GeneratorExp(_) + Expr::Generator(_) | Expr::Dict(_) | Expr::Set(_) | Expr::SetComp(_) @@ -195,7 +195,7 @@ fn parenthesize(expr: &Expr, text: &str, context: FormatContext) -> bool { (_, Expr::Call(ast::ExprCall { func, .. })) => { matches!( func.as_ref(), - Expr::GeneratorExp(_) + Expr::Generator(_) | Expr::Dict(_) | Expr::Set(_) | Expr::SetComp(_) diff --git a/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs b/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs index 44057726b7..a33f2bbc23 100644 --- a/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs +++ b/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs @@ -169,13 +169,13 @@ fn is_allowed_value(expr: &Expr) -> bool { Expr::BoolOp(_) | Expr::BinOp(_) | Expr::UnaryOp(_) - | Expr::IfExp(_) + | Expr::If(_) | Expr::Dict(_) | Expr::Set(_) | Expr::ListComp(_) | Expr::SetComp(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::Compare(_) | Expr::Call(_) | Expr::FString(_) @@ -191,7 +191,7 @@ fn is_allowed_value(expr: &Expr) -> bool { | Expr::List(_) => true, Expr::Tuple(tuple) => tuple.elts.iter().all(is_allowed_value), // Maybe require parentheses. - Expr::NamedExpr(_) => false, + Expr::Named(_) => false, // Invalid in binary expressions. Expr::Await(_) | Expr::Lambda(_) diff --git a/crates/ruff_linter/src/rules/refurb/rules/bit_count.rs b/crates/ruff_linter/src/rules/refurb/rules/bit_count.rs index 671cca0f0b..c8f2e56fca 100644 --- a/crates/ruff_linter/src/rules/refurb/rules/bit_count.rs +++ b/crates/ruff_linter/src/rules/refurb/rules/bit_count.rs @@ -136,8 +136,8 @@ pub(crate) fn bit_count(checker: &mut Checker, call: &ExprCall) { | Expr::UnaryOp(_) | Expr::BinOp(_) | Expr::BoolOp(_) - | Expr::IfExp(_) - | Expr::NamedExpr(_) + | Expr::If(_) + | Expr::Named(_) | Expr::Lambda(_) | Expr::Slice(_) | Expr::Yield(_) @@ -146,7 +146,7 @@ pub(crate) fn bit_count(checker: &mut Checker, call: &ExprCall) { | Expr::List(_) | Expr::Compare(_) | Expr::Tuple(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::IpyEscapeCommand(_) => true, Expr::Call(_) diff --git a/crates/ruff_linter/src/rules/refurb/rules/if_expr_min_max.rs b/crates/ruff_linter/src/rules/refurb/rules/if_expr_min_max.rs index 8cf5be9182..46f6c1fd31 100644 --- a/crates/ruff_linter/src/rules/refurb/rules/if_expr_min_max.rs +++ b/crates/ruff_linter/src/rules/refurb/rules/if_expr_min_max.rs @@ -76,7 +76,7 @@ impl Violation for IfExprMinMax { } /// FURB136 -pub(crate) fn if_expr_min_max(checker: &mut Checker, if_exp: &ast::ExprIfExp) { +pub(crate) fn if_expr_min_max(checker: &mut Checker, if_exp: &ast::ExprIf) { let Expr::Compare(ast::ExprCompare { left, ops, diff --git a/crates/ruff_linter/src/rules/refurb/rules/reimplemented_starmap.rs b/crates/ruff_linter/src/rules/refurb/rules/reimplemented_starmap.rs index 143518339c..a7d65fd113 100644 --- a/crates/ruff_linter/src/rules/refurb/rules/reimplemented_starmap.rs +++ b/crates/ruff_linter/src/rules/refurb/rules/reimplemented_starmap.rs @@ -163,13 +163,13 @@ pub(crate) fn reimplemented_starmap(checker: &mut Checker, target: &StarmapCandi /// An enum for a node that can be considered a candidate for replacement with `starmap`. #[derive(Debug)] pub(crate) enum StarmapCandidate<'a> { - Generator(&'a ast::ExprGeneratorExp), + Generator(&'a ast::ExprGenerator), ListComp(&'a ast::ExprListComp), SetComp(&'a ast::ExprSetComp), } -impl<'a> From<&'a ast::ExprGeneratorExp> for StarmapCandidate<'a> { - fn from(generator: &'a ast::ExprGeneratorExp) -> Self { +impl<'a> From<&'a ast::ExprGenerator> for StarmapCandidate<'a> { + fn from(generator: &'a ast::ExprGenerator) -> Self { Self::Generator(generator) } } diff --git a/crates/ruff_linter/src/rules/ruff/rules/default_factory_kwarg.rs b/crates/ruff_linter/src/rules/ruff/rules/default_factory_kwarg.rs index 61adfd48dd..289a228264 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/default_factory_kwarg.rs +++ b/crates/ruff_linter/src/rules/ruff/rules/default_factory_kwarg.rs @@ -120,7 +120,7 @@ fn is_non_callable_value(value: &Expr) -> bool { | Expr::ListComp(_) | Expr::SetComp(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::FString(_)) } diff --git a/crates/ruff_linter/src/rules/ruff/rules/invalid_formatter_suppression_comment.rs b/crates/ruff_linter/src/rules/ruff/rules/invalid_formatter_suppression_comment.rs index f5a5aaab0c..50945f5b98 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/invalid_formatter_suppression_comment.rs +++ b/crates/ruff_linter/src/rules/ruff/rules/invalid_formatter_suppression_comment.rs @@ -279,17 +279,17 @@ const fn is_valid_enclosing_node(node: AnyNodeRef) -> bool { | AnyNodeRef::ElifElseClause(_) => true, AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) diff --git a/crates/ruff_linter/src/rules/ruff/rules/unnecessary_dict_comprehension_for_iterable.rs b/crates/ruff_linter/src/rules/ruff/rules/unnecessary_dict_comprehension_for_iterable.rs index 4336dbed30..189f7a5e3b 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/unnecessary_dict_comprehension_for_iterable.rs +++ b/crates/ruff_linter/src/rules/ruff/rules/unnecessary_dict_comprehension_for_iterable.rs @@ -141,12 +141,12 @@ fn is_constant_like(expr: &Expr) -> bool { | Expr::ListComp(_) | Expr::SetComp(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::Await(_) | Expr::Yield(_) | Expr::YieldFrom(_) | Expr::Call(_) - | Expr::NamedExpr(_) + | Expr::Named(_) ) }) } diff --git a/crates/ruff_linter/src/rules/ruff/rules/unnecessary_iterable_allocation_for_first_element.rs b/crates/ruff_linter/src/rules/ruff/rules/unnecessary_iterable_allocation_for_first_element.rs index 6d4d0643b4..9448b5dc70 100644 --- a/crates/ruff_linter/src/rules/ruff/rules/unnecessary_iterable_allocation_for_first_element.rs +++ b/crates/ruff_linter/src/rules/ruff/rules/unnecessary_iterable_allocation_for_first_element.rs @@ -185,7 +185,7 @@ fn match_iteration_target(expr: &Expr, semantic: &SemanticModel) -> Option match match_simple_comprehension(elt, generators) { Some(range) => IterationTarget { diff --git a/crates/ruff_python_ast/src/all.rs b/crates/ruff_python_ast/src/all.rs index b0710d50cc..2b35ee58c5 100644 --- a/crates/ruff_python_ast/src/all.rs +++ b/crates/ruff_python_ast/src/all.rs @@ -87,7 +87,7 @@ where } } } - Expr::NamedExpr(ast::ExprNamedExpr { value, .. }) => { + Expr::Named(ast::ExprNamed { value, .. }) => { // Allow, e.g., `__all__ += (value := ["A", "B"])`. return extract_elts(value, is_builtin); } diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs index 276894f6a9..194e382097 100644 --- a/crates/ruff_python_ast/src/comparable.rs +++ b/crates/ruff_python_ast/src/comparable.rs @@ -656,7 +656,7 @@ pub struct ExprBoolOp<'a> { } #[derive(Debug, PartialEq, Eq, Hash)] -pub struct ExprNamedExpr<'a> { +pub struct ExprNamed<'a> { target: Box>, value: Box>, } @@ -681,7 +681,7 @@ pub struct ExprLambda<'a> { } #[derive(Debug, PartialEq, Eq, Hash)] -pub struct ExprIfExp<'a> { +pub struct ExprIf<'a> { test: Box>, body: Box>, orelse: Box>, @@ -718,7 +718,7 @@ pub struct ExprDictComp<'a> { } #[derive(Debug, PartialEq, Eq, Hash)] -pub struct ExprGeneratorExp<'a> { +pub struct ExprGenerator<'a> { elt: Box>, generators: Vec>, } @@ -832,17 +832,17 @@ pub struct ExprIpyEscapeCommand<'a> { #[derive(Debug, PartialEq, Eq, Hash)] pub enum ComparableExpr<'a> { BoolOp(ExprBoolOp<'a>), - NamedExpr(ExprNamedExpr<'a>), + NamedExpr(ExprNamed<'a>), BinOp(ExprBinOp<'a>), UnaryOp(ExprUnaryOp<'a>), Lambda(ExprLambda<'a>), - IfExp(ExprIfExp<'a>), + IfExp(ExprIf<'a>), Dict(ExprDict<'a>), Set(ExprSet<'a>), ListComp(ExprListComp<'a>), SetComp(ExprSetComp<'a>), DictComp(ExprDictComp<'a>), - GeneratorExp(ExprGeneratorExp<'a>), + GeneratorExp(ExprGenerator<'a>), Await(ExprAwait<'a>), Yield(ExprYield<'a>), YieldFrom(ExprYieldFrom<'a>), @@ -889,11 +889,11 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> { op: (*op).into(), values: values.iter().map(Into::into).collect(), }), - ast::Expr::NamedExpr(ast::ExprNamedExpr { + ast::Expr::Named(ast::ExprNamed { target, value, range: _, - }) => Self::NamedExpr(ExprNamedExpr { + }) => Self::NamedExpr(ExprNamed { target: target.into(), value: value.into(), }), @@ -923,12 +923,12 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> { parameters: parameters.as_ref().map(Into::into), body: body.into(), }), - ast::Expr::IfExp(ast::ExprIfExp { + ast::Expr::If(ast::ExprIf { test, body, orelse, range: _, - }) => Self::IfExp(ExprIfExp { + }) => Self::IfExp(ExprIf { test: test.into(), body: body.into(), orelse: orelse.into(), @@ -973,12 +973,12 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> { value: value.into(), generators: generators.iter().map(Into::into).collect(), }), - ast::Expr::GeneratorExp(ast::ExprGeneratorExp { + ast::Expr::Generator(ast::ExprGenerator { elt, generators, range: _, parenthesized: _, - }) => Self::GeneratorExp(ExprGeneratorExp { + }) => Self::GeneratorExp(ExprGenerator { elt: elt.into(), generators: generators.iter().map(Into::into).collect(), }), diff --git a/crates/ruff_python_ast/src/expression.rs b/crates/ruff_python_ast/src/expression.rs index 56fecca6fc..707737c403 100644 --- a/crates/ruff_python_ast/src/expression.rs +++ b/crates/ruff_python_ast/src/expression.rs @@ -7,17 +7,17 @@ use crate::{self as ast, Expr}; #[derive(Copy, Clone, Debug, PartialEq)] pub enum ExpressionRef<'a> { BoolOp(&'a ast::ExprBoolOp), - NamedExpr(&'a ast::ExprNamedExpr), + Named(&'a ast::ExprNamed), BinOp(&'a ast::ExprBinOp), UnaryOp(&'a ast::ExprUnaryOp), Lambda(&'a ast::ExprLambda), - IfExp(&'a ast::ExprIfExp), + If(&'a ast::ExprIf), Dict(&'a ast::ExprDict), Set(&'a ast::ExprSet), ListComp(&'a ast::ExprListComp), SetComp(&'a ast::ExprSetComp), DictComp(&'a ast::ExprDictComp), - GeneratorExp(&'a ast::ExprGeneratorExp), + Generator(&'a ast::ExprGenerator), Await(&'a ast::ExprAwait), Yield(&'a ast::ExprYield), YieldFrom(&'a ast::ExprYieldFrom), @@ -50,17 +50,17 @@ impl<'a> From<&'a Expr> for ExpressionRef<'a> { fn from(value: &'a Expr) -> Self { match value { Expr::BoolOp(value) => ExpressionRef::BoolOp(value), - Expr::NamedExpr(value) => ExpressionRef::NamedExpr(value), + Expr::Named(value) => ExpressionRef::Named(value), Expr::BinOp(value) => ExpressionRef::BinOp(value), Expr::UnaryOp(value) => ExpressionRef::UnaryOp(value), Expr::Lambda(value) => ExpressionRef::Lambda(value), - Expr::IfExp(value) => ExpressionRef::IfExp(value), + Expr::If(value) => ExpressionRef::If(value), Expr::Dict(value) => ExpressionRef::Dict(value), Expr::Set(value) => ExpressionRef::Set(value), Expr::ListComp(value) => ExpressionRef::ListComp(value), Expr::SetComp(value) => ExpressionRef::SetComp(value), Expr::DictComp(value) => ExpressionRef::DictComp(value), - Expr::GeneratorExp(value) => ExpressionRef::GeneratorExp(value), + Expr::Generator(value) => ExpressionRef::Generator(value), Expr::Await(value) => ExpressionRef::Await(value), Expr::Yield(value) => ExpressionRef::Yield(value), Expr::YieldFrom(value) => ExpressionRef::YieldFrom(value), @@ -90,9 +90,9 @@ impl<'a> From<&'a ast::ExprBoolOp> for ExpressionRef<'a> { Self::BoolOp(value) } } -impl<'a> From<&'a ast::ExprNamedExpr> for ExpressionRef<'a> { - fn from(value: &'a ast::ExprNamedExpr) -> Self { - Self::NamedExpr(value) +impl<'a> From<&'a ast::ExprNamed> for ExpressionRef<'a> { + fn from(value: &'a ast::ExprNamed) -> Self { + Self::Named(value) } } impl<'a> From<&'a ast::ExprBinOp> for ExpressionRef<'a> { @@ -110,9 +110,9 @@ impl<'a> From<&'a ast::ExprLambda> for ExpressionRef<'a> { Self::Lambda(value) } } -impl<'a> From<&'a ast::ExprIfExp> for ExpressionRef<'a> { - fn from(value: &'a ast::ExprIfExp) -> Self { - Self::IfExp(value) +impl<'a> From<&'a ast::ExprIf> for ExpressionRef<'a> { + fn from(value: &'a ast::ExprIf) -> Self { + Self::If(value) } } impl<'a> From<&'a ast::ExprDict> for ExpressionRef<'a> { @@ -140,9 +140,9 @@ impl<'a> From<&'a ast::ExprDictComp> for ExpressionRef<'a> { Self::DictComp(value) } } -impl<'a> From<&'a ast::ExprGeneratorExp> for ExpressionRef<'a> { - fn from(value: &'a ast::ExprGeneratorExp) -> Self { - Self::GeneratorExp(value) +impl<'a> From<&'a ast::ExprGenerator> for ExpressionRef<'a> { + fn from(value: &'a ast::ExprGenerator) -> Self { + Self::Generator(value) } } impl<'a> From<&'a ast::ExprAwait> for ExpressionRef<'a> { @@ -250,17 +250,17 @@ impl<'a> From> for AnyNodeRef<'a> { fn from(value: ExpressionRef<'a>) -> Self { match value { ExpressionRef::BoolOp(expression) => AnyNodeRef::ExprBoolOp(expression), - ExpressionRef::NamedExpr(expression) => AnyNodeRef::ExprNamedExpr(expression), + ExpressionRef::Named(expression) => AnyNodeRef::ExprNamed(expression), ExpressionRef::BinOp(expression) => AnyNodeRef::ExprBinOp(expression), ExpressionRef::UnaryOp(expression) => AnyNodeRef::ExprUnaryOp(expression), ExpressionRef::Lambda(expression) => AnyNodeRef::ExprLambda(expression), - ExpressionRef::IfExp(expression) => AnyNodeRef::ExprIfExp(expression), + ExpressionRef::If(expression) => AnyNodeRef::ExprIf(expression), ExpressionRef::Dict(expression) => AnyNodeRef::ExprDict(expression), ExpressionRef::Set(expression) => AnyNodeRef::ExprSet(expression), ExpressionRef::ListComp(expression) => AnyNodeRef::ExprListComp(expression), ExpressionRef::SetComp(expression) => AnyNodeRef::ExprSetComp(expression), ExpressionRef::DictComp(expression) => AnyNodeRef::ExprDictComp(expression), - ExpressionRef::GeneratorExp(expression) => AnyNodeRef::ExprGeneratorExp(expression), + ExpressionRef::Generator(expression) => AnyNodeRef::ExprGenerator(expression), ExpressionRef::Await(expression) => AnyNodeRef::ExprAwait(expression), ExpressionRef::Yield(expression) => AnyNodeRef::ExprYield(expression), ExpressionRef::YieldFrom(expression) => AnyNodeRef::ExprYieldFrom(expression), @@ -293,17 +293,17 @@ impl Ranged for ExpressionRef<'_> { fn range(&self) -> TextRange { match self { ExpressionRef::BoolOp(expression) => expression.range(), - ExpressionRef::NamedExpr(expression) => expression.range(), + ExpressionRef::Named(expression) => expression.range(), ExpressionRef::BinOp(expression) => expression.range(), ExpressionRef::UnaryOp(expression) => expression.range(), ExpressionRef::Lambda(expression) => expression.range(), - ExpressionRef::IfExp(expression) => expression.range(), + ExpressionRef::If(expression) => expression.range(), ExpressionRef::Dict(expression) => expression.range(), ExpressionRef::Set(expression) => expression.range(), ExpressionRef::ListComp(expression) => expression.range(), ExpressionRef::SetComp(expression) => expression.range(), ExpressionRef::DictComp(expression) => expression.range(), - ExpressionRef::GeneratorExp(expression) => expression.range(), + ExpressionRef::Generator(expression) => expression.range(), ExpressionRef::Await(expression) => expression.range(), ExpressionRef::Yield(expression) => expression.range(), ExpressionRef::YieldFrom(expression) => expression.range(), diff --git a/crates/ruff_python_ast/src/helpers.rs b/crates/ruff_python_ast/src/helpers.rs index 18b3e5cc96..7a198855fe 100644 --- a/crates/ruff_python_ast/src/helpers.rs +++ b/crates/ruff_python_ast/src/helpers.rs @@ -115,7 +115,7 @@ where Expr::Await(_) | Expr::Call(_) | Expr::DictComp(_) - | Expr::GeneratorExp(_) + | Expr::Generator(_) | Expr::ListComp(_) | Expr::SetComp(_) | Expr::Subscript(_) @@ -139,7 +139,7 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool { Expr::FString(ast::ExprFString { value, .. }) => value .elements() .any(|expr| any_over_f_string_element(expr, func)), - Expr::NamedExpr(ast::ExprNamedExpr { + Expr::Named(ast::ExprNamed { target, value, range: _, @@ -149,7 +149,7 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool { } Expr::UnaryOp(ast::ExprUnaryOp { operand, .. }) => any_over_expr(operand, func), Expr::Lambda(ast::ExprLambda { body, .. }) => any_over_expr(body, func), - Expr::IfExp(ast::ExprIfExp { + Expr::If(ast::ExprIf { test, body, orelse, @@ -178,7 +178,7 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool { generators, range: _, }) - | Expr::GeneratorExp(ast::ExprGeneratorExp { + | Expr::Generator(ast::ExprGenerator { elt, generators, range: _, @@ -1045,7 +1045,7 @@ pub fn on_conditional_branch<'a>(parents: &mut impl Iterator) - return true; } if let Stmt::Expr(ast::StmtExpr { value, range: _ }) = parent { - if value.is_if_exp_expr() { + if value.is_if_expr() { return true; } } @@ -1270,14 +1270,14 @@ fn is_non_empty_f_string(expr: &ast::ExprFString) -> bool { Expr::Tuple(_) => true, // These expressions must resolve to the inner expression. - Expr::IfExp(ast::ExprIfExp { body, orelse, .. }) => inner(body) && inner(orelse), - Expr::NamedExpr(ast::ExprNamedExpr { value, .. }) => inner(value), + Expr::If(ast::ExprIf { body, orelse, .. }) => inner(body) && inner(orelse), + Expr::Named(ast::ExprNamed { value, .. }) => inner(value), // These expressions are complex. We can't determine whether they're empty or not. Expr::BoolOp(ast::ExprBoolOp { .. }) => false, Expr::BinOp(ast::ExprBinOp { .. }) => false, Expr::UnaryOp(ast::ExprUnaryOp { .. }) => false, - Expr::GeneratorExp(_) => false, + Expr::Generator(_) => false, Expr::Await(_) => false, Expr::Yield(_) => false, Expr::YieldFrom(_) => false, diff --git a/crates/ruff_python_ast/src/node.rs b/crates/ruff_python_ast/src/node.rs index 5b727bcf37..e22153fedb 100644 --- a/crates/ruff_python_ast/src/node.rs +++ b/crates/ruff_python_ast/src/node.rs @@ -55,17 +55,17 @@ pub enum AnyNode { StmtContinue(ast::StmtContinue), StmtIpyEscapeCommand(ast::StmtIpyEscapeCommand), ExprBoolOp(ast::ExprBoolOp), - ExprNamedExpr(ast::ExprNamedExpr), + ExprNamed(ast::ExprNamed), ExprBinOp(ast::ExprBinOp), ExprUnaryOp(ast::ExprUnaryOp), ExprLambda(ast::ExprLambda), - ExprIfExp(ast::ExprIfExp), + ExprIf(ast::ExprIf), ExprDict(ast::ExprDict), ExprSet(ast::ExprSet), ExprListComp(ast::ExprListComp), ExprSetComp(ast::ExprSetComp), ExprDictComp(ast::ExprDictComp), - ExprGeneratorExp(ast::ExprGeneratorExp), + ExprGenerator(ast::ExprGenerator), ExprAwait(ast::ExprAwait), ExprYield(ast::ExprYield), ExprYieldFrom(ast::ExprYieldFrom), @@ -152,17 +152,17 @@ impl AnyNode { AnyNode::ModModule(_) | AnyNode::ModExpression(_) | AnyNode::ExprBoolOp(_) - | AnyNode::ExprNamedExpr(_) + | AnyNode::ExprNamed(_) | AnyNode::ExprBinOp(_) | AnyNode::ExprUnaryOp(_) | AnyNode::ExprLambda(_) - | AnyNode::ExprIfExp(_) + | AnyNode::ExprIf(_) | AnyNode::ExprDict(_) | AnyNode::ExprSet(_) | AnyNode::ExprListComp(_) | AnyNode::ExprSetComp(_) | AnyNode::ExprDictComp(_) - | AnyNode::ExprGeneratorExp(_) + | AnyNode::ExprGenerator(_) | AnyNode::ExprAwait(_) | AnyNode::ExprYield(_) | AnyNode::ExprYieldFrom(_) @@ -221,17 +221,17 @@ impl AnyNode { pub fn expression(self) -> Option { match self { AnyNode::ExprBoolOp(node) => Some(Expr::BoolOp(node)), - AnyNode::ExprNamedExpr(node) => Some(Expr::NamedExpr(node)), + AnyNode::ExprNamed(node) => Some(Expr::Named(node)), AnyNode::ExprBinOp(node) => Some(Expr::BinOp(node)), AnyNode::ExprUnaryOp(node) => Some(Expr::UnaryOp(node)), AnyNode::ExprLambda(node) => Some(Expr::Lambda(node)), - AnyNode::ExprIfExp(node) => Some(Expr::IfExp(node)), + AnyNode::ExprIf(node) => Some(Expr::If(node)), AnyNode::ExprDict(node) => Some(Expr::Dict(node)), AnyNode::ExprSet(node) => Some(Expr::Set(node)), AnyNode::ExprListComp(node) => Some(Expr::ListComp(node)), AnyNode::ExprSetComp(node) => Some(Expr::SetComp(node)), AnyNode::ExprDictComp(node) => Some(Expr::DictComp(node)), - AnyNode::ExprGeneratorExp(node) => Some(Expr::GeneratorExp(node)), + AnyNode::ExprGenerator(node) => Some(Expr::Generator(node)), AnyNode::ExprAwait(node) => Some(Expr::Await(node)), AnyNode::ExprYield(node) => Some(Expr::Yield(node)), AnyNode::ExprYieldFrom(node) => Some(Expr::YieldFrom(node)), @@ -346,17 +346,17 @@ impl AnyNode { | AnyNode::StmtContinue(_) | AnyNode::StmtIpyEscapeCommand(_) | AnyNode::ExprBoolOp(_) - | AnyNode::ExprNamedExpr(_) + | AnyNode::ExprNamed(_) | AnyNode::ExprBinOp(_) | AnyNode::ExprUnaryOp(_) | AnyNode::ExprLambda(_) - | AnyNode::ExprIfExp(_) + | AnyNode::ExprIf(_) | AnyNode::ExprDict(_) | AnyNode::ExprSet(_) | AnyNode::ExprListComp(_) | AnyNode::ExprSetComp(_) | AnyNode::ExprDictComp(_) - | AnyNode::ExprGeneratorExp(_) + | AnyNode::ExprGenerator(_) | AnyNode::ExprAwait(_) | AnyNode::ExprYield(_) | AnyNode::ExprYieldFrom(_) @@ -451,17 +451,17 @@ impl AnyNode { | AnyNode::StmtContinue(_) | AnyNode::StmtIpyEscapeCommand(_) | AnyNode::ExprBoolOp(_) - | AnyNode::ExprNamedExpr(_) + | AnyNode::ExprNamed(_) | AnyNode::ExprBinOp(_) | AnyNode::ExprUnaryOp(_) | AnyNode::ExprLambda(_) - | AnyNode::ExprIfExp(_) + | AnyNode::ExprIf(_) | AnyNode::ExprDict(_) | AnyNode::ExprSet(_) | AnyNode::ExprListComp(_) | AnyNode::ExprSetComp(_) | AnyNode::ExprDictComp(_) - | AnyNode::ExprGeneratorExp(_) + | AnyNode::ExprGenerator(_) | AnyNode::ExprAwait(_) | AnyNode::ExprYield(_) | AnyNode::ExprYieldFrom(_) @@ -541,17 +541,17 @@ impl AnyNode { | AnyNode::StmtContinue(_) | AnyNode::StmtIpyEscapeCommand(_) | AnyNode::ExprBoolOp(_) - | AnyNode::ExprNamedExpr(_) + | AnyNode::ExprNamed(_) | AnyNode::ExprBinOp(_) | AnyNode::ExprUnaryOp(_) | AnyNode::ExprLambda(_) - | AnyNode::ExprIfExp(_) + | AnyNode::ExprIf(_) | AnyNode::ExprDict(_) | AnyNode::ExprSet(_) | AnyNode::ExprListComp(_) | AnyNode::ExprSetComp(_) | AnyNode::ExprDictComp(_) - | AnyNode::ExprGeneratorExp(_) + | AnyNode::ExprGenerator(_) | AnyNode::ExprAwait(_) | AnyNode::ExprYield(_) | AnyNode::ExprYieldFrom(_) @@ -656,17 +656,17 @@ impl AnyNode { Self::StmtContinue(node) => AnyNodeRef::StmtContinue(node), Self::StmtIpyEscapeCommand(node) => AnyNodeRef::StmtIpyEscapeCommand(node), Self::ExprBoolOp(node) => AnyNodeRef::ExprBoolOp(node), - Self::ExprNamedExpr(node) => AnyNodeRef::ExprNamedExpr(node), + Self::ExprNamed(node) => AnyNodeRef::ExprNamed(node), Self::ExprBinOp(node) => AnyNodeRef::ExprBinOp(node), Self::ExprUnaryOp(node) => AnyNodeRef::ExprUnaryOp(node), Self::ExprLambda(node) => AnyNodeRef::ExprLambda(node), - Self::ExprIfExp(node) => AnyNodeRef::ExprIfExp(node), + Self::ExprIf(node) => AnyNodeRef::ExprIf(node), Self::ExprDict(node) => AnyNodeRef::ExprDict(node), Self::ExprSet(node) => AnyNodeRef::ExprSet(node), Self::ExprListComp(node) => AnyNodeRef::ExprListComp(node), Self::ExprSetComp(node) => AnyNodeRef::ExprSetComp(node), Self::ExprDictComp(node) => AnyNodeRef::ExprDictComp(node), - Self::ExprGeneratorExp(node) => AnyNodeRef::ExprGeneratorExp(node), + Self::ExprGenerator(node) => AnyNodeRef::ExprGenerator(node), Self::ExprAwait(node) => AnyNodeRef::ExprAwait(node), Self::ExprYield(node) => AnyNodeRef::ExprYield(node), Self::ExprYieldFrom(node) => AnyNodeRef::ExprYieldFrom(node), @@ -1959,12 +1959,12 @@ impl AstNode for ast::ExprBoolOp { } } } -impl AstNode for ast::ExprNamedExpr { +impl AstNode for ast::ExprNamed { fn cast(kind: AnyNode) -> Option where Self: Sized, { - if let AnyNode::ExprNamedExpr(node) = kind { + if let AnyNode::ExprNamed(node) = kind { Some(node) } else { None @@ -1972,7 +1972,7 @@ impl AstNode for ast::ExprNamedExpr { } fn cast_ref(kind: AnyNodeRef) -> Option<&Self> { - if let AnyNodeRef::ExprNamedExpr(node) = kind { + if let AnyNodeRef::ExprNamed(node) = kind { Some(node) } else { None @@ -1991,7 +1991,7 @@ impl AstNode for ast::ExprNamedExpr { where V: PreorderVisitor<'a> + ?Sized, { - let ast::ExprNamedExpr { + let ast::ExprNamed { target, value, range: _, @@ -2129,12 +2129,12 @@ impl AstNode for ast::ExprLambda { visitor.visit_expr(body); } } -impl AstNode for ast::ExprIfExp { +impl AstNode for ast::ExprIf { fn cast(kind: AnyNode) -> Option where Self: Sized, { - if let AnyNode::ExprIfExp(node) = kind { + if let AnyNode::ExprIf(node) = kind { Some(node) } else { None @@ -2142,7 +2142,7 @@ impl AstNode for ast::ExprIfExp { } fn cast_ref(kind: AnyNodeRef) -> Option<&Self> { - if let AnyNodeRef::ExprIfExp(node) = kind { + if let AnyNodeRef::ExprIf(node) = kind { Some(node) } else { None @@ -2161,7 +2161,7 @@ impl AstNode for ast::ExprIfExp { where V: PreorderVisitor<'a> + ?Sized, { - let ast::ExprIfExp { + let ast::ExprIf { test, body, orelse, @@ -2394,12 +2394,12 @@ impl AstNode for ast::ExprDictComp { } } } -impl AstNode for ast::ExprGeneratorExp { +impl AstNode for ast::ExprGenerator { fn cast(kind: AnyNode) -> Option where Self: Sized, { - if let AnyNode::ExprGeneratorExp(node) = kind { + if let AnyNode::ExprGenerator(node) = kind { Some(node) } else { None @@ -2407,7 +2407,7 @@ impl AstNode for ast::ExprGeneratorExp { } fn cast_ref(kind: AnyNodeRef) -> Option<&Self> { - if let AnyNodeRef::ExprGeneratorExp(node) = kind { + if let AnyNodeRef::ExprGenerator(node) = kind { Some(node) } else { None @@ -2426,7 +2426,7 @@ impl AstNode for ast::ExprGeneratorExp { where V: PreorderVisitor<'a> + ?Sized, { - let ast::ExprGeneratorExp { + let ast::ExprGenerator { elt, generators, range: _, @@ -4542,17 +4542,17 @@ impl From for AnyNode { fn from(expr: Expr) -> Self { match expr { Expr::BoolOp(node) => AnyNode::ExprBoolOp(node), - Expr::NamedExpr(node) => AnyNode::ExprNamedExpr(node), + Expr::Named(node) => AnyNode::ExprNamed(node), Expr::BinOp(node) => AnyNode::ExprBinOp(node), Expr::UnaryOp(node) => AnyNode::ExprUnaryOp(node), Expr::Lambda(node) => AnyNode::ExprLambda(node), - Expr::IfExp(node) => AnyNode::ExprIfExp(node), + Expr::If(node) => AnyNode::ExprIf(node), Expr::Dict(node) => AnyNode::ExprDict(node), Expr::Set(node) => AnyNode::ExprSet(node), Expr::ListComp(node) => AnyNode::ExprListComp(node), Expr::SetComp(node) => AnyNode::ExprSetComp(node), Expr::DictComp(node) => AnyNode::ExprDictComp(node), - Expr::GeneratorExp(node) => AnyNode::ExprGeneratorExp(node), + Expr::Generator(node) => AnyNode::ExprGenerator(node), Expr::Await(node) => AnyNode::ExprAwait(node), Expr::Yield(node) => AnyNode::ExprYield(node), Expr::YieldFrom(node) => AnyNode::ExprYieldFrom(node), @@ -4792,9 +4792,9 @@ impl From for AnyNode { } } -impl From for AnyNode { - fn from(node: ast::ExprNamedExpr) -> Self { - AnyNode::ExprNamedExpr(node) +impl From for AnyNode { + fn from(node: ast::ExprNamed) -> Self { + AnyNode::ExprNamed(node) } } @@ -4816,9 +4816,9 @@ impl From for AnyNode { } } -impl From for AnyNode { - fn from(node: ast::ExprIfExp) -> Self { - AnyNode::ExprIfExp(node) +impl From for AnyNode { + fn from(node: ast::ExprIf) -> Self { + AnyNode::ExprIf(node) } } @@ -4852,9 +4852,9 @@ impl From for AnyNode { } } -impl From for AnyNode { - fn from(node: ast::ExprGeneratorExp) -> Self { - AnyNode::ExprGeneratorExp(node) +impl From for AnyNode { + fn from(node: ast::ExprGenerator) -> Self { + AnyNode::ExprGenerator(node) } } @@ -5184,17 +5184,17 @@ impl Ranged for AnyNode { AnyNode::StmtContinue(node) => node.range(), AnyNode::StmtIpyEscapeCommand(node) => node.range(), AnyNode::ExprBoolOp(node) => node.range(), - AnyNode::ExprNamedExpr(node) => node.range(), + AnyNode::ExprNamed(node) => node.range(), AnyNode::ExprBinOp(node) => node.range(), AnyNode::ExprUnaryOp(node) => node.range(), AnyNode::ExprLambda(node) => node.range(), - AnyNode::ExprIfExp(node) => node.range(), + AnyNode::ExprIf(node) => node.range(), AnyNode::ExprDict(node) => node.range(), AnyNode::ExprSet(node) => node.range(), AnyNode::ExprListComp(node) => node.range(), AnyNode::ExprSetComp(node) => node.range(), AnyNode::ExprDictComp(node) => node.range(), - AnyNode::ExprGeneratorExp(node) => node.range(), + AnyNode::ExprGenerator(node) => node.range(), AnyNode::ExprAwait(node) => node.range(), AnyNode::ExprYield(node) => node.range(), AnyNode::ExprYieldFrom(node) => node.range(), @@ -5281,17 +5281,17 @@ pub enum AnyNodeRef<'a> { StmtContinue(&'a ast::StmtContinue), StmtIpyEscapeCommand(&'a ast::StmtIpyEscapeCommand), ExprBoolOp(&'a ast::ExprBoolOp), - ExprNamedExpr(&'a ast::ExprNamedExpr), + ExprNamed(&'a ast::ExprNamed), ExprBinOp(&'a ast::ExprBinOp), ExprUnaryOp(&'a ast::ExprUnaryOp), ExprLambda(&'a ast::ExprLambda), - ExprIfExp(&'a ast::ExprIfExp), + ExprIf(&'a ast::ExprIf), ExprDict(&'a ast::ExprDict), ExprSet(&'a ast::ExprSet), ExprListComp(&'a ast::ExprListComp), ExprSetComp(&'a ast::ExprSetComp), ExprDictComp(&'a ast::ExprDictComp), - ExprGeneratorExp(&'a ast::ExprGeneratorExp), + ExprGenerator(&'a ast::ExprGenerator), ExprAwait(&'a ast::ExprAwait), ExprYield(&'a ast::ExprYield), ExprYieldFrom(&'a ast::ExprYieldFrom), @@ -5377,17 +5377,17 @@ impl<'a> AnyNodeRef<'a> { AnyNodeRef::StmtContinue(node) => NonNull::from(*node).cast(), AnyNodeRef::StmtIpyEscapeCommand(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprBoolOp(node) => NonNull::from(*node).cast(), - AnyNodeRef::ExprNamedExpr(node) => NonNull::from(*node).cast(), + AnyNodeRef::ExprNamed(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprBinOp(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprUnaryOp(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprLambda(node) => NonNull::from(*node).cast(), - AnyNodeRef::ExprIfExp(node) => NonNull::from(*node).cast(), + AnyNodeRef::ExprIf(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprDict(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprSet(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprListComp(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprSetComp(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprDictComp(node) => NonNull::from(*node).cast(), - AnyNodeRef::ExprGeneratorExp(node) => NonNull::from(*node).cast(), + AnyNodeRef::ExprGenerator(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprAwait(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprYield(node) => NonNull::from(*node).cast(), AnyNodeRef::ExprYieldFrom(node) => NonNull::from(*node).cast(), @@ -5479,17 +5479,17 @@ impl<'a> AnyNodeRef<'a> { AnyNodeRef::StmtContinue(_) => NodeKind::StmtContinue, AnyNodeRef::StmtIpyEscapeCommand(_) => NodeKind::StmtIpyEscapeCommand, AnyNodeRef::ExprBoolOp(_) => NodeKind::ExprBoolOp, - AnyNodeRef::ExprNamedExpr(_) => NodeKind::ExprNamedExpr, + AnyNodeRef::ExprNamed(_) => NodeKind::ExprNamed, AnyNodeRef::ExprBinOp(_) => NodeKind::ExprBinOp, AnyNodeRef::ExprUnaryOp(_) => NodeKind::ExprUnaryOp, AnyNodeRef::ExprLambda(_) => NodeKind::ExprLambda, - AnyNodeRef::ExprIfExp(_) => NodeKind::ExprIfExp, + AnyNodeRef::ExprIf(_) => NodeKind::ExprIf, AnyNodeRef::ExprDict(_) => NodeKind::ExprDict, AnyNodeRef::ExprSet(_) => NodeKind::ExprSet, AnyNodeRef::ExprListComp(_) => NodeKind::ExprListComp, AnyNodeRef::ExprSetComp(_) => NodeKind::ExprSetComp, AnyNodeRef::ExprDictComp(_) => NodeKind::ExprDictComp, - AnyNodeRef::ExprGeneratorExp(_) => NodeKind::ExprGeneratorExp, + AnyNodeRef::ExprGenerator(_) => NodeKind::ExprGenerator, AnyNodeRef::ExprAwait(_) => NodeKind::ExprAwait, AnyNodeRef::ExprYield(_) => NodeKind::ExprYield, AnyNodeRef::ExprYieldFrom(_) => NodeKind::ExprYieldFrom, @@ -5576,17 +5576,17 @@ impl<'a> AnyNodeRef<'a> { AnyNodeRef::ModModule(_) | AnyNodeRef::ModExpression(_) | AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) @@ -5645,17 +5645,17 @@ impl<'a> AnyNodeRef<'a> { pub const fn is_expression(self) -> bool { match self { AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) @@ -5769,17 +5769,17 @@ impl<'a> AnyNodeRef<'a> { | AnyNodeRef::StmtContinue(_) | AnyNodeRef::StmtIpyEscapeCommand(_) | AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) @@ -5874,17 +5874,17 @@ impl<'a> AnyNodeRef<'a> { | AnyNodeRef::StmtContinue(_) | AnyNodeRef::StmtIpyEscapeCommand(_) | AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) @@ -5964,17 +5964,17 @@ impl<'a> AnyNodeRef<'a> { | AnyNodeRef::StmtContinue(_) | AnyNodeRef::StmtIpyEscapeCommand(_) | AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) @@ -6073,17 +6073,17 @@ impl<'a> AnyNodeRef<'a> { AnyNodeRef::StmtContinue(node) => node.visit_preorder(visitor), AnyNodeRef::StmtIpyEscapeCommand(node) => node.visit_preorder(visitor), AnyNodeRef::ExprBoolOp(node) => node.visit_preorder(visitor), - AnyNodeRef::ExprNamedExpr(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::ExprIfExp(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::ExprGeneratorExp(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), @@ -6488,9 +6488,9 @@ impl<'a> From<&'a ast::ExprBoolOp> for AnyNodeRef<'a> { } } -impl<'a> From<&'a ast::ExprNamedExpr> for AnyNodeRef<'a> { - fn from(node: &'a ast::ExprNamedExpr) -> Self { - AnyNodeRef::ExprNamedExpr(node) +impl<'a> From<&'a ast::ExprNamed> for AnyNodeRef<'a> { + fn from(node: &'a ast::ExprNamed) -> Self { + AnyNodeRef::ExprNamed(node) } } @@ -6512,9 +6512,9 @@ impl<'a> From<&'a ast::ExprLambda> for AnyNodeRef<'a> { } } -impl<'a> From<&'a ast::ExprIfExp> for AnyNodeRef<'a> { - fn from(node: &'a ast::ExprIfExp) -> Self { - AnyNodeRef::ExprIfExp(node) +impl<'a> From<&'a ast::ExprIf> for AnyNodeRef<'a> { + fn from(node: &'a ast::ExprIf) -> Self { + AnyNodeRef::ExprIf(node) } } @@ -6548,9 +6548,9 @@ impl<'a> From<&'a ast::ExprDictComp> for AnyNodeRef<'a> { } } -impl<'a> From<&'a ast::ExprGeneratorExp> for AnyNodeRef<'a> { - fn from(node: &'a ast::ExprGeneratorExp) -> Self { - AnyNodeRef::ExprGeneratorExp(node) +impl<'a> From<&'a ast::ExprGenerator> for AnyNodeRef<'a> { + fn from(node: &'a ast::ExprGenerator) -> Self { + AnyNodeRef::ExprGenerator(node) } } @@ -6841,17 +6841,17 @@ impl<'a> From<&'a Expr> for AnyNodeRef<'a> { fn from(expr: &'a Expr) -> Self { match expr { Expr::BoolOp(node) => AnyNodeRef::ExprBoolOp(node), - Expr::NamedExpr(node) => AnyNodeRef::ExprNamedExpr(node), + Expr::Named(node) => AnyNodeRef::ExprNamed(node), Expr::BinOp(node) => AnyNodeRef::ExprBinOp(node), Expr::UnaryOp(node) => AnyNodeRef::ExprUnaryOp(node), Expr::Lambda(node) => AnyNodeRef::ExprLambda(node), - Expr::IfExp(node) => AnyNodeRef::ExprIfExp(node), + Expr::If(node) => AnyNodeRef::ExprIf(node), Expr::Dict(node) => AnyNodeRef::ExprDict(node), Expr::Set(node) => AnyNodeRef::ExprSet(node), Expr::ListComp(node) => AnyNodeRef::ExprListComp(node), Expr::SetComp(node) => AnyNodeRef::ExprSetComp(node), Expr::DictComp(node) => AnyNodeRef::ExprDictComp(node), - Expr::GeneratorExp(node) => AnyNodeRef::ExprGeneratorExp(node), + Expr::Generator(node) => AnyNodeRef::ExprGenerator(node), Expr::Await(node) => AnyNodeRef::ExprAwait(node), Expr::Yield(node) => AnyNodeRef::ExprYield(node), Expr::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node), @@ -7006,17 +7006,17 @@ impl Ranged for AnyNodeRef<'_> { AnyNodeRef::StmtContinue(node) => node.range(), AnyNodeRef::StmtIpyEscapeCommand(node) => node.range(), AnyNodeRef::ExprBoolOp(node) => node.range(), - AnyNodeRef::ExprNamedExpr(node) => node.range(), + AnyNodeRef::ExprNamed(node) => node.range(), AnyNodeRef::ExprBinOp(node) => node.range(), AnyNodeRef::ExprUnaryOp(node) => node.range(), AnyNodeRef::ExprLambda(node) => node.range(), - AnyNodeRef::ExprIfExp(node) => node.range(), + AnyNodeRef::ExprIf(node) => node.range(), AnyNodeRef::ExprDict(node) => node.range(), AnyNodeRef::ExprSet(node) => node.range(), AnyNodeRef::ExprListComp(node) => node.range(), AnyNodeRef::ExprSetComp(node) => node.range(), AnyNodeRef::ExprDictComp(node) => node.range(), - AnyNodeRef::ExprGeneratorExp(node) => node.range(), + AnyNodeRef::ExprGenerator(node) => node.range(), AnyNodeRef::ExprAwait(node) => node.range(), AnyNodeRef::ExprYield(node) => node.range(), AnyNodeRef::ExprYieldFrom(node) => node.range(), @@ -7105,17 +7105,17 @@ pub enum NodeKind { StmtBreak, StmtContinue, ExprBoolOp, - ExprNamedExpr, + ExprNamed, ExprBinOp, ExprUnaryOp, ExprLambda, - ExprIfExp, + ExprIf, ExprDict, ExprSet, ExprListComp, ExprSetComp, ExprDictComp, - ExprGeneratorExp, + ExprGenerator, ExprAwait, ExprYield, ExprYieldFrom, diff --git a/crates/ruff_python_ast/src/nodes.rs b/crates/ruff_python_ast/src/nodes.rs index d990461147..a8db5967a8 100644 --- a/crates/ruff_python_ast/src/nodes.rs +++ b/crates/ruff_python_ast/src/nodes.rs @@ -558,16 +558,16 @@ impl From for Stmt { pub enum Expr { #[is(name = "bool_op_expr")] BoolOp(ExprBoolOp), - #[is(name = "named_expr_expr")] - NamedExpr(ExprNamedExpr), + #[is(name = "named_expr")] + Named(ExprNamed), #[is(name = "bin_op_expr")] BinOp(ExprBinOp), #[is(name = "unary_op_expr")] UnaryOp(ExprUnaryOp), #[is(name = "lambda_expr")] Lambda(ExprLambda), - #[is(name = "if_exp_expr")] - IfExp(ExprIfExp), + #[is(name = "if_expr")] + If(ExprIf), #[is(name = "dict_expr")] Dict(ExprDict), #[is(name = "set_expr")] @@ -578,8 +578,8 @@ pub enum Expr { SetComp(ExprSetComp), #[is(name = "dict_comp_expr")] DictComp(ExprDictComp), - #[is(name = "generator_exp_expr")] - GeneratorExp(ExprGeneratorExp), + #[is(name = "generator_expr")] + Generator(ExprGenerator), #[is(name = "await_expr")] Await(ExprAwait), #[is(name = "yield_expr")] @@ -695,15 +695,15 @@ impl From for Expr { /// See also [NamedExpr](https://docs.python.org/3/library/ast.html#ast.NamedExpr) #[derive(Clone, Debug, PartialEq)] -pub struct ExprNamedExpr { +pub struct ExprNamed { pub range: TextRange, pub target: Box, pub value: Box, } -impl From for Expr { - fn from(payload: ExprNamedExpr) -> Self { - Expr::NamedExpr(payload) +impl From for Expr { + fn from(payload: ExprNamed) -> Self { + Expr::Named(payload) } } @@ -752,16 +752,16 @@ impl From for Expr { /// See also [IfExp](https://docs.python.org/3/library/ast.html#ast.IfExp) #[derive(Clone, Debug, PartialEq)] -pub struct ExprIfExp { +pub struct ExprIf { pub range: TextRange, pub test: Box, pub body: Box, pub orelse: Box, } -impl From for Expr { - fn from(payload: ExprIfExp) -> Self { - Expr::IfExp(payload) +impl From for Expr { + fn from(payload: ExprIf) -> Self { + Expr::If(payload) } } @@ -837,16 +837,16 @@ impl From for Expr { /// See also [GeneratorExp](https://docs.python.org/3/library/ast.html#ast.GeneratorExp) #[derive(Clone, Debug, PartialEq)] -pub struct ExprGeneratorExp { +pub struct ExprGenerator { pub range: TextRange, pub elt: Box, pub generators: Vec, pub parenthesized: bool, } -impl From for Expr { - fn from(payload: ExprGeneratorExp) -> Self { - Expr::GeneratorExp(payload) +impl From for Expr { + fn from(payload: ExprGenerator) -> Self { + Expr::Generator(payload) } } @@ -3534,7 +3534,7 @@ impl Ranged for crate::nodes::ExprBoolOp { self.range } } -impl Ranged for crate::nodes::ExprNamedExpr { +impl Ranged for crate::nodes::ExprNamed { fn range(&self) -> TextRange { self.range } @@ -3554,7 +3554,7 @@ impl Ranged for crate::nodes::ExprLambda { self.range } } -impl Ranged for crate::nodes::ExprIfExp { +impl Ranged for crate::nodes::ExprIf { fn range(&self) -> TextRange { self.range } @@ -3584,7 +3584,7 @@ impl Ranged for crate::nodes::ExprDictComp { self.range } } -impl Ranged for crate::nodes::ExprGeneratorExp { +impl Ranged for crate::nodes::ExprGenerator { fn range(&self) -> TextRange { self.range } @@ -3663,17 +3663,17 @@ impl Ranged for crate::Expr { fn range(&self) -> TextRange { match self { Self::BoolOp(node) => node.range(), - Self::NamedExpr(node) => node.range(), + Self::Named(node) => node.range(), Self::BinOp(node) => node.range(), Self::UnaryOp(node) => node.range(), Self::Lambda(node) => node.range(), - Self::IfExp(node) => node.range(), + Self::If(node) => node.range(), Self::Dict(node) => node.range(), Self::Set(node) => node.range(), Self::ListComp(node) => node.range(), Self::SetComp(node) => node.range(), Self::DictComp(node) => node.range(), - Self::GeneratorExp(node) => node.range(), + Self::Generator(node) => node.range(), Self::Await(node) => node.range(), Self::Yield(node) => node.range(), Self::YieldFrom(node) => node.range(), @@ -3883,14 +3883,14 @@ mod tests { assert_eq!(std::mem::size_of::(), 48); assert_eq!(std::mem::size_of::(), 8); assert_eq!(std::mem::size_of::(), 48); - assert_eq!(std::mem::size_of::(), 48); - assert_eq!(std::mem::size_of::(), 32); + assert_eq!(std::mem::size_of::(), 48); + assert_eq!(std::mem::size_of::(), 32); assert_eq!(std::mem::size_of::(), 32); assert_eq!(std::mem::size_of::(), 24); assert_eq!(std::mem::size_of::(), 40); assert_eq!(std::mem::size_of::(), 40); assert_eq!(std::mem::size_of::(), 40); - assert_eq!(std::mem::size_of::(), 24); + assert_eq!(std::mem::size_of::(), 24); assert_eq!(std::mem::size_of::(), 8); assert_eq!(std::mem::size_of::(), 32); assert_eq!(std::mem::size_of::(), 32); diff --git a/crates/ruff_python_ast/src/relocate.rs b/crates/ruff_python_ast/src/relocate.rs index 5c189fb4c6..f4f327d073 100644 --- a/crates/ruff_python_ast/src/relocate.rs +++ b/crates/ruff_python_ast/src/relocate.rs @@ -20,7 +20,7 @@ impl Transformer for Relocator { Expr::BoolOp(nodes::ExprBoolOp { range, .. }) => { *range = self.range; } - Expr::NamedExpr(nodes::ExprNamedExpr { range, .. }) => { + Expr::Named(nodes::ExprNamed { range, .. }) => { *range = self.range; } Expr::BinOp(nodes::ExprBinOp { range, .. }) => { @@ -32,7 +32,7 @@ impl Transformer for Relocator { Expr::Lambda(nodes::ExprLambda { range, .. }) => { *range = self.range; } - Expr::IfExp(nodes::ExprIfExp { range, .. }) => { + Expr::If(nodes::ExprIf { range, .. }) => { *range = self.range; } Expr::Dict(nodes::ExprDict { range, .. }) => { @@ -50,7 +50,7 @@ impl Transformer for Relocator { Expr::DictComp(nodes::ExprDictComp { range, .. }) => { *range = self.range; } - Expr::GeneratorExp(nodes::ExprGeneratorExp { range, .. }) => { + Expr::Generator(nodes::ExprGenerator { range, .. }) => { *range = self.range; } Expr::Await(nodes::ExprAwait { range, .. }) => { diff --git a/crates/ruff_python_ast/src/visitor.rs b/crates/ruff_python_ast/src/visitor.rs index 1c41bdd146..1233ff2d9e 100644 --- a/crates/ruff_python_ast/src/visitor.rs +++ b/crates/ruff_python_ast/src/visitor.rs @@ -342,7 +342,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) { visitor.visit_expr(expr); } } - Expr::NamedExpr(ast::ExprNamedExpr { + Expr::Named(ast::ExprNamed { target, value, range: _, @@ -378,7 +378,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) { } visitor.visit_expr(body); } - Expr::IfExp(ast::ExprIfExp { + Expr::If(ast::ExprIf { test, body, orelse, @@ -437,7 +437,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) { visitor.visit_expr(key); visitor.visit_expr(value); } - Expr::GeneratorExp(ast::ExprGeneratorExp { + Expr::Generator(ast::ExprGenerator { elt, generators, range: _, diff --git a/crates/ruff_python_ast/src/visitor/preorder.rs b/crates/ruff_python_ast/src/visitor/preorder.rs index 394d8cbf17..f6c70678d4 100644 --- a/crates/ruff_python_ast/src/visitor/preorder.rs +++ b/crates/ruff_python_ast/src/visitor/preorder.rs @@ -273,17 +273,17 @@ where if visitor.enter_node(node).is_traverse() { match expr { Expr::BoolOp(expr) => expr.visit_preorder(visitor), - Expr::NamedExpr(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::IfExp(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::GeneratorExp(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), diff --git a/crates/ruff_python_ast/src/visitor/transformer.rs b/crates/ruff_python_ast/src/visitor/transformer.rs index 3aa2622ceb..9bb6d4b208 100644 --- a/crates/ruff_python_ast/src/visitor/transformer.rs +++ b/crates/ruff_python_ast/src/visitor/transformer.rs @@ -329,7 +329,7 @@ pub fn walk_expr(visitor: &V, expr: &mut Expr) { visitor.visit_expr(expr); } } - Expr::NamedExpr(ast::ExprNamedExpr { + Expr::Named(ast::ExprNamed { target, value, range: _, @@ -365,7 +365,7 @@ pub fn walk_expr(visitor: &V, expr: &mut Expr) { } visitor.visit_expr(body); } - Expr::IfExp(ast::ExprIfExp { + Expr::If(ast::ExprIf { test, body, orelse, @@ -424,7 +424,7 @@ pub fn walk_expr(visitor: &V, expr: &mut Expr) { visitor.visit_expr(key); visitor.visit_expr(value); } - Expr::GeneratorExp(ast::ExprGeneratorExp { + Expr::Generator(ast::ExprGenerator { elt, generators, range: _, diff --git a/crates/ruff_python_codegen/src/generator.rs b/crates/ruff_python_codegen/src/generator.rs index 4358bf6131..35441e8c47 100644 --- a/crates/ruff_python_codegen/src/generator.rs +++ b/crates/ruff_python_codegen/src/generator.rs @@ -811,7 +811,7 @@ impl<'a> Generator<'a> { } }); } - Expr::NamedExpr(ast::ExprNamedExpr { + Expr::Named(ast::ExprNamed { target, value, range: _, @@ -887,7 +887,7 @@ impl<'a> Generator<'a> { self.unparse_expr(body, precedence::LAMBDA); }); } - Expr::IfExp(ast::ExprIfExp { + Expr::If(ast::ExprIf { test, body, orelse, @@ -967,7 +967,7 @@ impl<'a> Generator<'a> { self.unparse_comp(generators); self.p("}"); } - Expr::GeneratorExp(ast::ExprGeneratorExp { + Expr::Generator(ast::ExprGenerator { elt, generators, parenthesized: _, @@ -1034,7 +1034,7 @@ impl<'a> Generator<'a> { self.unparse_expr(func, precedence::MAX); self.p("("); if let ( - [Expr::GeneratorExp(ast::ExprGeneratorExp { + [Expr::Generator(ast::ExprGenerator { elt, generators, range: _, diff --git a/crates/ruff_python_formatter/src/comments/placement.rs b/crates/ruff_python_formatter/src/comments/placement.rs index babd7459f9..0418cdde33 100644 --- a/crates/ruff_python_formatter/src/comments/placement.rs +++ b/crates/ruff_python_formatter/src/comments/placement.rs @@ -227,14 +227,14 @@ fn handle_enclosed_comment<'a>( handle_pattern_keyword_comment(comment, pattern_keyword, locator) } AnyNodeRef::ExprUnaryOp(unary_op) => handle_unary_op_comment(comment, unary_op, locator), - AnyNodeRef::ExprNamedExpr(_) => handle_named_expr_comment(comment, locator), + AnyNodeRef::ExprNamed(_) => handle_named_expr_comment(comment, locator), AnyNodeRef::ExprLambda(lambda) => handle_lambda_comment(comment, lambda, locator), AnyNodeRef::ExprDict(_) => handle_dict_unpacking_comment(comment, locator) .or_else(|comment| handle_bracketed_end_of_line_comment(comment, locator)) .or_else(|comment| handle_key_value_comment(comment, locator)), AnyNodeRef::ExprDictComp(_) => handle_key_value_comment(comment, locator) .or_else(|comment| handle_bracketed_end_of_line_comment(comment, locator)), - AnyNodeRef::ExprIfExp(expr_if) => handle_expr_if_comment(comment, expr_if, locator), + AnyNodeRef::ExprIf(expr_if) => handle_expr_if_comment(comment, expr_if, locator), AnyNodeRef::ExprSlice(expr_slice) => { handle_slice_comments(comment, expr_slice, comment_ranges, locator) } @@ -317,7 +317,7 @@ fn handle_enclosed_comment<'a>( parenthesized: true, .. }) => handle_bracketed_end_of_line_comment(comment, locator), - AnyNodeRef::ExprGeneratorExp(generator) if generator.parenthesized => { + AnyNodeRef::ExprGenerator(generator) if generator.parenthesized => { handle_bracketed_end_of_line_comment(comment, locator) } _ => CommentPlacement::Default(comment), @@ -1353,10 +1353,10 @@ fn handle_attribute_comment<'a>( /// happens if the comments are in a weird position but it also doesn't hurt handling it. fn handle_expr_if_comment<'a>( comment: DecoratedComment<'a>, - expr_if: &'a ast::ExprIfExp, + expr_if: &'a ast::ExprIf, locator: &Locator, ) -> CommentPlacement<'a> { - let ast::ExprIfExp { + let ast::ExprIf { range: _, test, body, @@ -1612,7 +1612,7 @@ fn handle_named_expr_comment<'a>( comment: DecoratedComment<'a>, locator: &Locator, ) -> CommentPlacement<'a> { - debug_assert!(comment.enclosing_node().is_expr_named_expr()); + debug_assert!(comment.enclosing_node().is_expr_named()); let (Some(target), Some(value)) = (comment.preceding_node(), comment.following_node()) else { return CommentPlacement::Default(comment); diff --git a/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs b/crates/ruff_python_formatter/src/expression/expr_generator.rs similarity index 85% rename from crates/ruff_python_formatter/src/expression/expr_generator_exp.rs rename to crates/ruff_python_formatter/src/expression/expr_generator.rs index fcf75f4771..9e459d6824 100644 --- a/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs +++ b/crates/ruff_python_formatter/src/expression/expr_generator.rs @@ -1,6 +1,6 @@ use ruff_formatter::{format_args, write, FormatRuleWithOptions}; use ruff_python_ast::AnyNodeRef; -use ruff_python_ast::ExprGeneratorExp; +use ruff_python_ast::ExprGenerator; use crate::comments::SourceComment; use crate::expression::parentheses::{parenthesized, NeedsParentheses, OptionalParentheses}; @@ -20,7 +20,7 @@ pub enum GeneratorExpParentheses { Preserve, } -impl FormatRuleWithOptions> for FormatExprGeneratorExp { +impl FormatRuleWithOptions> for FormatExprGenerator { type Options = GeneratorExpParentheses; fn with_options(mut self, options: Self::Options) -> Self { @@ -30,13 +30,13 @@ impl FormatRuleWithOptions> for FormatExpr } #[derive(Default)] -pub struct FormatExprGeneratorExp { +pub struct FormatExprGenerator { parentheses: GeneratorExpParentheses, } -impl FormatNodeRule for FormatExprGeneratorExp { - fn fmt_fields(&self, item: &ExprGeneratorExp, f: &mut PyFormatter) -> FormatResult<()> { - let ExprGeneratorExp { +impl FormatNodeRule for FormatExprGenerator { + fn fmt_fields(&self, item: &ExprGenerator, f: &mut PyFormatter) -> FormatResult<()> { + let ExprGenerator { range: _, elt, generators, @@ -87,7 +87,7 @@ impl FormatNodeRule for FormatExprGeneratorExp { } } -impl NeedsParentheses for ExprGeneratorExp { +impl NeedsParentheses for ExprGenerator { fn needs_parentheses( &self, parent: AnyNodeRef, diff --git a/crates/ruff_python_formatter/src/expression/expr_if_exp.rs b/crates/ruff_python_formatter/src/expression/expr_if.rs similarity index 78% rename from crates/ruff_python_formatter/src/expression/expr_if_exp.rs rename to crates/ruff_python_formatter/src/expression/expr_if.rs index 5244e18d49..9d417531fc 100644 --- a/crates/ruff_python_formatter/src/expression/expr_if_exp.rs +++ b/crates/ruff_python_formatter/src/expression/expr_if.rs @@ -1,6 +1,6 @@ use ruff_formatter::{write, FormatRuleWithOptions}; use ruff_python_ast::AnyNodeRef; -use ruff_python_ast::{Expr, ExprIfExp}; +use ruff_python_ast::{Expr, ExprIf}; use crate::comments::leading_comments; use crate::expression::parentheses::{ @@ -10,11 +10,11 @@ use crate::expression::parentheses::{ use crate::prelude::*; #[derive(Default, Copy, Clone)] -pub enum ExprIfExpLayout { +pub enum ExprIfLayout { #[default] Default, - /// The [`ExprIfExp`] is nested inside another [`ExprIfExp`], so it should not be given a new + /// The [`ExprIf`] is nested inside another [`ExprIf`], so it should not be given a new /// group. For example, avoid grouping the `else` clause in: /// ```python /// clone._iterable_class = ( @@ -29,12 +29,12 @@ pub enum ExprIfExpLayout { } #[derive(Default)] -pub struct FormatExprIfExp { - layout: ExprIfExpLayout, +pub struct FormatExprIf { + layout: ExprIfLayout, } -impl FormatRuleWithOptions> for FormatExprIfExp { - type Options = ExprIfExpLayout; +impl FormatRuleWithOptions> for FormatExprIf { + type Options = ExprIfLayout; fn with_options(mut self, options: Self::Options) -> Self { self.layout = options; @@ -42,9 +42,9 @@ impl FormatRuleWithOptions> for FormatExprIfExp { } } -impl FormatNodeRule for FormatExprIfExp { - fn fmt_fields(&self, item: &ExprIfExp, f: &mut PyFormatter) -> FormatResult<()> { - let ExprIfExp { +impl FormatNodeRule for FormatExprIf { + fn fmt_fields(&self, item: &ExprIf, f: &mut PyFormatter) -> FormatResult<()> { + let ExprIf { range: _, test, body, @@ -76,13 +76,13 @@ impl FormatNodeRule for FormatExprIfExp { }); match self.layout { - ExprIfExpLayout::Default => in_parentheses_only_group(&inner).fmt(f), - ExprIfExpLayout::Nested => inner.fmt(f), + ExprIfLayout::Default => in_parentheses_only_group(&inner).fmt(f), + ExprIfLayout::Nested => inner.fmt(f), } } } -impl NeedsParentheses for ExprIfExp { +impl NeedsParentheses for ExprIf { fn needs_parentheses( &self, parent: AnyNodeRef, @@ -104,14 +104,14 @@ struct FormatOrElse<'a> { impl Format> for FormatOrElse<'_> { fn fmt(&self, f: &mut Formatter>) -> FormatResult<()> { match self.orelse { - Expr::IfExp(expr) + Expr::If(expr) if !is_expression_parenthesized( expr.into(), f.context().comments().ranges(), f.context().source(), ) => { - write!(f, [expr.format().with_options(ExprIfExpLayout::Nested)]) + write!(f, [expr.format().with_options(ExprIfLayout::Nested)]) } _ => write!(f, [in_parentheses_only_group(&self.orelse.format())]), } diff --git a/crates/ruff_python_formatter/src/expression/expr_named_expr.rs b/crates/ruff_python_formatter/src/expression/expr_named.rs similarity index 88% rename from crates/ruff_python_formatter/src/expression/expr_named_expr.rs rename to crates/ruff_python_formatter/src/expression/expr_named.rs index fff39ec4f2..5f8ec7f291 100644 --- a/crates/ruff_python_formatter/src/expression/expr_named_expr.rs +++ b/crates/ruff_python_formatter/src/expression/expr_named.rs @@ -1,6 +1,6 @@ use ruff_formatter::{format_args, write}; use ruff_python_ast::AnyNodeRef; -use ruff_python_ast::ExprNamedExpr; +use ruff_python_ast::ExprNamed; use crate::comments::{dangling_comments, SourceComment}; use crate::expression::parentheses::{ @@ -9,11 +9,11 @@ use crate::expression::parentheses::{ use crate::prelude::*; #[derive(Default)] -pub struct FormatExprNamedExpr; +pub struct FormatExprNamed; -impl FormatNodeRule for FormatExprNamedExpr { - fn fmt_fields(&self, item: &ExprNamedExpr, f: &mut PyFormatter) -> FormatResult<()> { - let ExprNamedExpr { +impl FormatNodeRule for FormatExprNamed { + fn fmt_fields(&self, item: &ExprNamed, f: &mut PyFormatter) -> FormatResult<()> { + let ExprNamed { target, value, range: _, @@ -53,7 +53,7 @@ impl FormatNodeRule for FormatExprNamedExpr { } } -impl NeedsParentheses for ExprNamedExpr { +impl NeedsParentheses for ExprNamed { fn needs_parentheses( &self, parent: AnyNodeRef, diff --git a/crates/ruff_python_formatter/src/expression/mod.rs b/crates/ruff_python_formatter/src/expression/mod.rs index 0b8291a7d4..2aea69895f 100644 --- a/crates/ruff_python_formatter/src/expression/mod.rs +++ b/crates/ruff_python_formatter/src/expression/mod.rs @@ -34,14 +34,14 @@ pub(crate) mod expr_dict; pub(crate) mod expr_dict_comp; pub(crate) mod expr_ellipsis_literal; pub(crate) mod expr_f_string; -pub(crate) mod expr_generator_exp; -pub(crate) mod expr_if_exp; +pub(crate) mod expr_generator; +pub(crate) mod expr_if; pub(crate) mod expr_ipy_escape_command; pub(crate) mod expr_lambda; pub(crate) mod expr_list; pub(crate) mod expr_list_comp; pub(crate) mod expr_name; -pub(crate) mod expr_named_expr; +pub(crate) mod expr_named; pub(crate) mod expr_none_literal; pub(crate) mod expr_number_literal; pub(crate) mod expr_set; @@ -77,17 +77,17 @@ impl FormatRule> for FormatExpr { let format_expr = format_with(|f| match expression { Expr::BoolOp(expr) => expr.format().fmt(f), - Expr::NamedExpr(expr) => expr.format().fmt(f), + Expr::Named(expr) => expr.format().fmt(f), Expr::BinOp(expr) => expr.format().fmt(f), Expr::UnaryOp(expr) => expr.format().fmt(f), Expr::Lambda(expr) => expr.format().fmt(f), - Expr::IfExp(expr) => expr.format().fmt(f), + Expr::If(expr) => expr.format().fmt(f), Expr::Dict(expr) => expr.format().fmt(f), Expr::Set(expr) => expr.format().fmt(f), Expr::ListComp(expr) => expr.format().fmt(f), Expr::SetComp(expr) => expr.format().fmt(f), Expr::DictComp(expr) => expr.format().fmt(f), - Expr::GeneratorExp(expr) => expr.format().fmt(f), + Expr::Generator(expr) => expr.format().fmt(f), Expr::Await(expr) => expr.format().fmt(f), Expr::Yield(expr) => expr.format().fmt(f), Expr::YieldFrom(expr) => expr.format().fmt(f), @@ -265,17 +265,17 @@ fn format_with_parentheses_comments( let fmt_fields = format_with(|f| match expression { Expr::BoolOp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), - Expr::NamedExpr(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), + Expr::Named(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::BinOp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::UnaryOp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::Lambda(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), - Expr::IfExp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), + Expr::If(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::Dict(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::Set(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::ListComp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::SetComp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::DictComp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), - Expr::GeneratorExp(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), + Expr::Generator(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::Await(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::Yield(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), Expr::YieldFrom(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f), @@ -461,17 +461,17 @@ impl NeedsParentheses for Expr { ) -> OptionalParentheses { match self { Expr::BoolOp(expr) => expr.needs_parentheses(parent, context), - Expr::NamedExpr(expr) => expr.needs_parentheses(parent, context), + Expr::Named(expr) => expr.needs_parentheses(parent, context), Expr::BinOp(expr) => expr.needs_parentheses(parent, context), Expr::UnaryOp(expr) => expr.needs_parentheses(parent, context), Expr::Lambda(expr) => expr.needs_parentheses(parent, context), - Expr::IfExp(expr) => expr.needs_parentheses(parent, context), + Expr::If(expr) => expr.needs_parentheses(parent, context), Expr::Dict(expr) => expr.needs_parentheses(parent, context), Expr::Set(expr) => expr.needs_parentheses(parent, context), Expr::ListComp(expr) => expr.needs_parentheses(parent, context), Expr::SetComp(expr) => expr.needs_parentheses(parent, context), Expr::DictComp(expr) => expr.needs_parentheses(parent, context), - Expr::GeneratorExp(expr) => expr.needs_parentheses(parent, context), + Expr::Generator(expr) => expr.needs_parentheses(parent, context), Expr::Await(expr) => expr.needs_parentheses(parent, context), Expr::Yield(expr) => expr.needs_parentheses(parent, context), Expr::YieldFrom(expr) => expr.needs_parentheses(parent, context), @@ -669,7 +669,7 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> { return; } - Expr::GeneratorExp(generator) if generator.parenthesized => { + Expr::Generator(generator) if generator.parenthesized => { self.any_parenthesized_expressions = true; // The values are always parenthesized, don't visit. return; @@ -693,7 +693,7 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> { range: _, }) => self.update_max_precedence(OperatorPrecedence::from(*op)), - Expr::IfExp(_) => { + Expr::If(_) => { // + 1 for the if and one for the else self.update_max_precedence_with_count(OperatorPrecedence::Conditional, 2); } @@ -763,7 +763,7 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> { } // Non terminal nodes that don't have a termination token. - Expr::NamedExpr(_) | Expr::GeneratorExp(_) | Expr::Tuple(_) => {} + Expr::Named(_) | Expr::Generator(_) | Expr::Tuple(_) => {} // Expressions with sub expressions but a preceding token // Mark this expression as first expression and not the sub expression. @@ -1035,7 +1035,7 @@ pub(crate) fn has_own_parentheses( Some(OwnParentheses::NonEmpty) } - Expr::GeneratorExp(generator) if generator.parenthesized => Some(OwnParentheses::NonEmpty), + Expr::Generator(generator) if generator.parenthesized => Some(OwnParentheses::NonEmpty), // These expressions must contain _some_ child or trivia token in order to be non-empty. Expr::List(ast::ExprList { elts, .. }) | Expr::Set(ast::ExprSet { elts, .. }) => { @@ -1118,12 +1118,12 @@ pub(crate) fn is_expression_huggable(expr: &Expr, context: &PyFormatContext) -> Expr::Starred(ast::ExprStarred { value, .. }) => is_expression_huggable(value, context), Expr::BoolOp(_) - | Expr::NamedExpr(_) + | Expr::Named(_) | Expr::BinOp(_) | Expr::UnaryOp(_) | Expr::Lambda(_) - | Expr::IfExp(_) - | Expr::GeneratorExp(_) + | Expr::If(_) + | Expr::Generator(_) | Expr::Await(_) | Expr::Yield(_) | Expr::YieldFrom(_) @@ -1193,7 +1193,7 @@ impl From for OperatorPrecedence { pub(crate) fn is_splittable_expression(expr: &Expr, context: &PyFormatContext) -> bool { match expr { // Single token expressions. They never have any split points. - Expr::NamedExpr(_) + Expr::Named(_) | Expr::Name(_) | Expr::NumberLiteral(_) | Expr::BooleanLiteral(_) @@ -1206,8 +1206,8 @@ pub(crate) fn is_splittable_expression(expr: &Expr, context: &PyFormatContext) - Expr::Compare(_) | Expr::BinOp(_) | Expr::BoolOp(_) - | Expr::IfExp(_) - | Expr::GeneratorExp(_) + | Expr::If(_) + | Expr::Generator(_) | Expr::Subscript(_) | Expr::Await(_) | Expr::ListComp(_) diff --git a/crates/ruff_python_formatter/src/generated.rs b/crates/ruff_python_formatter/src/generated.rs index a5217a11d1..63667ac509 100644 --- a/crates/ruff_python_formatter/src/generated.rs +++ b/crates/ruff_python_formatter/src/generated.rs @@ -966,38 +966,38 @@ impl<'ast> IntoFormat> for ast::ExprBoolOp { } } -impl FormatRule> - for crate::expression::expr_named_expr::FormatExprNamedExpr +impl FormatRule> + for crate::expression::expr_named::FormatExprNamed { #[inline] - fn fmt(&self, node: &ast::ExprNamedExpr, f: &mut PyFormatter) -> FormatResult<()> { - FormatNodeRule::::fmt(self, node, f) + fn fmt(&self, node: &ast::ExprNamed, f: &mut PyFormatter) -> FormatResult<()> { + FormatNodeRule::::fmt(self, node, f) } } -impl<'ast> AsFormat> for ast::ExprNamedExpr { +impl<'ast> AsFormat> for ast::ExprNamed { type Format<'a> = FormatRefWithRule< 'a, - ast::ExprNamedExpr, - crate::expression::expr_named_expr::FormatExprNamedExpr, + ast::ExprNamed, + crate::expression::expr_named::FormatExprNamed, PyFormatContext<'ast>, >; fn format(&self) -> Self::Format<'_> { FormatRefWithRule::new( self, - crate::expression::expr_named_expr::FormatExprNamedExpr::default(), + crate::expression::expr_named::FormatExprNamed::default(), ) } } -impl<'ast> IntoFormat> for ast::ExprNamedExpr { +impl<'ast> IntoFormat> for ast::ExprNamed { type Format = FormatOwnedWithRule< - ast::ExprNamedExpr, - crate::expression::expr_named_expr::FormatExprNamedExpr, + ast::ExprNamed, + crate::expression::expr_named::FormatExprNamed, PyFormatContext<'ast>, >; fn into_format(self) -> Self::Format { FormatOwnedWithRule::new( self, - crate::expression::expr_named_expr::FormatExprNamedExpr::default(), + crate::expression::expr_named::FormatExprNamed::default(), ) } } @@ -1110,39 +1110,31 @@ impl<'ast> IntoFormat> for ast::ExprLambda { } } -impl FormatRule> - for crate::expression::expr_if_exp::FormatExprIfExp -{ +impl FormatRule> for crate::expression::expr_if::FormatExprIf { #[inline] - fn fmt(&self, node: &ast::ExprIfExp, f: &mut PyFormatter) -> FormatResult<()> { - FormatNodeRule::::fmt(self, node, f) + fn fmt(&self, node: &ast::ExprIf, f: &mut PyFormatter) -> FormatResult<()> { + FormatNodeRule::::fmt(self, node, f) } } -impl<'ast> AsFormat> for ast::ExprIfExp { +impl<'ast> AsFormat> for ast::ExprIf { type Format<'a> = FormatRefWithRule< 'a, - ast::ExprIfExp, - crate::expression::expr_if_exp::FormatExprIfExp, + ast::ExprIf, + crate::expression::expr_if::FormatExprIf, PyFormatContext<'ast>, >; fn format(&self) -> Self::Format<'_> { - FormatRefWithRule::new( - self, - crate::expression::expr_if_exp::FormatExprIfExp::default(), - ) + FormatRefWithRule::new(self, crate::expression::expr_if::FormatExprIf::default()) } } -impl<'ast> IntoFormat> for ast::ExprIfExp { +impl<'ast> IntoFormat> for ast::ExprIf { type Format = FormatOwnedWithRule< - ast::ExprIfExp, - crate::expression::expr_if_exp::FormatExprIfExp, + ast::ExprIf, + crate::expression::expr_if::FormatExprIf, PyFormatContext<'ast>, >; fn into_format(self) -> Self::Format { - FormatOwnedWithRule::new( - self, - crate::expression::expr_if_exp::FormatExprIfExp::default(), - ) + FormatOwnedWithRule::new(self, crate::expression::expr_if::FormatExprIf::default()) } } @@ -1318,38 +1310,38 @@ impl<'ast> IntoFormat> for ast::ExprDictComp { } } -impl FormatRule> - for crate::expression::expr_generator_exp::FormatExprGeneratorExp +impl FormatRule> + for crate::expression::expr_generator::FormatExprGenerator { #[inline] - fn fmt(&self, node: &ast::ExprGeneratorExp, f: &mut PyFormatter) -> FormatResult<()> { - FormatNodeRule::::fmt(self, node, f) + fn fmt(&self, node: &ast::ExprGenerator, f: &mut PyFormatter) -> FormatResult<()> { + FormatNodeRule::::fmt(self, node, f) } } -impl<'ast> AsFormat> for ast::ExprGeneratorExp { +impl<'ast> AsFormat> for ast::ExprGenerator { type Format<'a> = FormatRefWithRule< 'a, - ast::ExprGeneratorExp, - crate::expression::expr_generator_exp::FormatExprGeneratorExp, + ast::ExprGenerator, + crate::expression::expr_generator::FormatExprGenerator, PyFormatContext<'ast>, >; fn format(&self) -> Self::Format<'_> { FormatRefWithRule::new( self, - crate::expression::expr_generator_exp::FormatExprGeneratorExp::default(), + crate::expression::expr_generator::FormatExprGenerator::default(), ) } } -impl<'ast> IntoFormat> for ast::ExprGeneratorExp { +impl<'ast> IntoFormat> for ast::ExprGenerator { type Format = FormatOwnedWithRule< - ast::ExprGeneratorExp, - crate::expression::expr_generator_exp::FormatExprGeneratorExp, + ast::ExprGenerator, + crate::expression::expr_generator::FormatExprGenerator, PyFormatContext<'ast>, >; fn into_format(self) -> Self::Format { FormatOwnedWithRule::new( self, - crate::expression::expr_generator_exp::FormatExprGeneratorExp::default(), + crate::expression::expr_generator::FormatExprGenerator::default(), ) } } diff --git a/crates/ruff_python_formatter/src/other/arguments.rs b/crates/ruff_python_formatter/src/other/arguments.rs index a92c3f3e0f..62871cdf31 100644 --- a/crates/ruff_python_formatter/src/other/arguments.rs +++ b/crates/ruff_python_formatter/src/other/arguments.rs @@ -4,7 +4,7 @@ use ruff_python_trivia::{PythonWhitespace, SimpleTokenKind, SimpleTokenizer}; use ruff_text_size::{Ranged, TextLen, TextRange, TextSize}; use crate::comments::SourceComment; -use crate::expression::expr_generator_exp::GeneratorExpParentheses; +use crate::expression::expr_generator::GeneratorExpParentheses; use crate::expression::is_expression_huggable; use crate::expression::parentheses::{empty_parenthesized, parenthesized, Parentheses}; use crate::other::commas; @@ -40,7 +40,7 @@ impl FormatNodeRule for FormatArguments { match args.as_ref() { [arg] if keywords.is_empty() => { match arg { - Expr::GeneratorExp(generator_exp) => joiner.entry( + Expr::Generator(generator_exp) => joiner.entry( generator_exp, &generator_exp .format() diff --git a/crates/ruff_python_formatter/src/range.rs b/crates/ruff_python_formatter/src/range.rs index c187c03b53..2997526671 100644 --- a/crates/ruff_python_formatter/src/range.rs +++ b/crates/ruff_python_formatter/src/range.rs @@ -648,17 +648,17 @@ impl Format> for FormatEnclosingNode<'_> { AnyNodeRef::ElifElseClause(node) => node.format().fmt(f), AnyNodeRef::ExprBoolOp(_) - | AnyNodeRef::ExprNamedExpr(_) + | AnyNodeRef::ExprNamed(_) | AnyNodeRef::ExprBinOp(_) | AnyNodeRef::ExprUnaryOp(_) | AnyNodeRef::ExprLambda(_) - | AnyNodeRef::ExprIfExp(_) + | AnyNodeRef::ExprIf(_) | AnyNodeRef::ExprDict(_) | AnyNodeRef::ExprSet(_) | AnyNodeRef::ExprListComp(_) | AnyNodeRef::ExprSetComp(_) | AnyNodeRef::ExprDictComp(_) - | AnyNodeRef::ExprGeneratorExp(_) + | AnyNodeRef::ExprGenerator(_) | AnyNodeRef::ExprAwait(_) | AnyNodeRef::ExprYield(_) | AnyNodeRef::ExprYieldFrom(_) diff --git a/crates/ruff_python_parser/src/invalid.rs b/crates/ruff_python_parser/src/invalid.rs index 909e6faf17..551af3db55 100644 --- a/crates/ruff_python_parser/src/invalid.rs +++ b/crates/ruff_python_parser/src/invalid.rs @@ -43,17 +43,17 @@ pub(crate) fn assignment_target(target: &Expr) -> Result<(), LexicalError> { }; match *target { BoolOp(ref e) => Err(err(e.range.start())), - NamedExpr(ref e) => Err(err(e.range.start())), + Named(ref e) => Err(err(e.range.start())), BinOp(ref e) => Err(err(e.range.start())), UnaryOp(ref e) => Err(err(e.range.start())), Lambda(ref e) => Err(err(e.range.start())), - IfExp(ref e) => Err(err(e.range.start())), + If(ref e) => Err(err(e.range.start())), Dict(ref e) => Err(err(e.range.start())), Set(ref e) => Err(err(e.range.start())), ListComp(ref e) => Err(err(e.range.start())), SetComp(ref e) => Err(err(e.range.start())), DictComp(ref e) => Err(err(e.range.start())), - GeneratorExp(ref e) => Err(err(e.range.start())), + Generator(ref e) => Err(err(e.range.start())), Await(ref e) => Err(err(e.range.start())), Yield(ref e) => Err(err(e.range.start())), YieldFrom(ref e) => Err(err(e.range.start())), diff --git a/crates/ruff_python_parser/src/parser.rs b/crates/ruff_python_parser/src/parser.rs index 60a855cc2e..e1ad6216a2 100644 --- a/crates/ruff_python_parser/src/parser.rs +++ b/crates/ruff_python_parser/src/parser.rs @@ -17,11 +17,11 @@ pub(super) use lalrpop_util::ParseError as LalrpopError; use ruff_python_ast::{ Expr, ExprAttribute, ExprAwait, ExprBinOp, ExprBoolOp, ExprBooleanLiteral, ExprBytesLiteral, - ExprCall, ExprCompare, ExprDict, ExprDictComp, ExprEllipsisLiteral, ExprFString, - ExprGeneratorExp, ExprIfExp, ExprIpyEscapeCommand, ExprLambda, ExprList, ExprListComp, - ExprName, ExprNamedExpr, ExprNoneLiteral, ExprNumberLiteral, ExprSet, ExprSetComp, ExprSlice, - ExprStarred, ExprStringLiteral, ExprSubscript, ExprTuple, ExprUnaryOp, ExprYield, - ExprYieldFrom, Mod, ModModule, Suite, + ExprCall, ExprCompare, ExprDict, ExprDictComp, ExprEllipsisLiteral, ExprFString, ExprGenerator, + ExprIf, ExprIpyEscapeCommand, ExprLambda, ExprList, ExprListComp, ExprName, ExprNamed, + ExprNoneLiteral, ExprNumberLiteral, ExprSet, ExprSetComp, ExprSlice, ExprStarred, + ExprStringLiteral, ExprSubscript, ExprTuple, ExprUnaryOp, ExprYield, ExprYieldFrom, Mod, + ModModule, Suite, }; use ruff_text_size::{Ranged, TextRange, TextSize}; @@ -409,9 +409,9 @@ impl From for ParenthesizedExpr { Expr::BoolOp(payload).into() } } -impl From for ParenthesizedExpr { - fn from(payload: ExprNamedExpr) -> Self { - Expr::NamedExpr(payload).into() +impl From for ParenthesizedExpr { + fn from(payload: ExprNamed) -> Self { + Expr::Named(payload).into() } } impl From for ParenthesizedExpr { @@ -429,9 +429,9 @@ impl From for ParenthesizedExpr { Expr::Lambda(payload).into() } } -impl From for ParenthesizedExpr { - fn from(payload: ExprIfExp) -> Self { - Expr::IfExp(payload).into() +impl From for ParenthesizedExpr { + fn from(payload: ExprIf) -> Self { + Expr::If(payload).into() } } impl From for ParenthesizedExpr { @@ -459,9 +459,9 @@ impl From for ParenthesizedExpr { Expr::DictComp(payload).into() } } -impl From for ParenthesizedExpr { - fn from(payload: ExprGeneratorExp) -> Self { - Expr::GeneratorExp(payload).into() +impl From for ParenthesizedExpr { + fn from(payload: ExprGenerator) -> Self { + Expr::Generator(payload).into() } } impl From for ParenthesizedExpr { diff --git a/crates/ruff_python_parser/src/python.lalrpop b/crates/ruff_python_parser/src/python.lalrpop index b10080e1e4..41b11fa292 100644 --- a/crates/ruff_python_parser/src/python.lalrpop +++ b/crates/ruff_python_parser/src/python.lalrpop @@ -1028,7 +1028,7 @@ WithItems: Vec = { // ``` // In this case, the `(` and `)` are part of the `with` statement. // The same applies to `yield` and `yield from`. - let item = if item.optional_vars.is_none() && matches!(item.context_expr, ast::Expr::NamedExpr(_) | ast::Expr::Yield(_) | ast::Expr::YieldFrom(_)) { + let item = if item.optional_vars.is_none() && matches!(item.context_expr, ast::Expr::Named(_) | ast::Expr::Yield(_) | ast::Expr::YieldFrom(_)) { ast::WithItem { range: item.range().add_start(TextSize::new(1)).sub_end(TextSize::new(1)), context_expr: item.context_expr, @@ -1330,7 +1330,7 @@ YieldExpr: crate::parser::ParenthesizedExpr = { }; Test: crate::parser::ParenthesizedExpr = { - > "if" > "else" > => ast::ExprIfExp { + > "if" > "else" > => ast::ExprIf { test: Box::new(test.into()), body: Box::new(body.into()), orelse: Box::new(orelse.into()), @@ -1355,7 +1355,7 @@ NamedExpressionName: crate::parser::ParenthesizedExpr = { NamedExpression: crate::parser::ParenthesizedExpr = { ":=" > => { - ast::ExprNamedExpr { + ast::ExprNamed { target: Box::new(target.into()), value: Box::new(value.into()), range: (location..end_location).into(), @@ -1770,7 +1770,7 @@ Atom: crate::parser::ParenthesizedExpr = { expr: e.into(), range: (location..end_location).into(), }, - "(" ")" => ast::ExprGeneratorExp { + "(" ")" => ast::ExprGenerator { elt: Box::new(elt.into()), generators, range: (location..end_location).into(), @@ -1921,8 +1921,8 @@ Arguments: ast::Arguments = { FunctionArgument: (Option<(TextSize, TextSize, Option)>, ast::Expr) = { => { let expr = match generators { - Some(generators) => ast::Expr::GeneratorExp( - ast::ExprGeneratorExp { + Some(generators) => ast::Expr::Generator( + ast::ExprGenerator { elt: Box::new(elt.into()), generators, range: (location..end_location).into(), diff --git a/crates/ruff_python_parser/src/python.rs b/crates/ruff_python_parser/src/python.rs index bd4535bdc6..a2a5c35389 100644 --- a/crates/ruff_python_parser/src/python.rs +++ b/crates/ruff_python_parser/src/python.rs @@ -1,5 +1,5 @@ // auto-generated: "lalrpop 0.20.0" -// sha3: d64ca7ff27121baee9d7a1b4d0f341932391a365fe75f115987b05bf2aaf538e +// sha3: 7adb931f958c3646393245e0bbd0700fd671ccfdea81f378daa8816c9036ca75 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize}; use ruff_python_ast::{self as ast, Int, IpyEscapeKind}; use crate::{ @@ -35409,7 +35409,7 @@ fn __action159< // ``` // In this case, the `(` and `)` are part of the `with` statement. // The same applies to `yield` and `yield from`. - let item = if item.optional_vars.is_none() && matches!(item.context_expr, ast::Expr::NamedExpr(_) | ast::Expr::Yield(_) | ast::Expr::YieldFrom(_)) { + let item = if item.optional_vars.is_none() && matches!(item.context_expr, ast::Expr::Named(_) | ast::Expr::Yield(_) | ast::Expr::YieldFrom(_)) { ast::WithItem { range: item.range().add_start(TextSize::new(1)).sub_end(TextSize::new(1)), context_expr: item.context_expr, @@ -35892,7 +35892,7 @@ fn __action183< ) -> crate::parser::ParenthesizedExpr { { - ast::ExprNamedExpr { + ast::ExprNamed { target: Box::new(target.into()), value: Box::new(value.into()), range: (location..end_location).into(), @@ -36796,8 +36796,8 @@ fn __action242< { { let expr = match generators { - Some(generators) => ast::Expr::GeneratorExp( - ast::ExprGeneratorExp { + Some(generators) => ast::Expr::Generator( + ast::ExprGenerator { elt: Box::new(elt.into()), generators, range: (location..end_location).into(), @@ -39128,7 +39128,7 @@ fn __action403< (_, end_location, _): (TextSize, TextSize, TextSize), ) -> crate::parser::ParenthesizedExpr { - ast::ExprIfExp { + ast::ExprIf { test: Box::new(test.into()), body: Box::new(body.into()), orelse: Box::new(orelse.into()), @@ -39545,7 +39545,7 @@ fn __action435< (_, end_location, _): (TextSize, TextSize, TextSize), ) -> crate::parser::ParenthesizedExpr { - ast::ExprIfExp { + ast::ExprIf { test: Box::new(test.into()), body: Box::new(body.into()), orelse: Box::new(orelse.into()), @@ -41410,7 +41410,7 @@ fn __action557< (_, end_location, _): (TextSize, TextSize, TextSize), ) -> crate::parser::ParenthesizedExpr { - ast::ExprGeneratorExp { + ast::ExprGenerator { elt: Box::new(elt.into()), generators, range: (location..end_location).into(), @@ -42115,7 +42115,7 @@ fn __action599< (_, end_location, _): (TextSize, TextSize, TextSize), ) -> crate::parser::ParenthesizedExpr { - ast::ExprGeneratorExp { + ast::ExprGenerator { elt: Box::new(elt.into()), generators, range: (location..end_location).into(), diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_named_expr.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_named_expr.snap index 4177eaaeb8..63b8236e4e 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_named_expr.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_named_expr.snap @@ -6,8 +6,8 @@ expression: parse_ast If( StmtIf { range: 0..14, - test: NamedExpr( - ExprNamedExpr { + test: Named( + ExprNamed { range: 3..8, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_assignment_expr.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_assignment_expr.snap index 58e38220f7..cf2c840aa0 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_assignment_expr.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_assignment_expr.snap @@ -7,8 +7,8 @@ Ok( Expr( StmtExpr { range: 0..8, - value: NamedExpr( - ExprNamedExpr { + value: Named( + ExprNamed { range: 1..7, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap index df4298d8de..3b04e2d6dd 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap @@ -32,8 +32,8 @@ Call( arguments: Arguments { range: 8..141, args: [ - GeneratorExp( - ExprGeneratorExp { + Generator( + ExprGenerator { range: 14..139, elt: Name( ExprName { @@ -56,8 +56,8 @@ Call( ExprTuple { range: 33..139, elts: [ - IfExp( - ExprIfExp { + If( + ExprIf { range: 43..80, test: Name( ExprName { @@ -100,8 +100,8 @@ Call( ), }, ), - IfExp( - ExprIfExp { + If( + ExprIf { range: 90..132, test: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap index 1fd737b95f..a0f26918e4 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap @@ -623,8 +623,8 @@ expression: parse_suite(source).unwrap() If( StmtIf { range: 508..527, - test: NamedExpr( - ExprNamedExpr { + test: Named( + ExprNamed { range: 511..521, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__named_expression.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__named_expression.snap index 18aef224ed..39154f69fd 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__named_expression.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__named_expression.snap @@ -2,8 +2,8 @@ source: crates/ruff_python_parser/src/parser.rs expression: parse_ast --- -NamedExpr( - ExprNamedExpr { +Named( + ExprNamed { range: 1..15, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap index 689cbc6111..bace4a7dbb 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap @@ -311,8 +311,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 164..170, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 164..170, target: Name( ExprName { @@ -350,8 +350,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 183..196, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 184..190, target: Name( ExprName { @@ -423,8 +423,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 226..234, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 227..233, target: Name( ExprName { @@ -481,8 +481,8 @@ expression: parse_suite(source).unwrap() }, WithItem { range: 256..264, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 257..263, target: Name( ExprName { @@ -531,8 +531,8 @@ expression: parse_suite(source).unwrap() }, WithItem { range: 281..289, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 282..288, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap index 556bfa858b..73b442c471 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap @@ -2,8 +2,8 @@ source: crates/ruff_python_parser/src/parser.rs expression: parse_ast --- -GeneratorExp( - ExprGeneratorExp { +Generator( + ExprGenerator { range: 0..14, elt: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap index ea82d262be..f5a76841ee 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap @@ -2,11 +2,11 @@ source: crates/ruff_python_parser/src/parser.rs expression: parse_ast --- -GeneratorExp( - ExprGeneratorExp { +Generator( + ExprGenerator { range: 0..26, - elt: IfExp( - ExprIfExp { + elt: If( + ExprIf { range: 1..14, test: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap index eb9aec31ec..3141b28fbb 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap @@ -2,11 +2,11 @@ source: crates/ruff_python_parser/src/parser.rs expression: parse_ast --- -GeneratorExp( - ExprGeneratorExp { +Generator( + ExprGenerator { range: 0..23, - elt: NamedExpr( - ExprNamedExpr { + elt: Named( + ExprNamed { range: 1..11, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap index 2b527edb99..32ccfc9e17 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap @@ -1846,8 +1846,8 @@ expression: parse_ast }, ), guard: Some( - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 1472..1482, target: Name( ExprName { @@ -3620,8 +3620,8 @@ expression: parse_ast ExprTuple { range: 2789..2796, elts: [ - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 2789..2795, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap index 6ac529f01f..8f8dc1302e 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap @@ -623,8 +623,8 @@ expression: parse_suite(source).unwrap() If( StmtIf { range: 481..499, - test: NamedExpr( - ExprNamedExpr { + test: Named( + ExprNamed { range: 484..493, target: Name( ExprName { diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap index 2d6cde0597..ac34bf5571 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap @@ -166,8 +166,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 78..91, - context_expr: IfExp( - ExprIfExp { + context_expr: If( + ExprIf { range: 78..91, test: NumberLiteral( ExprNumberLiteral { @@ -214,8 +214,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 103..121, - context_expr: IfExp( - ExprIfExp { + context_expr: If( + ExprIf { range: 103..116, test: NumberLiteral( ExprNumberLiteral { @@ -752,8 +752,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 362..368, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 362..368, target: Name( ExprName { @@ -791,8 +791,8 @@ expression: parse_suite(source).unwrap() items: [ WithItem { range: 381..394, - context_expr: NamedExpr( - ExprNamedExpr { + context_expr: Named( + ExprNamed { range: 382..388, target: Name( ExprName { @@ -842,8 +842,8 @@ expression: parse_suite(source).unwrap() ExprTuple { range: 406..422, elts: [ - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 407..413, target: Name( ExprName { @@ -862,8 +862,8 @@ expression: parse_suite(source).unwrap() ), }, ), - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 415..421, target: Name( ExprName { @@ -910,8 +910,8 @@ expression: parse_suite(source).unwrap() ExprTuple { range: 434..450, elts: [ - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 435..441, target: Name( ExprName { @@ -930,8 +930,8 @@ expression: parse_suite(source).unwrap() ), }, ), - NamedExpr( - ExprNamedExpr { + Named( + ExprNamed { range: 443..449, target: Name( ExprName { diff --git a/crates/ruff_python_semantic/src/analyze/type_inference.rs b/crates/ruff_python_semantic/src/analyze/type_inference.rs index 4a96689473..e2ecd8690e 100644 --- a/crates/ruff_python_semantic/src/analyze/type_inference.rs +++ b/crates/ruff_python_semantic/src/analyze/type_inference.rs @@ -76,7 +76,7 @@ impl From<&Expr> for ResolvedPythonType { Expr::List(_) => ResolvedPythonType::Atom(PythonType::List), Expr::ListComp(_) => ResolvedPythonType::Atom(PythonType::List), Expr::Tuple(_) => ResolvedPythonType::Atom(PythonType::Tuple), - Expr::GeneratorExp(_) => ResolvedPythonType::Atom(PythonType::Generator), + Expr::Generator(_) => ResolvedPythonType::Atom(PythonType::Generator), Expr::FString(_) => ResolvedPythonType::Atom(PythonType::String), Expr::StringLiteral(_) => ResolvedPythonType::Atom(PythonType::String), Expr::BytesLiteral(_) => ResolvedPythonType::Atom(PythonType::Bytes), @@ -97,10 +97,8 @@ impl From<&Expr> for ResolvedPythonType { Expr::NoneLiteral(_) => ResolvedPythonType::Atom(PythonType::None), Expr::EllipsisLiteral(_) => ResolvedPythonType::Atom(PythonType::Ellipsis), // Simple container expressions. - Expr::NamedExpr(ast::ExprNamedExpr { value, .. }) => { - ResolvedPythonType::from(value.as_ref()) - } - Expr::IfExp(ast::ExprIfExp { body, orelse, .. }) => { + Expr::Named(ast::ExprNamed { value, .. }) => ResolvedPythonType::from(value.as_ref()), + Expr::If(ast::ExprIf { body, orelse, .. }) => { let body = ResolvedPythonType::from(body.as_ref()); let orelse = ResolvedPythonType::from(orelse.as_ref()); body.union(orelse) diff --git a/crates/ruff_python_semantic/src/analyze/typing.rs b/crates/ruff_python_semantic/src/analyze/typing.rs index 59ba701b80..db7c7ab146 100644 --- a/crates/ruff_python_semantic/src/analyze/typing.rs +++ b/crates/ruff_python_semantic/src/analyze/typing.rs @@ -466,8 +466,8 @@ fn check_type(binding: &Binding, semantic: &SemanticModel) -> bo binding.source.is_some_and(|source| { semantic .expressions(source) - .find_map(|expr| expr.as_named_expr_expr()) - .and_then(|ast::ExprNamedExpr { target, value, .. }| { + .find_map(|expr| expr.as_named_expr()) + .and_then(|ast::ExprNamed { target, value, .. }| { match_value(binding, target.as_ref(), value.as_ref()) }) .is_some_and(|value| T::match_initializer(value, semantic)) @@ -818,8 +818,8 @@ pub fn find_binding_value<'a>(binding: &Binding, semantic: &'a SemanticModel) -> let parent_id = binding.source?; let parent = semantic .expressions(parent_id) - .find_map(|expr| expr.as_named_expr_expr()); - if let Some(ast::ExprNamedExpr { target, value, .. }) = parent { + .find_map(|expr| expr.as_named_expr()); + if let Some(ast::ExprNamed { target, value, .. }) = parent { return match_value(binding, target.as_ref(), value.as_ref()); } }