mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-02 16:47:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Separate grouped and ungrouped nodes more clearly in AST generator (#15646)

Browse source 
This is a minor cleanup to the AST generation script to make a clearer
separation between nodes that do appear in a group enum, and those that
don't. There are some types and methods that we create for every syntax
node, and others that refer to the group that the syntax node belongs
to, and which therefore don't make sense for ungrouped nodes. This new
separation makes it clearer which category each definition is in, since
you're either inside of a `for group in ast.groups` loop, or a `for node
in ast.all_nodes` loop.
This commit is contained in:
Douglas Creager 2025-01-21 13:37:18 -05:00 • committed by GitHub
parent fce4adfd41
commit fa546b20a6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 254 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

348
crates/ruff_python_ast/src/generated.rs generated
View file

@ -2387,18 +2387,6 @@ impl<'a> From<ModRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a crate::ModModule> for AnyNodeRef<'a> {
fn from(node: &'a crate::ModModule) -> AnyNodeRef<'a> {
AnyNodeRef::ModModule(node)
}
}
impl<'a> From<&'a crate::ModExpression> for AnyNodeRef<'a> {
fn from(node: &'a crate::ModExpression) -> AnyNodeRef<'a> {
AnyNodeRef::ModExpression(node)
}
}
impl<'a> From<&'a Stmt> for AnyNodeRef<'a> {
fn from(node: &'a Stmt) -> AnyNodeRef<'a> {
match node {
@ -2463,6 +2451,180 @@ impl<'a> From<StatementRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a Expr> for AnyNodeRef<'a> {
fn from(node: &'a Expr) -> AnyNodeRef<'a> {
match node {
Expr::BoolOp(node) => AnyNodeRef::ExprBoolOp(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::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::Generator(node) => AnyNodeRef::ExprGenerator(node),
Expr::Await(node) => AnyNodeRef::ExprAwait(node),
Expr::Yield(node) => AnyNodeRef::ExprYield(node),
Expr::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
Expr::Compare(node) => AnyNodeRef::ExprCompare(node),
Expr::Call(node) => AnyNodeRef::ExprCall(node),
Expr::FString(node) => AnyNodeRef::ExprFString(node),
Expr::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
Expr::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
Expr::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
Expr::BooleanLiteral(node) => AnyNodeRef::ExprBooleanLiteral(node),
Expr::NoneLiteral(node) => AnyNodeRef::ExprNoneLiteral(node),
Expr::EllipsisLiteral(node) => AnyNodeRef::ExprEllipsisLiteral(node),
Expr::Attribute(node) => AnyNodeRef::ExprAttribute(node),
Expr::Subscript(node) => AnyNodeRef::ExprSubscript(node),
Expr::Starred(node) => AnyNodeRef::ExprStarred(node),
Expr::Name(node) => AnyNodeRef::ExprName(node),
Expr::List(node) => AnyNodeRef::ExprList(node),
Expr::Tuple(node) => AnyNodeRef::ExprTuple(node),
Expr::Slice(node) => AnyNodeRef::ExprSlice(node),
Expr::IpyEscapeCommand(node) => AnyNodeRef::ExprIpyEscapeCommand(node),
}
}
}
impl<'a> From<ExpressionRef<'a>> for AnyNodeRef<'a> {
fn from(node: ExpressionRef<'a>) -> AnyNodeRef<'a> {
match node {
ExpressionRef::BoolOp(node) => AnyNodeRef::ExprBoolOp(node),
ExpressionRef::Named(node) => AnyNodeRef::ExprNamed(node),
ExpressionRef::BinOp(node) => AnyNodeRef::ExprBinOp(node),
ExpressionRef::UnaryOp(node) => AnyNodeRef::ExprUnaryOp(node),
ExpressionRef::Lambda(node) => AnyNodeRef::ExprLambda(node),
ExpressionRef::If(node) => AnyNodeRef::ExprIf(node),
ExpressionRef::Dict(node) => AnyNodeRef::ExprDict(node),
ExpressionRef::Set(node) => AnyNodeRef::ExprSet(node),
ExpressionRef::ListComp(node) => AnyNodeRef::ExprListComp(node),
ExpressionRef::SetComp(node) => AnyNodeRef::ExprSetComp(node),
ExpressionRef::DictComp(node) => AnyNodeRef::ExprDictComp(node),
ExpressionRef::Generator(node) => AnyNodeRef::ExprGenerator(node),
ExpressionRef::Await(node) => AnyNodeRef::ExprAwait(node),
ExpressionRef::Yield(node) => AnyNodeRef::ExprYield(node),
ExpressionRef::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
ExpressionRef::Compare(node) => AnyNodeRef::ExprCompare(node),
ExpressionRef::Call(node) => AnyNodeRef::ExprCall(node),
ExpressionRef::FString(node) => AnyNodeRef::ExprFString(node),
ExpressionRef::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
ExpressionRef::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
ExpressionRef::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
ExpressionRef::BooleanLiteral(node) => AnyNodeRef::ExprBooleanLiteral(node),
ExpressionRef::NoneLiteral(node) => AnyNodeRef::ExprNoneLiteral(node),
ExpressionRef::EllipsisLiteral(node) => AnyNodeRef::ExprEllipsisLiteral(node),
ExpressionRef::Attribute(node) => AnyNodeRef::ExprAttribute(node),
ExpressionRef::Subscript(node) => AnyNodeRef::ExprSubscript(node),
ExpressionRef::Starred(node) => AnyNodeRef::ExprStarred(node),
ExpressionRef::Name(node) => AnyNodeRef::ExprName(node),
ExpressionRef::List(node) => AnyNodeRef::ExprList(node),
ExpressionRef::Tuple(node) => AnyNodeRef::ExprTuple(node),
ExpressionRef::Slice(node) => AnyNodeRef::ExprSlice(node),
ExpressionRef::IpyEscapeCommand(node) => AnyNodeRef::ExprIpyEscapeCommand(node),
}
}
}
impl<'a> From<&'a ExceptHandler> for AnyNodeRef<'a> {
fn from(node: &'a ExceptHandler) -> AnyNodeRef<'a> {
match node {
ExceptHandler::ExceptHandler(node) => AnyNodeRef::ExceptHandlerExceptHandler(node),
}
}
}
impl<'a> From<ExceptHandlerRef<'a>> for AnyNodeRef<'a> {
fn from(node: ExceptHandlerRef<'a>) -> AnyNodeRef<'a> {
match node {
ExceptHandlerRef::ExceptHandler(node) => AnyNodeRef::ExceptHandlerExceptHandler(node),
}
}
}
impl<'a> From<&'a FStringElement> for AnyNodeRef<'a> {
fn from(node: &'a FStringElement) -> AnyNodeRef<'a> {
match node {
FStringElement::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
FStringElement::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
}
}
}
impl<'a> From<FStringElementRef<'a>> for AnyNodeRef<'a> {
fn from(node: FStringElementRef<'a>) -> AnyNodeRef<'a> {
match node {
FStringElementRef::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
FStringElementRef::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
}
}
}
impl<'a> From<&'a Pattern> for AnyNodeRef<'a> {
fn from(node: &'a Pattern) -> AnyNodeRef<'a> {
match node {
Pattern::MatchValue(node) => AnyNodeRef::PatternMatchValue(node),
Pattern::MatchSingleton(node) => AnyNodeRef::PatternMatchSingleton(node),
Pattern::MatchSequence(node) => AnyNodeRef::PatternMatchSequence(node),
Pattern::MatchMapping(node) => AnyNodeRef::PatternMatchMapping(node),
Pattern::MatchClass(node) => AnyNodeRef::PatternMatchClass(node),
Pattern::MatchStar(node) => AnyNodeRef::PatternMatchStar(node),
Pattern::MatchAs(node) => AnyNodeRef::PatternMatchAs(node),
Pattern::MatchOr(node) => AnyNodeRef::PatternMatchOr(node),
}
}
}
impl<'a> From<PatternRef<'a>> for AnyNodeRef<'a> {
fn from(node: PatternRef<'a>) -> AnyNodeRef<'a> {
match node {
PatternRef::MatchValue(node) => AnyNodeRef::PatternMatchValue(node),
PatternRef::MatchSingleton(node) => AnyNodeRef::PatternMatchSingleton(node),
PatternRef::MatchSequence(node) => AnyNodeRef::PatternMatchSequence(node),
PatternRef::MatchMapping(node) => AnyNodeRef::PatternMatchMapping(node),
PatternRef::MatchClass(node) => AnyNodeRef::PatternMatchClass(node),
PatternRef::MatchStar(node) => AnyNodeRef::PatternMatchStar(node),
PatternRef::MatchAs(node) => AnyNodeRef::PatternMatchAs(node),
PatternRef::MatchOr(node) => AnyNodeRef::PatternMatchOr(node),
}
}
}
impl<'a> From<&'a TypeParam> for AnyNodeRef<'a> {
fn from(node: &'a TypeParam) -> AnyNodeRef<'a> {
match node {
TypeParam::TypeVar(node) => AnyNodeRef::TypeParamTypeVar(node),
TypeParam::TypeVarTuple(node) => AnyNodeRef::TypeParamTypeVarTuple(node),
TypeParam::ParamSpec(node) => AnyNodeRef::TypeParamParamSpec(node),
}
}
}
impl<'a> From<TypeParamRef<'a>> for AnyNodeRef<'a> {
fn from(node: TypeParamRef<'a>) -> AnyNodeRef<'a> {
match node {
TypeParamRef::TypeVar(node) => AnyNodeRef::TypeParamTypeVar(node),
TypeParamRef::TypeVarTuple(node) => AnyNodeRef::TypeParamTypeVarTuple(node),
TypeParamRef::ParamSpec(node) => AnyNodeRef::TypeParamParamSpec(node),
}
}
}
impl<'a> From<&'a crate::ModModule> for AnyNodeRef<'a> {
fn from(node: &'a crate::ModModule) -> AnyNodeRef<'a> {
AnyNodeRef::ModModule(node)
}
}
impl<'a> From<&'a crate::ModExpression> for AnyNodeRef<'a> {
fn from(node: &'a crate::ModExpression) -> AnyNodeRef<'a> {
AnyNodeRef::ModExpression(node)
}
}
impl<'a> From<&'a crate::StmtFunctionDef> for AnyNodeRef<'a> {
fn from(node: &'a crate::StmtFunctionDef) -> AnyNodeRef<'a> {
AnyNodeRef::StmtFunctionDef(node)
@ -2613,84 +2775,6 @@ impl<'a> From<&'a crate::StmtIpyEscapeCommand> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a Expr> for AnyNodeRef<'a> {
fn from(node: &'a Expr) -> AnyNodeRef<'a> {
match node {
Expr::BoolOp(node) => AnyNodeRef::ExprBoolOp(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::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::Generator(node) => AnyNodeRef::ExprGenerator(node),
Expr::Await(node) => AnyNodeRef::ExprAwait(node),
Expr::Yield(node) => AnyNodeRef::ExprYield(node),
Expr::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
Expr::Compare(node) => AnyNodeRef::ExprCompare(node),
Expr::Call(node) => AnyNodeRef::ExprCall(node),
Expr::FString(node) => AnyNodeRef::ExprFString(node),
Expr::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
Expr::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
Expr::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
Expr::BooleanLiteral(node) => AnyNodeRef::ExprBooleanLiteral(node),
Expr::NoneLiteral(node) => AnyNodeRef::ExprNoneLiteral(node),
Expr::EllipsisLiteral(node) => AnyNodeRef::ExprEllipsisLiteral(node),
Expr::Attribute(node) => AnyNodeRef::ExprAttribute(node),
Expr::Subscript(node) => AnyNodeRef::ExprSubscript(node),
Expr::Starred(node) => AnyNodeRef::ExprStarred(node),
Expr::Name(node) => AnyNodeRef::ExprName(node),
Expr::List(node) => AnyNodeRef::ExprList(node),
Expr::Tuple(node) => AnyNodeRef::ExprTuple(node),
Expr::Slice(node) => AnyNodeRef::ExprSlice(node),
Expr::IpyEscapeCommand(node) => AnyNodeRef::ExprIpyEscapeCommand(node),
}
}
}
impl<'a> From<ExpressionRef<'a>> for AnyNodeRef<'a> {
fn from(node: ExpressionRef<'a>) -> AnyNodeRef<'a> {
match node {
ExpressionRef::BoolOp(node) => AnyNodeRef::ExprBoolOp(node),
ExpressionRef::Named(node) => AnyNodeRef::ExprNamed(node),
ExpressionRef::BinOp(node) => AnyNodeRef::ExprBinOp(node),
ExpressionRef::UnaryOp(node) => AnyNodeRef::ExprUnaryOp(node),
ExpressionRef::Lambda(node) => AnyNodeRef::ExprLambda(node),
ExpressionRef::If(node) => AnyNodeRef::ExprIf(node),
ExpressionRef::Dict(node) => AnyNodeRef::ExprDict(node),
ExpressionRef::Set(node) => AnyNodeRef::ExprSet(node),
ExpressionRef::ListComp(node) => AnyNodeRef::ExprListComp(node),
ExpressionRef::SetComp(node) => AnyNodeRef::ExprSetComp(node),
ExpressionRef::DictComp(node) => AnyNodeRef::ExprDictComp(node),
ExpressionRef::Generator(node) => AnyNodeRef::ExprGenerator(node),
ExpressionRef::Await(node) => AnyNodeRef::ExprAwait(node),
ExpressionRef::Yield(node) => AnyNodeRef::ExprYield(node),
ExpressionRef::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
ExpressionRef::Compare(node) => AnyNodeRef::ExprCompare(node),
ExpressionRef::Call(node) => AnyNodeRef::ExprCall(node),
ExpressionRef::FString(node) => AnyNodeRef::ExprFString(node),
ExpressionRef::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
ExpressionRef::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
ExpressionRef::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
ExpressionRef::BooleanLiteral(node) => AnyNodeRef::ExprBooleanLiteral(node),
ExpressionRef::NoneLiteral(node) => AnyNodeRef::ExprNoneLiteral(node),
ExpressionRef::EllipsisLiteral(node) => AnyNodeRef::ExprEllipsisLiteral(node),
ExpressionRef::Attribute(node) => AnyNodeRef::ExprAttribute(node),
ExpressionRef::Subscript(node) => AnyNodeRef::ExprSubscript(node),
ExpressionRef::Starred(node) => AnyNodeRef::ExprStarred(node),
ExpressionRef::Name(node) => AnyNodeRef::ExprName(node),
ExpressionRef::List(node) => AnyNodeRef::ExprList(node),
ExpressionRef::Tuple(node) => AnyNodeRef::ExprTuple(node),
ExpressionRef::Slice(node) => AnyNodeRef::ExprSlice(node),
ExpressionRef::IpyEscapeCommand(node) => AnyNodeRef::ExprIpyEscapeCommand(node),
}
}
}
impl<'a> From<&'a crate::ExprBoolOp> for AnyNodeRef<'a> {
fn from(node: &'a crate::ExprBoolOp) -> AnyNodeRef<'a> {
AnyNodeRef::ExprBoolOp(node)
@ -2883,46 +2967,12 @@ impl<'a> From<&'a crate::ExprIpyEscapeCommand> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ExceptHandler> for AnyNodeRef<'a> {
fn from(node: &'a ExceptHandler) -> AnyNodeRef<'a> {
match node {
ExceptHandler::ExceptHandler(node) => AnyNodeRef::ExceptHandlerExceptHandler(node),
}
}
}
impl<'a> From<ExceptHandlerRef<'a>> for AnyNodeRef<'a> {
fn from(node: ExceptHandlerRef<'a>) -> AnyNodeRef<'a> {
match node {
ExceptHandlerRef::ExceptHandler(node) => AnyNodeRef::ExceptHandlerExceptHandler(node),
}
}
}
impl<'a> From<&'a crate::ExceptHandlerExceptHandler> for AnyNodeRef<'a> {
fn from(node: &'a crate::ExceptHandlerExceptHandler) -> AnyNodeRef<'a> {
AnyNodeRef::ExceptHandlerExceptHandler(node)
}
}
impl<'a> From<&'a FStringElement> for AnyNodeRef<'a> {
fn from(node: &'a FStringElement) -> AnyNodeRef<'a> {
match node {
FStringElement::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
FStringElement::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
}
}
}
impl<'a> From<FStringElementRef<'a>> for AnyNodeRef<'a> {
fn from(node: FStringElementRef<'a>) -> AnyNodeRef<'a> {
match node {
FStringElementRef::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
FStringElementRef::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
}
}
}
impl<'a> From<&'a crate::FStringExpressionElement> for AnyNodeRef<'a> {
fn from(node: &'a crate::FStringExpressionElement) -> AnyNodeRef<'a> {
AnyNodeRef::FStringExpressionElement(node)
@ -2935,36 +2985,6 @@ impl<'a> From<&'a crate::FStringLiteralElement> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a Pattern> for AnyNodeRef<'a> {
fn from(node: &'a Pattern) -> AnyNodeRef<'a> {
match node {
Pattern::MatchValue(node) => AnyNodeRef::PatternMatchValue(node),
Pattern::MatchSingleton(node) => AnyNodeRef::PatternMatchSingleton(node),
Pattern::MatchSequence(node) => AnyNodeRef::PatternMatchSequence(node),
Pattern::MatchMapping(node) => AnyNodeRef::PatternMatchMapping(node),
Pattern::MatchClass(node) => AnyNodeRef::PatternMatchClass(node),
Pattern::MatchStar(node) => AnyNodeRef::PatternMatchStar(node),
Pattern::MatchAs(node) => AnyNodeRef::PatternMatchAs(node),
Pattern::MatchOr(node) => AnyNodeRef::PatternMatchOr(node),
}
}
}
impl<'a> From<PatternRef<'a>> for AnyNodeRef<'a> {
fn from(node: PatternRef<'a>) -> AnyNodeRef<'a> {
match node {
PatternRef::MatchValue(node) => AnyNodeRef::PatternMatchValue(node),
PatternRef::MatchSingleton(node) => AnyNodeRef::PatternMatchSingleton(node),
PatternRef::MatchSequence(node) => AnyNodeRef::PatternMatchSequence(node),
PatternRef::MatchMapping(node) => AnyNodeRef::PatternMatchMapping(node),
PatternRef::MatchClass(node) => AnyNodeRef::PatternMatchClass(node),
PatternRef::MatchStar(node) => AnyNodeRef::PatternMatchStar(node),
PatternRef::MatchAs(node) => AnyNodeRef::PatternMatchAs(node),
PatternRef::MatchOr(node) => AnyNodeRef::PatternMatchOr(node),
}
}
}
impl<'a> From<&'a crate::PatternMatchValue> for AnyNodeRef<'a> {
fn from(node: &'a crate::PatternMatchValue) -> AnyNodeRef<'a> {
AnyNodeRef::PatternMatchValue(node)
@ -3013,26 +3033,6 @@ impl<'a> From<&'a crate::PatternMatchOr> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a TypeParam> for AnyNodeRef<'a> {
fn from(node: &'a TypeParam) -> AnyNodeRef<'a> {
match node {
TypeParam::TypeVar(node) => AnyNodeRef::TypeParamTypeVar(node),
TypeParam::TypeVarTuple(node) => AnyNodeRef::TypeParamTypeVarTuple(node),
TypeParam::ParamSpec(node) => AnyNodeRef::TypeParamParamSpec(node),
}
}
}
impl<'a> From<TypeParamRef<'a>> for AnyNodeRef<'a> {
fn from(node: TypeParamRef<'a>) -> AnyNodeRef<'a> {
match node {
TypeParamRef::TypeVar(node) => AnyNodeRef::TypeParamTypeVar(node),
TypeParamRef::TypeVarTuple(node) => AnyNodeRef::TypeParamTypeVarTuple(node),
TypeParamRef::ParamSpec(node) => AnyNodeRef::TypeParamParamSpec(node),
}
}
}
impl<'a> From<&'a crate::TypeParamTypeVar> for AnyNodeRef<'a> {
fn from(node: &'a crate::TypeParamTypeVar) -> AnyNodeRef<'a> {
AnyNodeRef::TypeParamTypeVar(node)