mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-04 10:48:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Remove Expr postfix from ExprNamed, ExprIf, and ExprGenerator (#10229)

Browse source 
The expression types in our AST are called `ExprYield`, `ExprAwait`,
`ExprStringLiteral` etc, except `ExprNamedExpr`, `ExprIfExpr` and
`ExprGenratorExpr`. This seems to align with [Python AST's
naming](https://docs.python.org/3/library/ast.html) but feels
inconsistent and excessive.

This PR removes the `Expr` postfix from `ExprNamedExpr`, `ExprIfExpr`,
and `ExprGeneratorExpr`.
This commit is contained in:
Micha Reiser 2024-03-04 12:55:01 +01:00 • committed by GitHub
parent 8b749e1d4d
commit 184241f99a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
64 changed files with 418 additions and 428 deletions
Download patch file Download diff file Expand all files Collapse all files

10
crates/ruff_linter/src/checkers/ast/analyze/expression.rs
View file

@ -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);
}

8
crates/ruff_linter/src/checkers/ast/mod.rs
View file

@ -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(_) => {

2
crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs
View file

@ -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);
}

2
crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs
View file

@ -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;
}

2
crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs
View file

@ -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 {

2
crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs
View file

@ -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]`.

2
crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs
View file

@ -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}`.

2
crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs
View file

@ -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),

2
crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs
View file

@ -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()),

2
crates/ruff_linter/src/rules/flake8_simplify/rules/if_with_same_arms.rs
View file

@ -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 {

2
crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs
View file

@ -372,7 +372,7 @@ fn match_sibling_return<'a>(stmt: &'a Stmt, sibling: &'a Stmt) -> Option<Termina
/// Generate a return statement for an `any` or `all` builtin comprehension.
fn return_stmt(id: &str, test: &Expr, target: &Expr, iter: &Expr, generator: Generator) -> String {
let node = ast::ExprGeneratorExp {
let node = ast::ExprGenerator {
elt: Box::new(test.clone()),
generators: vec![Comprehension {
target: target.clone(),

2
crates/ruff_linter/src/rules/pandas_vet/helpers.rs
View file

@ -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)

2
crates/ruff_linter/src/rules/pyflakes/rules/strings.rs
View file

@ -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)),
_ => {}

2
crates/ruff_linter/src/rules/pylint/rules/literal_membership.rs
View file

@ -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,

2
crates/ruff_linter/src/rules/pylint/rules/named_expr_without_context.rs
View file

@ -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));

2
crates/ruff_linter/src/rules/pylint/rules/unnecessary_dict_index_lookup.rs
View file

@ -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 {

4
crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs
View file

@ -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()

2
crates/ruff_linter/src/rules/pylint/rules/unnecessary_list_index_lookup.rs
View file

@ -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 {

12
crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs
View file

@ -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(_)

6
crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs
View file

@ -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(_)

6
crates/ruff_linter/src/rules/refurb/rules/bit_count.rs
View file

@ -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(_)

2
crates/ruff_linter/src/rules/refurb/rules/if_expr_min_max.rs
View file

@ -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,

6
crates/ruff_linter/src/rules/refurb/rules/reimplemented_starmap.rs
View file

@ -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)
}
}

2
crates/ruff_linter/src/rules/ruff/rules/default_factory_kwarg.rs
View file

@ -120,7 +120,7 @@ fn is_non_callable_value(value: &Expr) -> bool {
| Expr::ListComp(_)
| Expr::SetComp(_)
| Expr::DictComp(_)
| Expr::GeneratorExp(_)
| Expr::Generator(_)
| Expr::FString(_))
}

6
crates/ruff_linter/src/rules/ruff/rules/invalid_formatter_suppression_comment.rs
View file

@ -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(_)

4
crates/ruff_linter/src/rules/ruff/rules/unnecessary_dict_comprehension_for_iterable.rs
View file

@ -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(_)
)
})
}

2
crates/ruff_linter/src/rules/ruff/rules/unnecessary_iterable_allocation_for_first_element.rs
View file

