mirror of
https://github.com/astral-sh/ruff.git
synced 2025-08-04 02:38:25 +00:00
Remove Expr postfix from ExprNamed, ExprIf, and ExprGenerator (#10229)
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
GitHub
parent
8b749e1d4d
commit
184241f99a
64 changed files with 418 additions and 428 deletions
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
}),
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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, .. }) => {
|
||||
|
|
|
|||
|
|
@ -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: _,
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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: _,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue