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

Add as_group methods to AnyNodeRef (#17048)

Browse source 
## Summary

This PR adds `as_<group>` methods to `AnyNodeRef` to e.g. convert an
`AnyNodeRef` to an `ExprRef`.

I need this for go to definition where the fallback is to test if
`AnyNodeRef` is an expression and then call `inferred_type` (listing
this mapping at every call site where we need to convert `AnyNodeRef` to
an `ExprRef` is a bit painful ;))

Split out from https://github.com/astral-sh/ruff/pull/16901

## Test Plan

`cargo test`
This commit is contained in:
Micha Reiser 2025-03-28 20:42:45 +01:00 • committed by GitHub
parent 050f332771
commit e07741e553
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 153 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -5050,6 +5050,17 @@ impl<'a> From<ModRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_mod_ref(self) -> Option<ModRef<'a>> {
match self {
Self::ModModule(node) => Some(ModRef::Module(node)),
Self::ModExpression(node) => Some(ModRef::Expression(node)),
_ => None,
}
}
}
impl<'a> From<&'a Stmt> for AnyNodeRef<'a> {
fn from(node: &'a Stmt) -> AnyNodeRef<'a> {
match node {
@ -5114,6 +5125,40 @@ impl<'a> From<StmtRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_stmt_ref(self) -> Option<StmtRef<'a>> {
match self {
Self::StmtFunctionDef(node) => Some(StmtRef::FunctionDef(node)),
Self::StmtClassDef(node) => Some(StmtRef::ClassDef(node)),
Self::StmtReturn(node) => Some(StmtRef::Return(node)),
Self::StmtDelete(node) => Some(StmtRef::Delete(node)),
Self::StmtTypeAlias(node) => Some(StmtRef::TypeAlias(node)),
Self::StmtAssign(node) => Some(StmtRef::Assign(node)),
Self::StmtAugAssign(node) => Some(StmtRef::AugAssign(node)),
Self::StmtAnnAssign(node) => Some(StmtRef::AnnAssign(node)),
Self::StmtFor(node) => Some(StmtRef::For(node)),
Self::StmtWhile(node) => Some(StmtRef::While(node)),
Self::StmtIf(node) => Some(StmtRef::If(node)),
Self::StmtWith(node) => Some(StmtRef::With(node)),
Self::StmtMatch(node) => Some(StmtRef::Match(node)),
Self::StmtRaise(node) => Some(StmtRef::Raise(node)),
Self::StmtTry(node) => Some(StmtRef::Try(node)),
Self::StmtAssert(node) => Some(StmtRef::Assert(node)),
Self::StmtImport(node) => Some(StmtRef::Import(node)),
Self::StmtImportFrom(node) => Some(StmtRef::ImportFrom(node)),
Self::StmtGlobal(node) => Some(StmtRef::Global(node)),
Self::StmtNonlocal(node) => Some(StmtRef::Nonlocal(node)),
Self::StmtExpr(node) => Some(StmtRef::Expr(node)),
Self::StmtPass(node) => Some(StmtRef::Pass(node)),
Self::StmtBreak(node) => Some(StmtRef::Break(node)),
Self::StmtContinue(node) => Some(StmtRef::Continue(node)),
Self::StmtIpyEscapeCommand(node) => Some(StmtRef::IpyEscapeCommand(node)),
_ => None,
}
}
}
impl<'a> From<&'a Expr> for AnyNodeRef<'a> {
fn from(node: &'a Expr) -> AnyNodeRef<'a> {
match node {
@ -5192,6 +5237,47 @@ impl<'a> From<ExprRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_expr_ref(self) -> Option<ExprRef<'a>> {
match self {
Self::ExprBoolOp(node) => Some(ExprRef::BoolOp(node)),
Self::ExprNamed(node) => Some(ExprRef::Named(node)),
Self::ExprBinOp(node) => Some(ExprRef::BinOp(node)),
Self::ExprUnaryOp(node) => Some(ExprRef::UnaryOp(node)),
Self::ExprLambda(node) => Some(ExprRef::Lambda(node)),
Self::ExprIf(node) => Some(ExprRef::If(node)),
Self::ExprDict(node) => Some(ExprRef::Dict(node)),
Self::ExprSet(node) => Some(ExprRef::Set(node)),
Self::ExprListComp(node) => Some(ExprRef::ListComp(node)),
Self::ExprSetComp(node) => Some(ExprRef::SetComp(node)),
Self::ExprDictComp(node) => Some(ExprRef::DictComp(node)),
Self::ExprGenerator(node) => Some(ExprRef::Generator(node)),
Self::ExprAwait(node) => Some(ExprRef::Await(node)),
Self::ExprYield(node) => Some(ExprRef::Yield(node)),
Self::ExprYieldFrom(node) => Some(ExprRef::YieldFrom(node)),
Self::ExprCompare(node) => Some(ExprRef::Compare(node)),
Self::ExprCall(node) => Some(ExprRef::Call(node)),
Self::ExprFString(node) => Some(ExprRef::FString(node)),
Self::ExprStringLiteral(node) => Some(ExprRef::StringLiteral(node)),
Self::ExprBytesLiteral(node) => Some(ExprRef::BytesLiteral(node)),
Self::ExprNumberLiteral(node) => Some(ExprRef::NumberLiteral(node)),
Self::ExprBooleanLiteral(node) => Some(ExprRef::BooleanLiteral(node)),
Self::ExprNoneLiteral(node) => Some(ExprRef::NoneLiteral(node)),
Self::ExprEllipsisLiteral(node) => Some(ExprRef::EllipsisLiteral(node)),
Self::ExprAttribute(node) => Some(ExprRef::Attribute(node)),
Self::ExprSubscript(node) => Some(ExprRef::Subscript(node)),
Self::ExprStarred(node) => Some(ExprRef::Starred(node)),
Self::ExprName(node) => Some(ExprRef::Name(node)),
Self::ExprList(node) => Some(ExprRef::List(node)),
Self::ExprTuple(node) => Some(ExprRef::Tuple(node)),
Self::ExprSlice(node) => Some(ExprRef::Slice(node)),
Self::ExprIpyEscapeCommand(node) => Some(ExprRef::IpyEscapeCommand(node)),
_ => None,
}
}
}
impl<'a> From<&'a ExceptHandler> for AnyNodeRef<'a> {
fn from(node: &'a ExceptHandler) -> AnyNodeRef<'a> {
match node {
@ -5208,6 +5294,16 @@ impl<'a> From<ExceptHandlerRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_except_handler_ref(self) -> Option<ExceptHandlerRef<'a>> {
match self {
Self::ExceptHandlerExceptHandler(node) => Some(ExceptHandlerRef::ExceptHandler(node)),
_ => None,
}
}
}
impl<'a> From<&'a FStringElement> for AnyNodeRef<'a> {
fn from(node: &'a FStringElement) -> AnyNodeRef<'a> {
match node {
@ -5226,6 +5322,17 @@ impl<'a> From<FStringElementRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_f_string_element_ref(self) -> Option<FStringElementRef<'a>> {
match self {
Self::FStringExpressionElement(node) => Some(FStringElementRef::Expression(node)),
Self::FStringLiteralElement(node) => Some(FStringElementRef::Literal(node)),
_ => None,
}
}
}
impl<'a> From<&'a Pattern> for AnyNodeRef<'a> {
fn from(node: &'a Pattern) -> AnyNodeRef<'a> {
match node {
@ -5256,6 +5363,23 @@ impl<'a> From<PatternRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_pattern_ref(self) -> Option<PatternRef<'a>> {
match self {
Self::PatternMatchValue(node) => Some(PatternRef::MatchValue(node)),
Self::PatternMatchSingleton(node) => Some(PatternRef::MatchSingleton(node)),
Self::PatternMatchSequence(node) => Some(PatternRef::MatchSequence(node)),
Self::PatternMatchMapping(node) => Some(PatternRef::MatchMapping(node)),
Self::PatternMatchClass(node) => Some(PatternRef::MatchClass(node)),
Self::PatternMatchStar(node) => Some(PatternRef::MatchStar(node)),
Self::PatternMatchAs(node) => Some(PatternRef::MatchAs(node)),
Self::PatternMatchOr(node) => Some(PatternRef::MatchOr(node)),
_ => None,
}
}
}
impl<'a> From<&'a TypeParam> for AnyNodeRef<'a> {
fn from(node: &'a TypeParam) -> AnyNodeRef<'a> {
match node {
@ -5276,6 +5400,18 @@ impl<'a> From<TypeParamRef<'a>> for AnyNodeRef<'a> {
}
}
impl<'a> AnyNodeRef<'a> {
pub fn as_type_param_ref(self) -> Option<TypeParamRef<'a>> {
match self {
Self::TypeParamTypeVar(node) => Some(TypeParamRef::TypeVar(node)),
Self::TypeParamTypeVarTuple(node) => Some(TypeParamRef::TypeVarTuple(node)),
Self::TypeParamParamSpec(node) => Some(TypeParamRef::ParamSpec(node)),
_ => None,
}
}
}
impl<'a> From<&'a crate::ModModule> for AnyNodeRef<'a> {
fn from(node: &'a crate::ModModule) -> AnyNodeRef<'a> {
AnyNodeRef::ModModule(node)