@ -185,7 +185,7 @@ fn match_iteration_target(expr: &Expr, semantic: &SemanticModel) -> Option<Itera
}
match arg {
Expr::GeneratorExp(ast::ExprGeneratorExp {
Expr::Generator(ast::ExprGenerator {
elt, generators, ..
}) => match match_simple_comprehension(elt, generators) {
Some(range) => IterationTarget {

2
crates/ruff_python_ast/src/all.rs
View file

@ -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);
}

24
crates/ruff_python_ast/src/comparable.rs
View file

@ -656,7 +656,7 @@ pub struct ExprBoolOp<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExprNamedExpr<'a> {
pub struct ExprNamed<'a> {
target: Box<ComparableExpr<'a>>,
value: Box<ComparableExpr<'a>>,
}
@ -681,7 +681,7 @@ pub struct ExprLambda<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExprIfExp<'a> {
pub struct ExprIf<'a> {
test: Box<ComparableExpr<'a>>,
body: Box<ComparableExpr<'a>>,
orelse: Box<ComparableExpr<'a>>,
@ -718,7 +718,7 @@ pub struct ExprDictComp<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExprGeneratorExp<'a> {
pub struct ExprGenerator<'a> {
elt: Box<ComparableExpr<'a>>,
generators: Vec<ComparableComprehension<'a>>,
}
@ -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(),
}),

42
crates/ruff_python_ast/src/expression.rs
View file

@ -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<ExpressionRef<'a>> 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(),

16
crates/ruff_python_ast/src/helpers.rs
View file

@ -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<Item = &'a Stmt>) -
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,

186
crates/ruff_python_ast/src/node.rs
View file

@ -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<Expr> {
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<Self>
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<Self>
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<Self>
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<Expr> 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<ast::ExprBoolOp> for AnyNode {
}
}
impl From<ast::ExprNamedExpr> for AnyNode {
fn from(node: ast::ExprNamedExpr) -> Self {
AnyNode::ExprNamedExpr(node)
impl From<ast::ExprNamed> for AnyNode {
fn from(node: ast::ExprNamed) -> Self {
AnyNode::ExprNamed(node)
}
}
@ -4816,9 +4816,9 @@ impl From<ast::ExprLambda> for AnyNode {
}
}
impl From<ast::ExprIfExp> for AnyNode {
fn from(node: ast::ExprIfExp) -> Self {
AnyNode::ExprIfExp(node)
impl From<ast::ExprIf> for AnyNode {
fn from(node: ast::ExprIf) -> Self {
AnyNode::ExprIf(node)
}
}
@ -4852,9 +4852,9 @@ impl From<ast::ExprDictComp> for AnyNode {
}
}
impl From<ast::ExprGeneratorExp> for AnyNode {
fn from(node: ast::ExprGeneratorExp) -> Self {
AnyNode::ExprGeneratorExp(node)
impl From<ast::ExprGenerator> 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,

54
crates/ruff_python_ast/src/nodes.rs
View file

@ -558,16 +558,16 @@ impl From<StmtContinue> 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<ExprBoolOp> 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<Expr>,
pub value: Box<Expr>,
}
impl From<ExprNamedExpr> for Expr {
fn from(payload: ExprNamedExpr) -> Self {
Expr::NamedExpr(payload)
impl From<ExprNamed> for Expr {
fn from(payload: ExprNamed) -> Self {
Expr::Named(payload)
}
}
@ -752,16 +752,16 @@ impl From<ExprLambda> 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<Expr>,
pub body: Box<Expr>,
pub orelse: Box<Expr>,
}
impl From<ExprIfExp> for Expr {
fn from(payload: ExprIfExp) -> Self {
Expr::IfExp(payload)
impl From<ExprIf> for Expr {
fn from(payload: ExprIf) -> Self {
Expr::If(payload)
}
}
@ -837,16 +837,16 @@ impl From<ExprDictComp> 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<Expr>,
pub generators: Vec<Comprehension>,
pub parenthesized: bool,
}
impl From<ExprGeneratorExp> for Expr {
fn from(payload: ExprGeneratorExp) -> Self {
Expr::GeneratorExp(payload)
impl From<ExprGenerator> 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::<ExprDictComp>(), 48);
assert_eq!(std::mem::size_of::<ExprEllipsisLiteral>(), 8);
assert_eq!(std::mem::size_of::<ExprFString>(), 48);
assert_eq!(std::mem::size_of::<ExprGeneratorExp>(), 48);
assert_eq!(std::mem::size_of::<ExprIfExp>(), 32);
assert_eq!(std::mem::size_of::<ExprGenerator>(), 48);
assert_eq!(std::mem::size_of::<ExprIf>(), 32);
assert_eq!(std::mem::size_of::<ExprIpyEscapeCommand>(), 32);
assert_eq!(std::mem::size_of::<ExprLambda>(), 24);
assert_eq!(std::mem::size_of::<ExprList>(), 40);
assert_eq!(std::mem::size_of::<ExprListComp>(), 40);
assert_eq!(std::mem::size_of::<ExprName>(), 40);
assert_eq!(std::mem::size_of::<ExprNamedExpr>(), 24);
assert_eq!(std::mem::size_of::<ExprNamed>(), 24);
assert_eq!(std::mem::size_of::<ExprNoneLiteral>(), 8);
assert_eq!(std::mem::size_of::<ExprNumberLiteral>(), 32);
assert_eq!(std::mem::size_of::<ExprSet>(), 32);

6
crates/ruff_python_ast/src/relocate.rs
View file

@ -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, .. }) => {

6
crates/ruff_python_ast/src/visitor.rs
View file

@ -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: _,

6
crates/ruff_python_ast/src/visitor/preorder.rs
View file

@ -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),

6
crates/ruff_python_ast/src/visitor/transformer.rs
View file

@ -329,7 +329,7 @@ pub fn walk_expr<V: Transformer + ?Sized>(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<V: Transformer + ?Sized>(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<V: Transformer + ?Sized>(visitor: &V, expr: &mut Expr) {
visitor.visit_expr(key);
visitor.visit_expr(value);
}
Expr::GeneratorExp(ast::ExprGeneratorExp {
Expr::Generator(ast::ExprGenerator {
elt,
generators,
range: _,

8
crates/ruff_python_codegen/src/generator.rs
View file

@ -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: _,

12
crates/ruff_python_formatter/src/comments/placement.rs
View file

@ -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);

14
crates/ruff_python_formatter/src/expression/expr_generator_exp.rs → crates/ruff_python_formatter/src/expression/expr_generator.rs
View file

@ -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<ExprGeneratorExp, PyFormatContext<'_>> for FormatExprGeneratorExp {
impl FormatRuleWithOptions<ExprGenerator, PyFormatContext<'_>> for FormatExprGenerator {
type Options = GeneratorExpParentheses;
fn with_options(mut self, options: Self::Options) -> Self {
@ -30,13 +30,13 @@ impl FormatRuleWithOptions<ExprGeneratorExp, PyFormatContext<'_>> for FormatExpr
}
#[derive(Default)]
pub struct FormatExprGeneratorExp {
pub struct FormatExprGenerator {
parentheses: GeneratorExpParentheses,
}
impl FormatNodeRule<ExprGeneratorExp> for FormatExprGeneratorExp {
fn fmt_fields(&self, item: &ExprGeneratorExp, f: &mut PyFormatter) -> FormatResult<()> {
let ExprGeneratorExp {
impl FormatNodeRule<ExprGenerator> for FormatExprGenerator {
fn fmt_fields(&self, item: &ExprGenerator, f: &mut PyFormatter) -> FormatResult<()> {
let ExprGenerator {
range: _,
elt,
generators,
@ -87,7 +87,7 @@ impl FormatNodeRule<ExprGeneratorExp> for FormatExprGeneratorExp {
}
}
impl NeedsParentheses for ExprGeneratorExp {
impl NeedsParentheses for ExprGenerator {
fn needs_parentheses(
&self,
parent: AnyNodeRef,

30
crates/ruff_python_formatter/src/expression/expr_if_exp.rs → crates/ruff_python_formatter/src/expression/expr_if.rs
View file

@ -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<ExprIfExp, PyFormatContext<'_>> for FormatExprIfExp {
type Options = ExprIfExpLayout;
impl FormatRuleWithOptions<ExprIf, PyFormatContext<'_>> for FormatExprIf {
type Options = ExprIfLayout;
fn with_options(mut self, options: Self::Options) -> Self {
self.layout = options;
@ -42,9 +42,9 @@ impl FormatRuleWithOptions<ExprIfExp, PyFormatContext<'_>> for FormatExprIfExp {
}
}
impl FormatNodeRule<ExprIfExp> for FormatExprIfExp {
fn fmt_fields(&self, item: &ExprIfExp, f: &mut PyFormatter) -> FormatResult<()> {
let ExprIfExp {
impl FormatNodeRule<ExprIf> for FormatExprIf {
fn fmt_fields(&self, item: &ExprIf, f: &mut PyFormatter) -> FormatResult<()> {
let ExprIf {
range: _,
test,
body,
@ -76,13 +76,13 @@ impl FormatNodeRule<ExprIfExp> 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<PyFormatContext<'_>> for FormatOrElse<'_> {
fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> 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())]),
}

12
crates/ruff_python_formatter/src/expression/expr_named_expr.rs → crates/ruff_python_formatter/src/expression/expr_named.rs
View file

@ -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<ExprNamedExpr> for FormatExprNamedExpr {
fn fmt_fields(&self, item: &ExprNamedExpr, f: &mut PyFormatter) -> FormatResult<()> {
let ExprNamedExpr {
impl FormatNodeRule<ExprNamed> for FormatExprNamed {
fn fmt_fields(&self, item: &ExprNamed, f: &mut PyFormatter) -> FormatResult<()> {
let ExprNamed {
target,
value,
range: _,
@ -53,7 +53,7 @@ impl FormatNodeRule<ExprNamedExpr> for FormatExprNamedExpr {
}
}
impl NeedsParentheses for ExprNamedExpr {
impl NeedsParentheses for ExprNamed {
fn needs_parentheses(
&self,
parent: AnyNodeRef,

44
crates/ruff_python_formatter/src/expression/mod.rs
View file

@ -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<Expr, PyFormatContext<'_>> 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<Operator> 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(_)

78
crates/ruff_python_formatter/src/generated.rs
View file

@ -966,38 +966,38 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExprBoolOp {
}
}
impl FormatRule<ast::ExprNamedExpr, PyFormatContext<'_>>
for crate::expression::expr_named_expr::FormatExprNamedExpr
impl FormatRule<ast::ExprNamed, PyFormatContext<'_>>
for crate::expression::expr_named::FormatExprNamed
{
#[inline]
fn fmt(&self, node: &ast::ExprNamedExpr, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprNamedExpr>::fmt(self, node, f)
fn fmt(&self, node: &ast::ExprNamed, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprNamed>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::ExprNamedExpr {
impl<'ast> AsFormat<PyFormatContext<'ast>> 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<PyFormatContext<'ast>> for ast::ExprNamedExpr {
impl<'ast> IntoFormat<PyFormatContext<'ast>> 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<PyFormatContext<'ast>> for ast::ExprLambda {
}
}
impl FormatRule<ast::ExprIfExp, PyFormatContext<'_>>
for crate::expression::expr_if_exp::FormatExprIfExp
{
impl FormatRule<ast::ExprIf, PyFormatContext<'_>> for crate::expression::expr_if::FormatExprIf {
#[inline]
fn fmt(&self, node: &ast::ExprIfExp, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprIfExp>::fmt(self, node, f)
fn fmt(&self, node: &ast::ExprIf, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprIf>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::ExprIfExp {
impl<'ast> AsFormat<PyFormatContext<'ast>> 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<PyFormatContext<'ast>> for ast::ExprIfExp {
impl<'ast> IntoFormat<PyFormatContext<'ast>> 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<PyFormatContext<'ast>> for ast::ExprDictComp {
}
}
impl FormatRule<ast::ExprGeneratorExp, PyFormatContext<'_>>
for crate::expression::expr_generator_exp::FormatExprGeneratorExp
impl FormatRule<ast::ExprGenerator, PyFormatContext<'_>>
for crate::expression::expr_generator::FormatExprGenerator
{
#[inline]
fn fmt(&self, node: &ast::ExprGeneratorExp, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprGeneratorExp>::fmt(self, node, f)
fn fmt(&self, node: &ast::ExprGenerator, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprGenerator>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::ExprGeneratorExp {
impl<'ast> AsFormat<PyFormatContext<'ast>> 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<PyFormatContext<'ast>> for ast::ExprGeneratorExp {
impl<'ast> IntoFormat<PyFormatContext<'ast>> 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(),
)
}
}

4
crates/ruff_python_formatter/src/other/arguments.rs
View file

@ -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<Arguments> 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()

6
crates/ruff_python_formatter/src/range.rs
View file

@ -648,17 +648,17 @@ impl Format<PyFormatContext<'_>> 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(_)

6
crates/ruff_python_parser/src/invalid.rs
View file

@ -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())),

28
crates/ruff_python_parser/src/parser.rs
View file

@ -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<ExprBoolOp> for ParenthesizedExpr {
Expr::BoolOp(payload).into()
}
}
impl From<ExprNamedExpr> for ParenthesizedExpr {
fn from(payload: ExprNamedExpr) -> Self {
Expr::NamedExpr(payload).into()
impl From<ExprNamed> for ParenthesizedExpr {
fn from(payload: ExprNamed) -> Self {
Expr::Named(payload).into()
}
}
impl From<ExprBinOp> for ParenthesizedExpr {
@ -429,9 +429,9 @@ impl From<ExprLambda> for ParenthesizedExpr {
Expr::Lambda(payload).into()
}
}
impl From<ExprIfExp> for ParenthesizedExpr {
fn from(payload: ExprIfExp) -> Self {
Expr::IfExp(payload).into()
impl From<ExprIf> for ParenthesizedExpr {
fn from(payload: ExprIf) -> Self {
Expr::If(payload).into()
}
}
impl From<ExprDict> for ParenthesizedExpr {
@ -459,9 +459,9 @@ impl From<ExprDictComp> for ParenthesizedExpr {
Expr::DictComp(payload).into()
}
}
impl From<ExprGeneratorExp> for ParenthesizedExpr {
fn from(payload: ExprGeneratorExp) -> Self {
Expr::GeneratorExp(payload).into()
impl From<ExprGenerator> for ParenthesizedExpr {
fn from(payload: ExprGenerator) -> Self {
Expr::Generator(payload).into()
}
}
impl From<ExprAwait> for ParenthesizedExpr {

12
crates/ruff_python_parser/src/python.lalrpop
View file

@ -1028,7 +1028,7 @@ WithItems: Vec<ast::WithItem> = {
// ```
// 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<Goal>: crate::parser::ParenthesizedExpr = {
<location:@L> <body:OrTest<"all">> "if" <test:OrTest<"all">> "else" <orelse:Test<"all">> <end_location:@R> => ast::ExprIfExp {
<location:@L> <body:OrTest<"all">> "if" <test:OrTest<"all">> "else" <orelse:Test<"all">> <end_location:@R> => 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 = {
<location:@L> <target:NamedExpressionName> ":=" <value:Test<"all">> <end_location:@R> => {
ast::ExprNamedExpr {
ast::ExprNamed {
target: Box::new(target.into()),
value: Box::new(value.into()),
range: (location..end_location).into(),
@ -1770,7 +1770,7 @@ Atom<Goal>: crate::parser::ParenthesizedExpr = {
expr: e.into(),
range: (location..end_location).into(),
},
<location:@L> "(" <elt:NamedExpressionTest> <generators:CompFor> ")" <end_location:@R> => ast::ExprGeneratorExp {
<location:@L> "(" <elt:NamedExpressionTest> <generators:CompFor> ")" <end_location:@R> => 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::Identifier>)>, ast::Expr) = {
<location:@L> <elt:NamedExpressionTest> <generators:CompFor?> <end_location:@R> => {
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(),

18
crates/ruff_python_parser/src/python.rs
View file

@ -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(),

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_named_expr.snap
View file

@ -6,8 +6,8 @@ expression: parse_ast
If(
StmtIf {
range: 0..14,
test: NamedExpr(
ExprNamedExpr {
test: Named(
ExprNamed {
range: 3..8,
target: Name(
ExprName {

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_assignment_expr.snap
View file

@ -7,8 +7,8 @@ Ok(
Expr(
StmtExpr {
range: 0..8,
value: NamedExpr(
ExprNamedExpr {
value: Named(
ExprNamed {
range: 1..7,
target: Name(
ExprName {

12
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap
View file

@ -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 {

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap
View file

@ -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 {

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__named_expression.snap
View file

@ -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 {

20
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap
View file

@ -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 {

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap
View file

@ -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 {

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap
View file

@ -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 {

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap
View file

@ -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 {

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap
View file

@ -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 {

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap
View file

@ -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 {

32
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap
View file

@ -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 {

8
crates/ruff_python_semantic/src/analyze/type_inference.rs
View file

@ -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)

8
crates/ruff_python_semantic/src/analyze/typing.rs
View file

@ -466,8 +466,8 @@ fn check_type<T: TypeChecker>(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());
}
}