diff --git a/crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs b/crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs
index bd0c65a7dc..9323ab6d78 100644
--- a/crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs
+++ b/crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs
@@ -4,7 +4,6 @@ use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::AstNode;
 use ruff_python_ast::{self as ast, Expr, ExprCall, ExprContext};
 use ruff_python_codegen::Generator;
 use ruff_python_trivia::CommentRanges;
@@ -324,7 +323,7 @@ fn get_parametrize_name_range(
 ) -> Option<TextRange> {
     parenthesized_range(
         expr.into(),
-        call.arguments.as_any_node_ref(),
+        (&call.arguments).into(),
         comment_ranges,
         source,
     )
diff --git a/crates/ruff_linter/src/rules/flake8_use_pathlib/rules/path_constructor_current_directory.rs b/crates/ruff_linter/src/rules/flake8_use_pathlib/rules/path_constructor_current_directory.rs
index 82eee8b655..7eb043e1a2 100644
--- a/crates/ruff_linter/src/rules/flake8_use_pathlib/rules/path_constructor_current_directory.rs
+++ b/crates/ruff_linter/src/rules/flake8_use_pathlib/rules/path_constructor_current_directory.rs
@@ -3,7 +3,7 @@ use std::ops::Range;
 use ruff_diagnostics::{AlwaysFixableViolation, Applicability, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::{AstNode, Expr, ExprBinOp, ExprCall, Operator};
+use ruff_python_ast::{Expr, ExprBinOp, ExprCall, Operator};
 use ruff_python_semantic::SemanticModel;
 use ruff_python_trivia::CommentRanges;
 use ruff_text_size::{Ranged, TextRange};
@@ -134,12 +134,6 @@ fn parent_and_next_path_fragment_range(
 
     Some((
         parent.range(),
-        parenthesized_range(
-            right.into(),
-            parent.as_any_node_ref(),
-            comment_ranges,
-            source,
-        )
-        .unwrap_or(range),
+        parenthesized_range(right.into(), parent.into(), comment_ranges, source).unwrap_or(range),
     ))
 }
diff --git a/crates/ruff_linter/src/rules/pycodestyle/rules/lambda_assignment.rs b/crates/ruff_linter/src/rules/pycodestyle/rules/lambda_assignment.rs
index 725d930dd4..b30ca36d2c 100644
--- a/crates/ruff_linter/src/rules/pycodestyle/rules/lambda_assignment.rs
+++ b/crates/ruff_linter/src/rules/pycodestyle/rules/lambda_assignment.rs
@@ -2,7 +2,7 @@ use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::parenthesize::parenthesized_range;
 use ruff_python_ast::{
-    self as ast, AstNode, Expr, ExprEllipsisLiteral, ExprLambda, Identifier, Parameter,
+    self as ast, Expr, ExprEllipsisLiteral, ExprLambda, Identifier, Parameter,
     ParameterWithDefault, Parameters, Stmt,
 };
 use ruff_python_semantic::SemanticModel;
@@ -263,7 +263,7 @@ fn replace_trailing_ellipsis_with_original_expr(
 ) -> String {
     let original_expr_range = parenthesized_range(
         (&lambda.body).into(),
-        lambda.as_any_node_ref(),
+        lambda.into(),
         checker.comment_ranges(),
         checker.source(),
     )
diff --git a/crates/ruff_linter/src/rules/pylint/rules/non_augmented_assignment.rs b/crates/ruff_linter/src/rules/pylint/rules/non_augmented_assignment.rs
index 97155c9464..caf45ed739 100644
--- a/crates/ruff_linter/src/rules/pylint/rules/non_augmented_assignment.rs
+++ b/crates/ruff_linter/src/rules/pylint/rules/non_augmented_assignment.rs
@@ -4,7 +4,7 @@ use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast as ast;
 use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::{AstNode, ExprBinOp, ExpressionRef, Operator};
+use ruff_python_ast::{ExprBinOp, ExpressionRef, Operator};
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
@@ -147,7 +147,7 @@ fn augmented_assignment(
     let locator = checker.locator();
 
     let right_operand_ref = ExpressionRef::from(right_operand);
-    let parent = original_expr.as_any_node_ref();
+    let parent = original_expr.into();
     let comment_ranges = checker.comment_ranges();
     let source = checker.source();
 
diff --git a/crates/ruff_linter/src/rules/ruff/rules/quadratic_list_summation.rs b/crates/ruff_linter/src/rules/ruff/rules/quadratic_list_summation.rs
index 84c904b7dc..42e05baeed 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/quadratic_list_summation.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/quadratic_list_summation.rs
@@ -4,7 +4,6 @@ use itertools::Itertools;
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::AstNode;
 use ruff_python_ast::{self as ast, Arguments, Expr};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
@@ -110,7 +109,7 @@ fn convert_to_reduce(iterable: &Expr, call: &ast::ExprCall, checker: &Checker) -
     let iterable = checker.locator().slice(
         parenthesized_range(
             iterable.into(),
-            call.arguments.as_any_node_ref(),
+            (&call.arguments).into(),
             checker.comment_ranges(),
             checker.locator().contents(),
         )
diff --git a/crates/ruff_python_ast/ast.toml b/crates/ruff_python_ast/ast.toml
index 60b9cddd00..4e34b55fd7 100644
--- a/crates/ruff_python_ast/ast.toml
+++ b/crates/ruff_python_ast/ast.toml
@@ -23,9 +23,8 @@
 #   is, `StmtIf` will become `if_stmt`.)
 #
 # anynode_is_label: foo_bar
-#   Controls the name of the AnyNode::foo_bar, AnyNode::is_foo_bar, and
-#   AnyNodeRef::is_foo_bar methods.  The default is the group name in
-#   snake_case.
+#   Controls the name of the AnyNodeRef::is_foo_bar method.  The default is the
+#   group name in snake_case.
 #
 # ref_enum_ty:
 #   The name of the reference enum that we create for this group.  The default
diff --git a/crates/ruff_python_ast/generate.py b/crates/ruff_python_ast/generate.py
index e294314dbf..8cbeed3841 100644
--- a/crates/ruff_python_ast/generate.py
+++ b/crates/ruff_python_ast/generate.py
@@ -265,141 +265,6 @@ def write_ref_enum(out: list[str], groups: list[Group]) -> None:
         """)
 
 
-# ------------------------------------------------------------------------------
-# AnyNode
-
-
-def write_anynode(out: list[str], groups: list[Group]) -> None:
-    """
-    Create the AnyNode type.
-
-    ```rust
-    pub enum AnyNode {
-        ...
-        TypeParamTypeVar(TypeParamTypeVar),
-        TypeParamTypeVarTuple(TypeParamTypeVarTuple),
-        ...
-    }
-    ```
-
-    Also creates:
-    - `impl From<TypeParam> for AnyNode`
-    - `impl From<TypeParamTypeVarTuple> for AnyNode`
-    - `impl Ranged for AnyNode`
-    - `fn AnyNode::type_param(self) -> Option<TypeParam>`
-    - `fn AnyNode::is_type_param(&self) -> bool`
-    - `fn AnyNode::is_type_param_type_var(&self) -> bool`
-    - `fn AnyNode::as_ref(&self) -> AnyNodeRef`
-
-    The name of the `type_param` and `is_type_param` methods can be customized
-    via the `anynode_is_label` group option.
-    """
-
-    out.append("""
-    #[derive(Clone, Debug, is_macro::Is, PartialEq)]
-    pub enum AnyNode {
-    """)
-    for group in groups:
-        for node in group.nodes:
-            out.append(f"{node.name}({node.ty}),")
-    out.append("""
-    }
-    """)
-
-    for group in groups:
-        if group.name != "ungrouped":
-            out.append(f"""
-            impl From<{group.owned_enum_ty}> for AnyNode {{
-                fn from(node: {group.owned_enum_ty}) -> AnyNode {{
-                    match node {{
-            """)
-            for node in group.nodes:
-                out.append(
-                    f"""{group.owned_enum_ty}::{node.variant}(node) => AnyNode::{node.name}(node),"""
-                )
-            out.append("""
-                    }
-                }
-            }
-            """)
-
-        for node in group.nodes:
-            out.append(f"""
-            impl From<{node.ty}> for AnyNode {{
-                fn from(node: {node.ty}) -> AnyNode {{
-                    AnyNode::{node.name}(node)
-                }}
-            }}
-            """)
-
-    out.append("""
-        impl ruff_text_size::Ranged for AnyNode {
-            fn range(&self) -> ruff_text_size::TextRange {
-                match self {
-    """)
-    for group in groups:
-        for node in group.nodes:
-            out.append(f"""AnyNode::{node.name}(node) => node.range(),""")
-    out.append("""
-                }
-            }
-        }
-    """)
-
-    for group in groups:
-        if group.name == "ungrouped":
-            continue
-        out.append(f"""
-        impl AnyNode {{
-            pub fn {group.anynode_is_label}(self) -> Option<{group.owned_enum_ty}> {{
-                match self {{
-        """)
-        for node in group.nodes:
-            out.append(
-                f"""AnyNode::{node.name}(node) => Some({group.owned_enum_ty}::{node.variant}(node)),"""
-            )
-        out.append("""
-                    _ => None,
-                }
-            }
-        }
-        """)
-
-    for group in groups:
-        if group.name == "ungrouped":
-            continue
-        out.append(f"""
-        impl AnyNode {{
-            pub const fn is_{group.anynode_is_label}(&self) -> bool {{
-                matches!(self,
-        """)
-        for i, node in enumerate(group.nodes):
-            if i > 0:
-                out.append("|")
-            out.append(f"""AnyNode::{node.name}(_)""")
-        out.append("""
-                )
-            }
-        }
-        """)
-
-    out.append("""
-    impl AnyNode {
-        pub const fn as_ref(&self) -> AnyNodeRef {
-            match self {
-    """)
-    for group in groups:
-        for node in group.nodes:
-            out.append(
-                f"""AnyNode::{node.name}(node) => AnyNodeRef::{node.name}(node),"""
-            )
-    out.append("""
-            }
-        }
-    }
-    """)
-
-
 # ------------------------------------------------------------------------------
 # AnyNodeRef
 
@@ -424,7 +289,6 @@ def write_anynoderef(out: list[str], groups: list[Group]) -> None:
     - `impl Ranged for AnyNodeRef<'_>`
     - `fn AnyNodeRef::as_ptr(&self) -> std::ptr::NonNull<()>`
     - `fn AnyNodeRef::visit_preorder(self, visitor &mut impl SourceOrderVisitor)`
-    - `fn AnyNode::is_type_param(&self) -> bool`
     """
 
     out.append("""
@@ -565,7 +429,6 @@ def write_nodekind(out: list[str], groups: list[Group]) -> None:
     }
 
     Also creates:
-    - `fn AnyNode::kind(&self) -> NodeKind`
     - `fn AnyNodeRef::kind(self) -> NodeKind`
     ```
     """
@@ -581,20 +444,6 @@ def write_nodekind(out: list[str], groups: list[Group]) -> None:
     }
     """)
 
-    out.append("""
-    impl AnyNode {
-        pub const fn kind(&self) -> NodeKind {
-            match self {
-    """)
-    for group in groups:
-        for node in group.nodes:
-            out.append(f"""AnyNode::{node.name}(_) => NodeKind::{node.name},""")
-    out.append("""
-            }
-        }
-    }
-    """)
-
     out.append("""
     impl AnyNodeRef<'_> {
         pub const fn kind(self) -> NodeKind {
@@ -610,110 +459,6 @@ def write_nodekind(out: list[str], groups: list[Group]) -> None:
     """)
 
 
-# ------------------------------------------------------------------------------
-# AstNode
-
-
-def write_astnode(out: list[str], groups: list[Group]) -> None:
-    """
-    Creates AstNode trait impls:
-    - `impl AstNode for TypeParam`
-    - `impl AstNode for TypeParamTypeVar`
-    """
-
-    for group in groups:
-        if group.name != "ungrouped":
-            out.append(f"""
-            impl crate::AstNode for {group.owned_enum_ty} {{
-                type Ref<'a> = {group.ref_enum_ty}<'a>;
-
-                fn cast(node: AnyNode) -> Option<Self>
-                where
-                    Self: Sized,
-                {{
-                    match node {{
-            """)
-            for node in group.nodes:
-                out.append(
-                    f"""AnyNode::{node.name}(node) => Some({group.owned_enum_ty}::{node.variant}(node)),"""
-                )
-            out.append("""
-                        _ => None,
-                    }
-                }
-
-                fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-                    match node {
-            """)
-            for node in group.nodes:
-                out.append(
-                    f"""AnyNodeRef::{node.name}(node) => Some({group.ref_enum_ty}::{node.variant}(node)),"""
-                )
-            out.append("""
-                        _ => None,
-                    }
-                }
-
-                fn can_cast(kind: NodeKind) -> bool {
-                    matches!(kind,
-            """)
-            for i, node in enumerate(group.nodes):
-                if i > 0:
-                    out.append("|")
-                out.append(f"""NodeKind::{node.name}""")
-            out.append("""
-                    )
-                }
-
-                fn as_any_node_ref(&self) -> AnyNodeRef {
-                    AnyNodeRef::from(self)
-                }
-
-                fn into_any_node(self) -> AnyNode {
-                    AnyNode::from(self)
-                }
-            }
-            """)
-
-        for node in group.nodes:
-            out.append(f"""
-            impl crate::AstNode for {node.ty} {{
-                type Ref<'a> = &'a Self;
-
-                fn cast(kind: AnyNode) -> Option<Self>
-                where
-                    Self: Sized,
-                {{
-                    if let AnyNode::{node.name}(node) = kind {{
-                        Some(node)
-                    }} else {{
-                        None
-                    }}
-                }}
-
-                fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {{
-                    if let AnyNodeRef::{node.name}(node) = kind {{
-                        Some(node)
-                    }} else {{
-                        None
-                    }}
-                }}
-
-                fn can_cast(kind: NodeKind) -> bool {{
-                    matches!(kind, NodeKind::{node.name})
-                }}
-
-                fn as_any_node_ref(&self) -> AnyNodeRef {{
-                    AnyNodeRef::from(self)
-                }}
-
-                fn into_any_node(self) -> AnyNode {{
-                    AnyNode::from(self)
-                }}
-            }}
-            """)
-
-
 # ------------------------------------------------------------------------------
 # Format and write output
 
@@ -723,10 +468,8 @@ def generate(groups: list[Group]) -> list[str]:
     write_preamble(out)
     write_owned_enum(out, groups)
     write_ref_enum(out, groups)
-    write_anynode(out, groups)
     write_anynoderef(out, groups)
     write_nodekind(out, groups)
-    write_astnode(out, groups)
     return out
 
 
diff --git a/crates/ruff_python_ast/src/generated.rs b/crates/ruff_python_ast/src/generated.rs
index ac2ef3611c..3b6683f1d3 100644
--- a/crates/ruff_python_ast/src/generated.rs
+++ b/crates/ruff_python_ast/src/generated.rs
@@ -2273,1233 +2273,6 @@ impl ruff_text_size::Ranged for TypeParamRef<'_> {
     }
 }
 
-#[derive(Clone, Debug, is_macro::Is, PartialEq)]
-pub enum AnyNode {
-    ModModule(crate::ModModule),
-    ModExpression(crate::ModExpression),
-    StmtFunctionDef(crate::StmtFunctionDef),
-    StmtClassDef(crate::StmtClassDef),
-    StmtReturn(crate::StmtReturn),
-    StmtDelete(crate::StmtDelete),
-    StmtTypeAlias(crate::StmtTypeAlias),
-    StmtAssign(crate::StmtAssign),
-    StmtAugAssign(crate::StmtAugAssign),
-    StmtAnnAssign(crate::StmtAnnAssign),
-    StmtFor(crate::StmtFor),
-    StmtWhile(crate::StmtWhile),
-    StmtIf(crate::StmtIf),
-    StmtWith(crate::StmtWith),
-    StmtMatch(crate::StmtMatch),
-    StmtRaise(crate::StmtRaise),
-    StmtTry(crate::StmtTry),
-    StmtAssert(crate::StmtAssert),
-    StmtImport(crate::StmtImport),
-    StmtImportFrom(crate::StmtImportFrom),
-    StmtGlobal(crate::StmtGlobal),
-    StmtNonlocal(crate::StmtNonlocal),
-    StmtExpr(crate::StmtExpr),
-    StmtPass(crate::StmtPass),
-    StmtBreak(crate::StmtBreak),
-    StmtContinue(crate::StmtContinue),
-    StmtIpyEscapeCommand(crate::StmtIpyEscapeCommand),
-    ExprBoolOp(crate::ExprBoolOp),
-    ExprNamed(crate::ExprNamed),
-    ExprBinOp(crate::ExprBinOp),
-    ExprUnaryOp(crate::ExprUnaryOp),
-    ExprLambda(crate::ExprLambda),
-    ExprIf(crate::ExprIf),
-    ExprDict(crate::ExprDict),
-    ExprSet(crate::ExprSet),
-    ExprListComp(crate::ExprListComp),
-    ExprSetComp(crate::ExprSetComp),
-    ExprDictComp(crate::ExprDictComp),
-    ExprGenerator(crate::ExprGenerator),
-    ExprAwait(crate::ExprAwait),
-    ExprYield(crate::ExprYield),
-    ExprYieldFrom(crate::ExprYieldFrom),
-    ExprCompare(crate::ExprCompare),
-    ExprCall(crate::ExprCall),
-    ExprFString(crate::ExprFString),
-    ExprStringLiteral(crate::ExprStringLiteral),
-    ExprBytesLiteral(crate::ExprBytesLiteral),
-    ExprNumberLiteral(crate::ExprNumberLiteral),
-    ExprBooleanLiteral(crate::ExprBooleanLiteral),
-    ExprNoneLiteral(crate::ExprNoneLiteral),
-    ExprEllipsisLiteral(crate::ExprEllipsisLiteral),
-    ExprAttribute(crate::ExprAttribute),
-    ExprSubscript(crate::ExprSubscript),
-    ExprStarred(crate::ExprStarred),
-    ExprName(crate::ExprName),
-    ExprList(crate::ExprList),
-    ExprTuple(crate::ExprTuple),
-    ExprSlice(crate::ExprSlice),
-    ExprIpyEscapeCommand(crate::ExprIpyEscapeCommand),
-    ExceptHandlerExceptHandler(crate::ExceptHandlerExceptHandler),
-    FStringExpressionElement(crate::FStringExpressionElement),
-    FStringLiteralElement(crate::FStringLiteralElement),
-    PatternMatchValue(crate::PatternMatchValue),
-    PatternMatchSingleton(crate::PatternMatchSingleton),
-    PatternMatchSequence(crate::PatternMatchSequence),
-    PatternMatchMapping(crate::PatternMatchMapping),
-    PatternMatchClass(crate::PatternMatchClass),
-    PatternMatchStar(crate::PatternMatchStar),
-    PatternMatchAs(crate::PatternMatchAs),
-    PatternMatchOr(crate::PatternMatchOr),
-    TypeParamTypeVar(crate::TypeParamTypeVar),
-    TypeParamTypeVarTuple(crate::TypeParamTypeVarTuple),
-    TypeParamParamSpec(crate::TypeParamParamSpec),
-    FStringFormatSpec(crate::FStringFormatSpec),
-    PatternArguments(crate::PatternArguments),
-    PatternKeyword(crate::PatternKeyword),
-    Comprehension(crate::Comprehension),
-    Arguments(crate::Arguments),
-    Parameters(crate::Parameters),
-    Parameter(crate::Parameter),
-    ParameterWithDefault(crate::ParameterWithDefault),
-    Keyword(crate::Keyword),
-    Alias(crate::Alias),
-    WithItem(crate::WithItem),
-    MatchCase(crate::MatchCase),
-    Decorator(crate::Decorator),
-    ElifElseClause(crate::ElifElseClause),
-    TypeParams(crate::TypeParams),
-    FString(crate::FString),
-    StringLiteral(crate::StringLiteral),
-    BytesLiteral(crate::BytesLiteral),
-    Identifier(crate::Identifier),
-}
-
-impl From<Mod> for AnyNode {
-    fn from(node: Mod) -> AnyNode {
-        match node {
-            Mod::Module(node) => AnyNode::ModModule(node),
-            Mod::Expression(node) => AnyNode::ModExpression(node),
-        }
-    }
-}
-
-impl From<crate::ModModule> for AnyNode {
-    fn from(node: crate::ModModule) -> AnyNode {
-        AnyNode::ModModule(node)
-    }
-}
-
-impl From<crate::ModExpression> for AnyNode {
-    fn from(node: crate::ModExpression) -> AnyNode {
-        AnyNode::ModExpression(node)
-    }
-}
-
-impl From<Stmt> for AnyNode {
-    fn from(node: Stmt) -> AnyNode {
-        match node {
-            Stmt::FunctionDef(node) => AnyNode::StmtFunctionDef(node),
-            Stmt::ClassDef(node) => AnyNode::StmtClassDef(node),
-            Stmt::Return(node) => AnyNode::StmtReturn(node),
-            Stmt::Delete(node) => AnyNode::StmtDelete(node),
-            Stmt::TypeAlias(node) => AnyNode::StmtTypeAlias(node),
-            Stmt::Assign(node) => AnyNode::StmtAssign(node),
-            Stmt::AugAssign(node) => AnyNode::StmtAugAssign(node),
-            Stmt::AnnAssign(node) => AnyNode::StmtAnnAssign(node),
-            Stmt::For(node) => AnyNode::StmtFor(node),
-            Stmt::While(node) => AnyNode::StmtWhile(node),
-            Stmt::If(node) => AnyNode::StmtIf(node),
-            Stmt::With(node) => AnyNode::StmtWith(node),
-            Stmt::Match(node) => AnyNode::StmtMatch(node),
-            Stmt::Raise(node) => AnyNode::StmtRaise(node),
-            Stmt::Try(node) => AnyNode::StmtTry(node),
-            Stmt::Assert(node) => AnyNode::StmtAssert(node),
-            Stmt::Import(node) => AnyNode::StmtImport(node),
-            Stmt::ImportFrom(node) => AnyNode::StmtImportFrom(node),
-            Stmt::Global(node) => AnyNode::StmtGlobal(node),
-            Stmt::Nonlocal(node) => AnyNode::StmtNonlocal(node),
-            Stmt::Expr(node) => AnyNode::StmtExpr(node),
-            Stmt::Pass(node) => AnyNode::StmtPass(node),
-            Stmt::Break(node) => AnyNode::StmtBreak(node),
-            Stmt::Continue(node) => AnyNode::StmtContinue(node),
-            Stmt::IpyEscapeCommand(node) => AnyNode::StmtIpyEscapeCommand(node),
-        }
-    }
-}
-
-impl From<crate::StmtFunctionDef> for AnyNode {
-    fn from(node: crate::StmtFunctionDef) -> AnyNode {
-        AnyNode::StmtFunctionDef(node)
-    }
-}
-
-impl From<crate::StmtClassDef> for AnyNode {
-    fn from(node: crate::StmtClassDef) -> AnyNode {
-        AnyNode::StmtClassDef(node)
-    }
-}
-
-impl From<crate::StmtReturn> for AnyNode {
-    fn from(node: crate::StmtReturn) -> AnyNode {
-        AnyNode::StmtReturn(node)
-    }
-}
-
-impl From<crate::StmtDelete> for AnyNode {
-    fn from(node: crate::StmtDelete) -> AnyNode {
-        AnyNode::StmtDelete(node)
-    }
-}
-
-impl From<crate::StmtTypeAlias> for AnyNode {
-    fn from(node: crate::StmtTypeAlias) -> AnyNode {
-        AnyNode::StmtTypeAlias(node)
-    }
-}
-
-impl From<crate::StmtAssign> for AnyNode {
-    fn from(node: crate::StmtAssign) -> AnyNode {
-        AnyNode::StmtAssign(node)
-    }
-}
-
-impl From<crate::StmtAugAssign> for AnyNode {
-    fn from(node: crate::StmtAugAssign) -> AnyNode {
-        AnyNode::StmtAugAssign(node)
-    }
-}
-
-impl From<crate::StmtAnnAssign> for AnyNode {
-    fn from(node: crate::StmtAnnAssign) -> AnyNode {
-        AnyNode::StmtAnnAssign(node)
-    }
-}
-
-impl From<crate::StmtFor> for AnyNode {
-    fn from(node: crate::StmtFor) -> AnyNode {
-        AnyNode::StmtFor(node)
-    }
-}
-
-impl From<crate::StmtWhile> for AnyNode {
-    fn from(node: crate::StmtWhile) -> AnyNode {
-        AnyNode::StmtWhile(node)
-    }
-}
-
-impl From<crate::StmtIf> for AnyNode {
-    fn from(node: crate::StmtIf) -> AnyNode {
-        AnyNode::StmtIf(node)
-    }
-}
-
-impl From<crate::StmtWith> for AnyNode {
-    fn from(node: crate::StmtWith) -> AnyNode {
-        AnyNode::StmtWith(node)
-    }
-}
-
-impl From<crate::StmtMatch> for AnyNode {
-    fn from(node: crate::StmtMatch) -> AnyNode {
-        AnyNode::StmtMatch(node)
-    }
-}
-
-impl From<crate::StmtRaise> for AnyNode {
-    fn from(node: crate::StmtRaise) -> AnyNode {
-        AnyNode::StmtRaise(node)
-    }
-}
-
-impl From<crate::StmtTry> for AnyNode {
-    fn from(node: crate::StmtTry) -> AnyNode {
-        AnyNode::StmtTry(node)
-    }
-}
-
-impl From<crate::StmtAssert> for AnyNode {
-    fn from(node: crate::StmtAssert) -> AnyNode {
-        AnyNode::StmtAssert(node)
-    }
-}
-
-impl From<crate::StmtImport> for AnyNode {
-    fn from(node: crate::StmtImport) -> AnyNode {
-        AnyNode::StmtImport(node)
-    }
-}
-
-impl From<crate::StmtImportFrom> for AnyNode {
-    fn from(node: crate::StmtImportFrom) -> AnyNode {
-        AnyNode::StmtImportFrom(node)
-    }
-}
-
-impl From<crate::StmtGlobal> for AnyNode {
-    fn from(node: crate::StmtGlobal) -> AnyNode {
-        AnyNode::StmtGlobal(node)
-    }
-}
-
-impl From<crate::StmtNonlocal> for AnyNode {
-    fn from(node: crate::StmtNonlocal) -> AnyNode {
-        AnyNode::StmtNonlocal(node)
-    }
-}
-
-impl From<crate::StmtExpr> for AnyNode {
-    fn from(node: crate::StmtExpr) -> AnyNode {
-        AnyNode::StmtExpr(node)
-    }
-}
-
-impl From<crate::StmtPass> for AnyNode {
-    fn from(node: crate::StmtPass) -> AnyNode {
-        AnyNode::StmtPass(node)
-    }
-}
-
-impl From<crate::StmtBreak> for AnyNode {
-    fn from(node: crate::StmtBreak) -> AnyNode {
-        AnyNode::StmtBreak(node)
-    }
-}
-
-impl From<crate::StmtContinue> for AnyNode {
-    fn from(node: crate::StmtContinue) -> AnyNode {
-        AnyNode::StmtContinue(node)
-    }
-}
-
-impl From<crate::StmtIpyEscapeCommand> for AnyNode {
-    fn from(node: crate::StmtIpyEscapeCommand) -> AnyNode {
-        AnyNode::StmtIpyEscapeCommand(node)
-    }
-}
-
-impl From<Expr> for AnyNode {
-    fn from(node: Expr) -> AnyNode {
-        match node {
-            Expr::BoolOp(node) => AnyNode::ExprBoolOp(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::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::Generator(node) => AnyNode::ExprGenerator(node),
-            Expr::Await(node) => AnyNode::ExprAwait(node),
-            Expr::Yield(node) => AnyNode::ExprYield(node),
-            Expr::YieldFrom(node) => AnyNode::ExprYieldFrom(node),
-            Expr::Compare(node) => AnyNode::ExprCompare(node),
-            Expr::Call(node) => AnyNode::ExprCall(node),
-            Expr::FString(node) => AnyNode::ExprFString(node),
-            Expr::StringLiteral(node) => AnyNode::ExprStringLiteral(node),
-            Expr::BytesLiteral(node) => AnyNode::ExprBytesLiteral(node),
-            Expr::NumberLiteral(node) => AnyNode::ExprNumberLiteral(node),
-            Expr::BooleanLiteral(node) => AnyNode::ExprBooleanLiteral(node),
-            Expr::NoneLiteral(node) => AnyNode::ExprNoneLiteral(node),
-            Expr::EllipsisLiteral(node) => AnyNode::ExprEllipsisLiteral(node),
-            Expr::Attribute(node) => AnyNode::ExprAttribute(node),
-            Expr::Subscript(node) => AnyNode::ExprSubscript(node),
-            Expr::Starred(node) => AnyNode::ExprStarred(node),
-            Expr::Name(node) => AnyNode::ExprName(node),
-            Expr::List(node) => AnyNode::ExprList(node),
-            Expr::Tuple(node) => AnyNode::ExprTuple(node),
-            Expr::Slice(node) => AnyNode::ExprSlice(node),
-            Expr::IpyEscapeCommand(node) => AnyNode::ExprIpyEscapeCommand(node),
-        }
-    }
-}
-
-impl From<crate::ExprBoolOp> for AnyNode {
-    fn from(node: crate::ExprBoolOp) -> AnyNode {
-        AnyNode::ExprBoolOp(node)
-    }
-}
-
-impl From<crate::ExprNamed> for AnyNode {
-    fn from(node: crate::ExprNamed) -> AnyNode {
-        AnyNode::ExprNamed(node)
-    }
-}
-
-impl From<crate::ExprBinOp> for AnyNode {
-    fn from(node: crate::ExprBinOp) -> AnyNode {
-        AnyNode::ExprBinOp(node)
-    }
-}
-
-impl From<crate::ExprUnaryOp> for AnyNode {
-    fn from(node: crate::ExprUnaryOp) -> AnyNode {
-        AnyNode::ExprUnaryOp(node)
-    }
-}
-
-impl From<crate::ExprLambda> for AnyNode {
-    fn from(node: crate::ExprLambda) -> AnyNode {
-        AnyNode::ExprLambda(node)
-    }
-}
-
-impl From<crate::ExprIf> for AnyNode {
-    fn from(node: crate::ExprIf) -> AnyNode {
-        AnyNode::ExprIf(node)
-    }
-}
-
-impl From<crate::ExprDict> for AnyNode {
-    fn from(node: crate::ExprDict) -> AnyNode {
-        AnyNode::ExprDict(node)
-    }
-}
-
-impl From<crate::ExprSet> for AnyNode {
-    fn from(node: crate::ExprSet) -> AnyNode {
-        AnyNode::ExprSet(node)
-    }
-}
-
-impl From<crate::ExprListComp> for AnyNode {
-    fn from(node: crate::ExprListComp) -> AnyNode {
-        AnyNode::ExprListComp(node)
-    }
-}
-
-impl From<crate::ExprSetComp> for AnyNode {
-    fn from(node: crate::ExprSetComp) -> AnyNode {
-        AnyNode::ExprSetComp(node)
-    }
-}
-
-impl From<crate::ExprDictComp> for AnyNode {
-    fn from(node: crate::ExprDictComp) -> AnyNode {
-        AnyNode::ExprDictComp(node)
-    }
-}
-
-impl From<crate::ExprGenerator> for AnyNode {
-    fn from(node: crate::ExprGenerator) -> AnyNode {
-        AnyNode::ExprGenerator(node)
-    }
-}
-
-impl From<crate::ExprAwait> for AnyNode {
-    fn from(node: crate::ExprAwait) -> AnyNode {
-        AnyNode::ExprAwait(node)
-    }
-}
-
-impl From<crate::ExprYield> for AnyNode {
-    fn from(node: crate::ExprYield) -> AnyNode {
-        AnyNode::ExprYield(node)
-    }
-}
-
-impl From<crate::ExprYieldFrom> for AnyNode {
-    fn from(node: crate::ExprYieldFrom) -> AnyNode {
-        AnyNode::ExprYieldFrom(node)
-    }
-}
-
-impl From<crate::ExprCompare> for AnyNode {
-    fn from(node: crate::ExprCompare) -> AnyNode {
-        AnyNode::ExprCompare(node)
-    }
-}
-
-impl From<crate::ExprCall> for AnyNode {
-    fn from(node: crate::ExprCall) -> AnyNode {
-        AnyNode::ExprCall(node)
-    }
-}
-
-impl From<crate::ExprFString> for AnyNode {
-    fn from(node: crate::ExprFString) -> AnyNode {
-        AnyNode::ExprFString(node)
-    }
-}
-
-impl From<crate::ExprStringLiteral> for AnyNode {
-    fn from(node: crate::ExprStringLiteral) -> AnyNode {
-        AnyNode::ExprStringLiteral(node)
-    }
-}
-
-impl From<crate::ExprBytesLiteral> for AnyNode {
-    fn from(node: crate::ExprBytesLiteral) -> AnyNode {
-        AnyNode::ExprBytesLiteral(node)
-    }
-}
-
-impl From<crate::ExprNumberLiteral> for AnyNode {
-    fn from(node: crate::ExprNumberLiteral) -> AnyNode {
-        AnyNode::ExprNumberLiteral(node)
-    }
-}
-
-impl From<crate::ExprBooleanLiteral> for AnyNode {
-    fn from(node: crate::ExprBooleanLiteral) -> AnyNode {
-        AnyNode::ExprBooleanLiteral(node)
-    }
-}
-
-impl From<crate::ExprNoneLiteral> for AnyNode {
-    fn from(node: crate::ExprNoneLiteral) -> AnyNode {
-        AnyNode::ExprNoneLiteral(node)
-    }
-}
-
-impl From<crate::ExprEllipsisLiteral> for AnyNode {
-    fn from(node: crate::ExprEllipsisLiteral) -> AnyNode {
-        AnyNode::ExprEllipsisLiteral(node)
-    }
-}
-
-impl From<crate::ExprAttribute> for AnyNode {
-    fn from(node: crate::ExprAttribute) -> AnyNode {
-        AnyNode::ExprAttribute(node)
-    }
-}
-
-impl From<crate::ExprSubscript> for AnyNode {
-    fn from(node: crate::ExprSubscript) -> AnyNode {
-        AnyNode::ExprSubscript(node)
-    }
-}
-
-impl From<crate::ExprStarred> for AnyNode {
-    fn from(node: crate::ExprStarred) -> AnyNode {
-        AnyNode::ExprStarred(node)
-    }
-}
-
-impl From<crate::ExprName> for AnyNode {
-    fn from(node: crate::ExprName) -> AnyNode {
-        AnyNode::ExprName(node)
-    }
-}
-
-impl From<crate::ExprList> for AnyNode {
-    fn from(node: crate::ExprList) -> AnyNode {
-        AnyNode::ExprList(node)
-    }
-}
-
-impl From<crate::ExprTuple> for AnyNode {
-    fn from(node: crate::ExprTuple) -> AnyNode {
-        AnyNode::ExprTuple(node)
-    }
-}
-
-impl From<crate::ExprSlice> for AnyNode {
-    fn from(node: crate::ExprSlice) -> AnyNode {
-        AnyNode::ExprSlice(node)
-    }
-}
-
-impl From<crate::ExprIpyEscapeCommand> for AnyNode {
-    fn from(node: crate::ExprIpyEscapeCommand) -> AnyNode {
-        AnyNode::ExprIpyEscapeCommand(node)
-    }
-}
-
-impl From<ExceptHandler> for AnyNode {
-    fn from(node: ExceptHandler) -> AnyNode {
-        match node {
-            ExceptHandler::ExceptHandler(node) => AnyNode::ExceptHandlerExceptHandler(node),
-        }
-    }
-}
-
-impl From<crate::ExceptHandlerExceptHandler> for AnyNode {
-    fn from(node: crate::ExceptHandlerExceptHandler) -> AnyNode {
-        AnyNode::ExceptHandlerExceptHandler(node)
-    }
-}
-
-impl From<FStringElement> for AnyNode {
-    fn from(node: FStringElement) -> AnyNode {
-        match node {
-            FStringElement::Expression(node) => AnyNode::FStringExpressionElement(node),
-            FStringElement::Literal(node) => AnyNode::FStringLiteralElement(node),
-        }
-    }
-}
-
-impl From<crate::FStringExpressionElement> for AnyNode {
-    fn from(node: crate::FStringExpressionElement) -> AnyNode {
-        AnyNode::FStringExpressionElement(node)
-    }
-}
-
-impl From<crate::FStringLiteralElement> for AnyNode {
-    fn from(node: crate::FStringLiteralElement) -> AnyNode {
-        AnyNode::FStringLiteralElement(node)
-    }
-}
-
-impl From<Pattern> for AnyNode {
-    fn from(node: Pattern) -> AnyNode {
-        match node {
-            Pattern::MatchValue(node) => AnyNode::PatternMatchValue(node),
-            Pattern::MatchSingleton(node) => AnyNode::PatternMatchSingleton(node),
-            Pattern::MatchSequence(node) => AnyNode::PatternMatchSequence(node),
-            Pattern::MatchMapping(node) => AnyNode::PatternMatchMapping(node),
-            Pattern::MatchClass(node) => AnyNode::PatternMatchClass(node),
-            Pattern::MatchStar(node) => AnyNode::PatternMatchStar(node),
-            Pattern::MatchAs(node) => AnyNode::PatternMatchAs(node),
-            Pattern::MatchOr(node) => AnyNode::PatternMatchOr(node),
-        }
-    }
-}
-
-impl From<crate::PatternMatchValue> for AnyNode {
-    fn from(node: crate::PatternMatchValue) -> AnyNode {
-        AnyNode::PatternMatchValue(node)
-    }
-}
-
-impl From<crate::PatternMatchSingleton> for AnyNode {
-    fn from(node: crate::PatternMatchSingleton) -> AnyNode {
-        AnyNode::PatternMatchSingleton(node)
-    }
-}
-
-impl From<crate::PatternMatchSequence> for AnyNode {
-    fn from(node: crate::PatternMatchSequence) -> AnyNode {
-        AnyNode::PatternMatchSequence(node)
-    }
-}
-
-impl From<crate::PatternMatchMapping> for AnyNode {
-    fn from(node: crate::PatternMatchMapping) -> AnyNode {
-        AnyNode::PatternMatchMapping(node)
-    }
-}
-
-impl From<crate::PatternMatchClass> for AnyNode {
-    fn from(node: crate::PatternMatchClass) -> AnyNode {
-        AnyNode::PatternMatchClass(node)
-    }
-}
-
-impl From<crate::PatternMatchStar> for AnyNode {
-    fn from(node: crate::PatternMatchStar) -> AnyNode {
-        AnyNode::PatternMatchStar(node)
-    }
-}
-
-impl From<crate::PatternMatchAs> for AnyNode {
-    fn from(node: crate::PatternMatchAs) -> AnyNode {
-        AnyNode::PatternMatchAs(node)
-    }
-}
-
-impl From<crate::PatternMatchOr> for AnyNode {
-    fn from(node: crate::PatternMatchOr) -> AnyNode {
-        AnyNode::PatternMatchOr(node)
-    }
-}
-
-impl From<TypeParam> for AnyNode {
-    fn from(node: TypeParam) -> AnyNode {
-        match node {
-            TypeParam::TypeVar(node) => AnyNode::TypeParamTypeVar(node),
-            TypeParam::TypeVarTuple(node) => AnyNode::TypeParamTypeVarTuple(node),
-            TypeParam::ParamSpec(node) => AnyNode::TypeParamParamSpec(node),
-        }
-    }
-}
-
-impl From<crate::TypeParamTypeVar> for AnyNode {
-    fn from(node: crate::TypeParamTypeVar) -> AnyNode {
-        AnyNode::TypeParamTypeVar(node)
-    }
-}
-
-impl From<crate::TypeParamTypeVarTuple> for AnyNode {
-    fn from(node: crate::TypeParamTypeVarTuple) -> AnyNode {
-        AnyNode::TypeParamTypeVarTuple(node)
-    }
-}
-
-impl From<crate::TypeParamParamSpec> for AnyNode {
-    fn from(node: crate::TypeParamParamSpec) -> AnyNode {
-        AnyNode::TypeParamParamSpec(node)
-    }
-}
-
-impl From<crate::FStringFormatSpec> for AnyNode {
-    fn from(node: crate::FStringFormatSpec) -> AnyNode {
-        AnyNode::FStringFormatSpec(node)
-    }
-}
-
-impl From<crate::PatternArguments> for AnyNode {
-    fn from(node: crate::PatternArguments) -> AnyNode {
-        AnyNode::PatternArguments(node)
-    }
-}
-
-impl From<crate::PatternKeyword> for AnyNode {
-    fn from(node: crate::PatternKeyword) -> AnyNode {
-        AnyNode::PatternKeyword(node)
-    }
-}
-
-impl From<crate::Comprehension> for AnyNode {
-    fn from(node: crate::Comprehension) -> AnyNode {
-        AnyNode::Comprehension(node)
-    }
-}
-
-impl From<crate::Arguments> for AnyNode {
-    fn from(node: crate::Arguments) -> AnyNode {
-        AnyNode::Arguments(node)
-    }
-}
-
-impl From<crate::Parameters> for AnyNode {
-    fn from(node: crate::Parameters) -> AnyNode {
-        AnyNode::Parameters(node)
-    }
-}
-
-impl From<crate::Parameter> for AnyNode {
-    fn from(node: crate::Parameter) -> AnyNode {
-        AnyNode::Parameter(node)
-    }
-}
-
-impl From<crate::ParameterWithDefault> for AnyNode {
-    fn from(node: crate::ParameterWithDefault) -> AnyNode {
-        AnyNode::ParameterWithDefault(node)
-    }
-}
-
-impl From<crate::Keyword> for AnyNode {
-    fn from(node: crate::Keyword) -> AnyNode {
-        AnyNode::Keyword(node)
-    }
-}
-
-impl From<crate::Alias> for AnyNode {
-    fn from(node: crate::Alias) -> AnyNode {
-        AnyNode::Alias(node)
-    }
-}
-
-impl From<crate::WithItem> for AnyNode {
-    fn from(node: crate::WithItem) -> AnyNode {
-        AnyNode::WithItem(node)
-    }
-}
-
-impl From<crate::MatchCase> for AnyNode {
-    fn from(node: crate::MatchCase) -> AnyNode {
-        AnyNode::MatchCase(node)
-    }
-}
-
-impl From<crate::Decorator> for AnyNode {
-    fn from(node: crate::Decorator) -> AnyNode {
-        AnyNode::Decorator(node)
-    }
-}
-
-impl From<crate::ElifElseClause> for AnyNode {
-    fn from(node: crate::ElifElseClause) -> AnyNode {
-        AnyNode::ElifElseClause(node)
-    }
-}
-
-impl From<crate::TypeParams> for AnyNode {
-    fn from(node: crate::TypeParams) -> AnyNode {
-        AnyNode::TypeParams(node)
-    }
-}
-
-impl From<crate::FString> for AnyNode {
-    fn from(node: crate::FString) -> AnyNode {
-        AnyNode::FString(node)
-    }
-}
-
-impl From<crate::StringLiteral> for AnyNode {
-    fn from(node: crate::StringLiteral) -> AnyNode {
-        AnyNode::StringLiteral(node)
-    }
-}
-
-impl From<crate::BytesLiteral> for AnyNode {
-    fn from(node: crate::BytesLiteral) -> AnyNode {
-        AnyNode::BytesLiteral(node)
-    }
-}
-
-impl From<crate::Identifier> for AnyNode {
-    fn from(node: crate::Identifier) -> AnyNode {
-        AnyNode::Identifier(node)
-    }
-}
-
-impl ruff_text_size::Ranged for AnyNode {
-    fn range(&self) -> ruff_text_size::TextRange {
-        match self {
-            AnyNode::ModModule(node) => node.range(),
-            AnyNode::ModExpression(node) => node.range(),
-            AnyNode::StmtFunctionDef(node) => node.range(),
-            AnyNode::StmtClassDef(node) => node.range(),
-            AnyNode::StmtReturn(node) => node.range(),
-            AnyNode::StmtDelete(node) => node.range(),
-            AnyNode::StmtTypeAlias(node) => node.range(),
-            AnyNode::StmtAssign(node) => node.range(),
-            AnyNode::StmtAugAssign(node) => node.range(),
-            AnyNode::StmtAnnAssign(node) => node.range(),
-            AnyNode::StmtFor(node) => node.range(),
-            AnyNode::StmtWhile(node) => node.range(),
-            AnyNode::StmtIf(node) => node.range(),
-            AnyNode::StmtWith(node) => node.range(),
-            AnyNode::StmtMatch(node) => node.range(),
-            AnyNode::StmtRaise(node) => node.range(),
-            AnyNode::StmtTry(node) => node.range(),
-            AnyNode::StmtAssert(node) => node.range(),
-            AnyNode::StmtImport(node) => node.range(),
-            AnyNode::StmtImportFrom(node) => node.range(),
-            AnyNode::StmtGlobal(node) => node.range(),
-            AnyNode::StmtNonlocal(node) => node.range(),
-            AnyNode::StmtExpr(node) => node.range(),
-            AnyNode::StmtPass(node) => node.range(),
-            AnyNode::StmtBreak(node) => node.range(),
-            AnyNode::StmtContinue(node) => node.range(),
-            AnyNode::StmtIpyEscapeCommand(node) => node.range(),
-            AnyNode::ExprBoolOp(node) => node.range(),
-            AnyNode::ExprNamed(node) => node.range(),
-            AnyNode::ExprBinOp(node) => node.range(),
-            AnyNode::ExprUnaryOp(node) => node.range(),
-            AnyNode::ExprLambda(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::ExprGenerator(node) => node.range(),
-            AnyNode::ExprAwait(node) => node.range(),
-            AnyNode::ExprYield(node) => node.range(),
-            AnyNode::ExprYieldFrom(node) => node.range(),
-            AnyNode::ExprCompare(node) => node.range(),
-            AnyNode::ExprCall(node) => node.range(),
-            AnyNode::ExprFString(node) => node.range(),
-            AnyNode::ExprStringLiteral(node) => node.range(),
-            AnyNode::ExprBytesLiteral(node) => node.range(),
-            AnyNode::ExprNumberLiteral(node) => node.range(),
-            AnyNode::ExprBooleanLiteral(node) => node.range(),
-            AnyNode::ExprNoneLiteral(node) => node.range(),
-            AnyNode::ExprEllipsisLiteral(node) => node.range(),
-            AnyNode::ExprAttribute(node) => node.range(),
-            AnyNode::ExprSubscript(node) => node.range(),
-            AnyNode::ExprStarred(node) => node.range(),
-            AnyNode::ExprName(node) => node.range(),
-            AnyNode::ExprList(node) => node.range(),
-            AnyNode::ExprTuple(node) => node.range(),
-            AnyNode::ExprSlice(node) => node.range(),
-            AnyNode::ExprIpyEscapeCommand(node) => node.range(),
-            AnyNode::ExceptHandlerExceptHandler(node) => node.range(),
-            AnyNode::FStringExpressionElement(node) => node.range(),
-            AnyNode::FStringLiteralElement(node) => node.range(),
-            AnyNode::PatternMatchValue(node) => node.range(),
-            AnyNode::PatternMatchSingleton(node) => node.range(),
-            AnyNode::PatternMatchSequence(node) => node.range(),
-            AnyNode::PatternMatchMapping(node) => node.range(),
-            AnyNode::PatternMatchClass(node) => node.range(),
-            AnyNode::PatternMatchStar(node) => node.range(),
-            AnyNode::PatternMatchAs(node) => node.range(),
-            AnyNode::PatternMatchOr(node) => node.range(),
-            AnyNode::TypeParamTypeVar(node) => node.range(),
-            AnyNode::TypeParamTypeVarTuple(node) => node.range(),
-            AnyNode::TypeParamParamSpec(node) => node.range(),
-            AnyNode::FStringFormatSpec(node) => node.range(),
-            AnyNode::PatternArguments(node) => node.range(),
-            AnyNode::PatternKeyword(node) => node.range(),
-            AnyNode::Comprehension(node) => node.range(),
-            AnyNode::Arguments(node) => node.range(),
-            AnyNode::Parameters(node) => node.range(),
-            AnyNode::Parameter(node) => node.range(),
-            AnyNode::ParameterWithDefault(node) => node.range(),
-            AnyNode::Keyword(node) => node.range(),
-            AnyNode::Alias(node) => node.range(),
-            AnyNode::WithItem(node) => node.range(),
-            AnyNode::MatchCase(node) => node.range(),
-            AnyNode::Decorator(node) => node.range(),
-            AnyNode::ElifElseClause(node) => node.range(),
-            AnyNode::TypeParams(node) => node.range(),
-            AnyNode::FString(node) => node.range(),
-            AnyNode::StringLiteral(node) => node.range(),
-            AnyNode::BytesLiteral(node) => node.range(),
-            AnyNode::Identifier(node) => node.range(),
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn module(self) -> Option<Mod> {
-        match self {
-            AnyNode::ModModule(node) => Some(Mod::Module(node)),
-            AnyNode::ModExpression(node) => Some(Mod::Expression(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn statement(self) -> Option<Stmt> {
-        match self {
-            AnyNode::StmtFunctionDef(node) => Some(Stmt::FunctionDef(node)),
-            AnyNode::StmtClassDef(node) => Some(Stmt::ClassDef(node)),
-            AnyNode::StmtReturn(node) => Some(Stmt::Return(node)),
-            AnyNode::StmtDelete(node) => Some(Stmt::Delete(node)),
-            AnyNode::StmtTypeAlias(node) => Some(Stmt::TypeAlias(node)),
-            AnyNode::StmtAssign(node) => Some(Stmt::Assign(node)),
-            AnyNode::StmtAugAssign(node) => Some(Stmt::AugAssign(node)),
-            AnyNode::StmtAnnAssign(node) => Some(Stmt::AnnAssign(node)),
-            AnyNode::StmtFor(node) => Some(Stmt::For(node)),
-            AnyNode::StmtWhile(node) => Some(Stmt::While(node)),
-            AnyNode::StmtIf(node) => Some(Stmt::If(node)),
-            AnyNode::StmtWith(node) => Some(Stmt::With(node)),
-            AnyNode::StmtMatch(node) => Some(Stmt::Match(node)),
-            AnyNode::StmtRaise(node) => Some(Stmt::Raise(node)),
-            AnyNode::StmtTry(node) => Some(Stmt::Try(node)),
-            AnyNode::StmtAssert(node) => Some(Stmt::Assert(node)),
-            AnyNode::StmtImport(node) => Some(Stmt::Import(node)),
-            AnyNode::StmtImportFrom(node) => Some(Stmt::ImportFrom(node)),
-            AnyNode::StmtGlobal(node) => Some(Stmt::Global(node)),
-            AnyNode::StmtNonlocal(node) => Some(Stmt::Nonlocal(node)),
-            AnyNode::StmtExpr(node) => Some(Stmt::Expr(node)),
-            AnyNode::StmtPass(node) => Some(Stmt::Pass(node)),
-            AnyNode::StmtBreak(node) => Some(Stmt::Break(node)),
-            AnyNode::StmtContinue(node) => Some(Stmt::Continue(node)),
-            AnyNode::StmtIpyEscapeCommand(node) => Some(Stmt::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn expression(self) -> Option<Expr> {
-        match self {
-            AnyNode::ExprBoolOp(node) => Some(Expr::BoolOp(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::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::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)),
-            AnyNode::ExprCompare(node) => Some(Expr::Compare(node)),
-            AnyNode::ExprCall(node) => Some(Expr::Call(node)),
-            AnyNode::ExprFString(node) => Some(Expr::FString(node)),
-            AnyNode::ExprStringLiteral(node) => Some(Expr::StringLiteral(node)),
-            AnyNode::ExprBytesLiteral(node) => Some(Expr::BytesLiteral(node)),
-            AnyNode::ExprNumberLiteral(node) => Some(Expr::NumberLiteral(node)),
-            AnyNode::ExprBooleanLiteral(node) => Some(Expr::BooleanLiteral(node)),
-            AnyNode::ExprNoneLiteral(node) => Some(Expr::NoneLiteral(node)),
-            AnyNode::ExprEllipsisLiteral(node) => Some(Expr::EllipsisLiteral(node)),
-            AnyNode::ExprAttribute(node) => Some(Expr::Attribute(node)),
-            AnyNode::ExprSubscript(node) => Some(Expr::Subscript(node)),
-            AnyNode::ExprStarred(node) => Some(Expr::Starred(node)),
-            AnyNode::ExprName(node) => Some(Expr::Name(node)),
-            AnyNode::ExprList(node) => Some(Expr::List(node)),
-            AnyNode::ExprTuple(node) => Some(Expr::Tuple(node)),
-            AnyNode::ExprSlice(node) => Some(Expr::Slice(node)),
-            AnyNode::ExprIpyEscapeCommand(node) => Some(Expr::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn except_handler(self) -> Option<ExceptHandler> {
-        match self {
-            AnyNode::ExceptHandlerExceptHandler(node) => Some(ExceptHandler::ExceptHandler(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn f_string_element(self) -> Option<FStringElement> {
-        match self {
-            AnyNode::FStringExpressionElement(node) => Some(FStringElement::Expression(node)),
-            AnyNode::FStringLiteralElement(node) => Some(FStringElement::Literal(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn pattern(self) -> Option<Pattern> {
-        match self {
-            AnyNode::PatternMatchValue(node) => Some(Pattern::MatchValue(node)),
-            AnyNode::PatternMatchSingleton(node) => Some(Pattern::MatchSingleton(node)),
-            AnyNode::PatternMatchSequence(node) => Some(Pattern::MatchSequence(node)),
-            AnyNode::PatternMatchMapping(node) => Some(Pattern::MatchMapping(node)),
-            AnyNode::PatternMatchClass(node) => Some(Pattern::MatchClass(node)),
-            AnyNode::PatternMatchStar(node) => Some(Pattern::MatchStar(node)),
-            AnyNode::PatternMatchAs(node) => Some(Pattern::MatchAs(node)),
-            AnyNode::PatternMatchOr(node) => Some(Pattern::MatchOr(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub fn type_param(self) -> Option<TypeParam> {
-        match self {
-            AnyNode::TypeParamTypeVar(node) => Some(TypeParam::TypeVar(node)),
-            AnyNode::TypeParamTypeVarTuple(node) => Some(TypeParam::TypeVarTuple(node)),
-            AnyNode::TypeParamParamSpec(node) => Some(TypeParam::ParamSpec(node)),
-
-            _ => None,
-        }
-    }
-}
-
-impl AnyNode {
-    pub const fn is_module(&self) -> bool {
-        matches!(self, AnyNode::ModModule(_) | AnyNode::ModExpression(_))
-    }
-}
-
-impl AnyNode {
-    pub const fn is_statement(&self) -> bool {
-        matches!(
-            self,
-            AnyNode::StmtFunctionDef(_)
-                | AnyNode::StmtClassDef(_)
-                | AnyNode::StmtReturn(_)
-                | AnyNode::StmtDelete(_)
-                | AnyNode::StmtTypeAlias(_)
-                | AnyNode::StmtAssign(_)
-                | AnyNode::StmtAugAssign(_)
-                | AnyNode::StmtAnnAssign(_)
-                | AnyNode::StmtFor(_)
-                | AnyNode::StmtWhile(_)
-                | AnyNode::StmtIf(_)
-                | AnyNode::StmtWith(_)
-                | AnyNode::StmtMatch(_)
-                | AnyNode::StmtRaise(_)
-                | AnyNode::StmtTry(_)
-                | AnyNode::StmtAssert(_)
-                | AnyNode::StmtImport(_)
-                | AnyNode::StmtImportFrom(_)
-                | AnyNode::StmtGlobal(_)
-                | AnyNode::StmtNonlocal(_)
-                | AnyNode::StmtExpr(_)
-                | AnyNode::StmtPass(_)
-                | AnyNode::StmtBreak(_)
-                | AnyNode::StmtContinue(_)
-                | AnyNode::StmtIpyEscapeCommand(_)
-        )
-    }
-}
-
-impl AnyNode {
-    pub const fn is_expression(&self) -> bool {
-        matches!(
-            self,
-            AnyNode::ExprBoolOp(_)
-                | AnyNode::ExprNamed(_)
-                | AnyNode::ExprBinOp(_)
-                | AnyNode::ExprUnaryOp(_)
-                | AnyNode::ExprLambda(_)
-                | AnyNode::ExprIf(_)
-                | AnyNode::ExprDict(_)
-                | AnyNode::ExprSet(_)
-                | AnyNode::ExprListComp(_)
-                | AnyNode::ExprSetComp(_)
-                | AnyNode::ExprDictComp(_)
-                | AnyNode::ExprGenerator(_)
-                | AnyNode::ExprAwait(_)
-                | AnyNode::ExprYield(_)
-                | AnyNode::ExprYieldFrom(_)
-                | AnyNode::ExprCompare(_)
-                | AnyNode::ExprCall(_)
-                | AnyNode::ExprFString(_)
-                | AnyNode::ExprStringLiteral(_)
-                | AnyNode::ExprBytesLiteral(_)
-                | AnyNode::ExprNumberLiteral(_)
-                | AnyNode::ExprBooleanLiteral(_)
-                | AnyNode::ExprNoneLiteral(_)
-                | AnyNode::ExprEllipsisLiteral(_)
-                | AnyNode::ExprAttribute(_)
-                | AnyNode::ExprSubscript(_)
-                | AnyNode::ExprStarred(_)
-                | AnyNode::ExprName(_)
-                | AnyNode::ExprList(_)
-                | AnyNode::ExprTuple(_)
-                | AnyNode::ExprSlice(_)
-                | AnyNode::ExprIpyEscapeCommand(_)
-        )
-    }
-}
-
-impl AnyNode {
-    pub const fn is_except_handler(&self) -> bool {
-        matches!(self, AnyNode::ExceptHandlerExceptHandler(_))
-    }
-}
-
-impl AnyNode {
-    pub const fn is_f_string_element(&self) -> bool {
-        matches!(
-            self,
-            AnyNode::FStringExpressionElement(_) | AnyNode::FStringLiteralElement(_)
-        )
-    }
-}
-
-impl AnyNode {
-    pub const fn is_pattern(&self) -> bool {
-        matches!(
-            self,
-            AnyNode::PatternMatchValue(_)
-                | AnyNode::PatternMatchSingleton(_)
-                | AnyNode::PatternMatchSequence(_)
-                | AnyNode::PatternMatchMapping(_)
-                | AnyNode::PatternMatchClass(_)
-                | AnyNode::PatternMatchStar(_)
-                | AnyNode::PatternMatchAs(_)
-                | AnyNode::PatternMatchOr(_)
-        )
-    }
-}
-
-impl AnyNode {
-    pub const fn is_type_param(&self) -> bool {
-        matches!(
-            self,
-            AnyNode::TypeParamTypeVar(_)
-                | AnyNode::TypeParamTypeVarTuple(_)
-                | AnyNode::TypeParamParamSpec(_)
-        )
-    }
-}
-
-impl AnyNode {
-    pub const fn as_ref(&self) -> AnyNodeRef {
-        match self {
-            AnyNode::ModModule(node) => AnyNodeRef::ModModule(node),
-            AnyNode::ModExpression(node) => AnyNodeRef::ModExpression(node),
-            AnyNode::StmtFunctionDef(node) => AnyNodeRef::StmtFunctionDef(node),
-            AnyNode::StmtClassDef(node) => AnyNodeRef::StmtClassDef(node),
-            AnyNode::StmtReturn(node) => AnyNodeRef::StmtReturn(node),
-            AnyNode::StmtDelete(node) => AnyNodeRef::StmtDelete(node),
-            AnyNode::StmtTypeAlias(node) => AnyNodeRef::StmtTypeAlias(node),
-            AnyNode::StmtAssign(node) => AnyNodeRef::StmtAssign(node),
-            AnyNode::StmtAugAssign(node) => AnyNodeRef::StmtAugAssign(node),
-            AnyNode::StmtAnnAssign(node) => AnyNodeRef::StmtAnnAssign(node),
-            AnyNode::StmtFor(node) => AnyNodeRef::StmtFor(node),
-            AnyNode::StmtWhile(node) => AnyNodeRef::StmtWhile(node),
-            AnyNode::StmtIf(node) => AnyNodeRef::StmtIf(node),
-            AnyNode::StmtWith(node) => AnyNodeRef::StmtWith(node),
-            AnyNode::StmtMatch(node) => AnyNodeRef::StmtMatch(node),
-            AnyNode::StmtRaise(node) => AnyNodeRef::StmtRaise(node),
-            AnyNode::StmtTry(node) => AnyNodeRef::StmtTry(node),
-            AnyNode::StmtAssert(node) => AnyNodeRef::StmtAssert(node),
-            AnyNode::StmtImport(node) => AnyNodeRef::StmtImport(node),
-            AnyNode::StmtImportFrom(node) => AnyNodeRef::StmtImportFrom(node),
-            AnyNode::StmtGlobal(node) => AnyNodeRef::StmtGlobal(node),
-            AnyNode::StmtNonlocal(node) => AnyNodeRef::StmtNonlocal(node),
-            AnyNode::StmtExpr(node) => AnyNodeRef::StmtExpr(node),
-            AnyNode::StmtPass(node) => AnyNodeRef::StmtPass(node),
-            AnyNode::StmtBreak(node) => AnyNodeRef::StmtBreak(node),
-            AnyNode::StmtContinue(node) => AnyNodeRef::StmtContinue(node),
-            AnyNode::StmtIpyEscapeCommand(node) => AnyNodeRef::StmtIpyEscapeCommand(node),
-            AnyNode::ExprBoolOp(node) => AnyNodeRef::ExprBoolOp(node),
-            AnyNode::ExprNamed(node) => AnyNodeRef::ExprNamed(node),
-            AnyNode::ExprBinOp(node) => AnyNodeRef::ExprBinOp(node),
-            AnyNode::ExprUnaryOp(node) => AnyNodeRef::ExprUnaryOp(node),
-            AnyNode::ExprLambda(node) => AnyNodeRef::ExprLambda(node),
-            AnyNode::ExprIf(node) => AnyNodeRef::ExprIf(node),
-            AnyNode::ExprDict(node) => AnyNodeRef::ExprDict(node),
-            AnyNode::ExprSet(node) => AnyNodeRef::ExprSet(node),
-            AnyNode::ExprListComp(node) => AnyNodeRef::ExprListComp(node),
-            AnyNode::ExprSetComp(node) => AnyNodeRef::ExprSetComp(node),
-            AnyNode::ExprDictComp(node) => AnyNodeRef::ExprDictComp(node),
-            AnyNode::ExprGenerator(node) => AnyNodeRef::ExprGenerator(node),
-            AnyNode::ExprAwait(node) => AnyNodeRef::ExprAwait(node),
-            AnyNode::ExprYield(node) => AnyNodeRef::ExprYield(node),
-            AnyNode::ExprYieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
-            AnyNode::ExprCompare(node) => AnyNodeRef::ExprCompare(node),
-            AnyNode::ExprCall(node) => AnyNodeRef::ExprCall(node),
-            AnyNode::ExprFString(node) => AnyNodeRef::ExprFString(node),
-            AnyNode::ExprStringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
-            AnyNode::ExprBytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
-            AnyNode::ExprNumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
-            AnyNode::ExprBooleanLiteral(node) => AnyNodeRef::ExprBooleanLiteral(node),
-            AnyNode::ExprNoneLiteral(node) => AnyNodeRef::ExprNoneLiteral(node),
-            AnyNode::ExprEllipsisLiteral(node) => AnyNodeRef::ExprEllipsisLiteral(node),
-            AnyNode::ExprAttribute(node) => AnyNodeRef::ExprAttribute(node),
-            AnyNode::ExprSubscript(node) => AnyNodeRef::ExprSubscript(node),
-            AnyNode::ExprStarred(node) => AnyNodeRef::ExprStarred(node),
-            AnyNode::ExprName(node) => AnyNodeRef::ExprName(node),
-            AnyNode::ExprList(node) => AnyNodeRef::ExprList(node),
-            AnyNode::ExprTuple(node) => AnyNodeRef::ExprTuple(node),
-            AnyNode::ExprSlice(node) => AnyNodeRef::ExprSlice(node),
-            AnyNode::ExprIpyEscapeCommand(node) => AnyNodeRef::ExprIpyEscapeCommand(node),
-            AnyNode::ExceptHandlerExceptHandler(node) => {
-                AnyNodeRef::ExceptHandlerExceptHandler(node)
-            }
-            AnyNode::FStringExpressionElement(node) => AnyNodeRef::FStringExpressionElement(node),
-            AnyNode::FStringLiteralElement(node) => AnyNodeRef::FStringLiteralElement(node),
-            AnyNode::PatternMatchValue(node) => AnyNodeRef::PatternMatchValue(node),
-            AnyNode::PatternMatchSingleton(node) => AnyNodeRef::PatternMatchSingleton(node),
-            AnyNode::PatternMatchSequence(node) => AnyNodeRef::PatternMatchSequence(node),
-            AnyNode::PatternMatchMapping(node) => AnyNodeRef::PatternMatchMapping(node),
-            AnyNode::PatternMatchClass(node) => AnyNodeRef::PatternMatchClass(node),
-            AnyNode::PatternMatchStar(node) => AnyNodeRef::PatternMatchStar(node),
-            AnyNode::PatternMatchAs(node) => AnyNodeRef::PatternMatchAs(node),
-            AnyNode::PatternMatchOr(node) => AnyNodeRef::PatternMatchOr(node),
-            AnyNode::TypeParamTypeVar(node) => AnyNodeRef::TypeParamTypeVar(node),
-            AnyNode::TypeParamTypeVarTuple(node) => AnyNodeRef::TypeParamTypeVarTuple(node),
-            AnyNode::TypeParamParamSpec(node) => AnyNodeRef::TypeParamParamSpec(node),
-            AnyNode::FStringFormatSpec(node) => AnyNodeRef::FStringFormatSpec(node),
-            AnyNode::PatternArguments(node) => AnyNodeRef::PatternArguments(node),
-            AnyNode::PatternKeyword(node) => AnyNodeRef::PatternKeyword(node),
-            AnyNode::Comprehension(node) => AnyNodeRef::Comprehension(node),
-            AnyNode::Arguments(node) => AnyNodeRef::Arguments(node),
-            AnyNode::Parameters(node) => AnyNodeRef::Parameters(node),
-            AnyNode::Parameter(node) => AnyNodeRef::Parameter(node),
-            AnyNode::ParameterWithDefault(node) => AnyNodeRef::ParameterWithDefault(node),
-            AnyNode::Keyword(node) => AnyNodeRef::Keyword(node),
-            AnyNode::Alias(node) => AnyNodeRef::Alias(node),
-            AnyNode::WithItem(node) => AnyNodeRef::WithItem(node),
-            AnyNode::MatchCase(node) => AnyNodeRef::MatchCase(node),
-            AnyNode::Decorator(node) => AnyNodeRef::Decorator(node),
-            AnyNode::ElifElseClause(node) => AnyNodeRef::ElifElseClause(node),
-            AnyNode::TypeParams(node) => AnyNodeRef::TypeParams(node),
-            AnyNode::FString(node) => AnyNodeRef::FString(node),
-            AnyNode::StringLiteral(node) => AnyNodeRef::StringLiteral(node),
-            AnyNode::BytesLiteral(node) => AnyNodeRef::BytesLiteral(node),
-            AnyNode::Identifier(node) => AnyNodeRef::Identifier(node),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, is_macro::Is, PartialEq)]
 pub enum AnyNodeRef<'a> {
     ModModule(&'a crate::ModModule),
@@ -4913,105 +3686,6 @@ pub enum NodeKind {
     Identifier,
 }
 
-impl AnyNode {
-    pub const fn kind(&self) -> NodeKind {
-        match self {
-            AnyNode::ModModule(_) => NodeKind::ModModule,
-            AnyNode::ModExpression(_) => NodeKind::ModExpression,
-            AnyNode::StmtFunctionDef(_) => NodeKind::StmtFunctionDef,
-            AnyNode::StmtClassDef(_) => NodeKind::StmtClassDef,
-            AnyNode::StmtReturn(_) => NodeKind::StmtReturn,
-            AnyNode::StmtDelete(_) => NodeKind::StmtDelete,
-            AnyNode::StmtTypeAlias(_) => NodeKind::StmtTypeAlias,
-            AnyNode::StmtAssign(_) => NodeKind::StmtAssign,
-            AnyNode::StmtAugAssign(_) => NodeKind::StmtAugAssign,
-            AnyNode::StmtAnnAssign(_) => NodeKind::StmtAnnAssign,
-            AnyNode::StmtFor(_) => NodeKind::StmtFor,
-            AnyNode::StmtWhile(_) => NodeKind::StmtWhile,
-            AnyNode::StmtIf(_) => NodeKind::StmtIf,
-            AnyNode::StmtWith(_) => NodeKind::StmtWith,
-            AnyNode::StmtMatch(_) => NodeKind::StmtMatch,
-            AnyNode::StmtRaise(_) => NodeKind::StmtRaise,
-            AnyNode::StmtTry(_) => NodeKind::StmtTry,
-            AnyNode::StmtAssert(_) => NodeKind::StmtAssert,
-            AnyNode::StmtImport(_) => NodeKind::StmtImport,
-            AnyNode::StmtImportFrom(_) => NodeKind::StmtImportFrom,
-            AnyNode::StmtGlobal(_) => NodeKind::StmtGlobal,
-            AnyNode::StmtNonlocal(_) => NodeKind::StmtNonlocal,
-            AnyNode::StmtExpr(_) => NodeKind::StmtExpr,
-            AnyNode::StmtPass(_) => NodeKind::StmtPass,
-            AnyNode::StmtBreak(_) => NodeKind::StmtBreak,
-            AnyNode::StmtContinue(_) => NodeKind::StmtContinue,
-            AnyNode::StmtIpyEscapeCommand(_) => NodeKind::StmtIpyEscapeCommand,
-            AnyNode::ExprBoolOp(_) => NodeKind::ExprBoolOp,
-            AnyNode::ExprNamed(_) => NodeKind::ExprNamed,
-            AnyNode::ExprBinOp(_) => NodeKind::ExprBinOp,
-            AnyNode::ExprUnaryOp(_) => NodeKind::ExprUnaryOp,
-            AnyNode::ExprLambda(_) => NodeKind::ExprLambda,
-            AnyNode::ExprIf(_) => NodeKind::ExprIf,
-            AnyNode::ExprDict(_) => NodeKind::ExprDict,
-            AnyNode::ExprSet(_) => NodeKind::ExprSet,
-            AnyNode::ExprListComp(_) => NodeKind::ExprListComp,
-            AnyNode::ExprSetComp(_) => NodeKind::ExprSetComp,
-            AnyNode::ExprDictComp(_) => NodeKind::ExprDictComp,
-            AnyNode::ExprGenerator(_) => NodeKind::ExprGenerator,
-            AnyNode::ExprAwait(_) => NodeKind::ExprAwait,
-            AnyNode::ExprYield(_) => NodeKind::ExprYield,
-            AnyNode::ExprYieldFrom(_) => NodeKind::ExprYieldFrom,
-            AnyNode::ExprCompare(_) => NodeKind::ExprCompare,
-            AnyNode::ExprCall(_) => NodeKind::ExprCall,
-            AnyNode::ExprFString(_) => NodeKind::ExprFString,
-            AnyNode::ExprStringLiteral(_) => NodeKind::ExprStringLiteral,
-            AnyNode::ExprBytesLiteral(_) => NodeKind::ExprBytesLiteral,
-            AnyNode::ExprNumberLiteral(_) => NodeKind::ExprNumberLiteral,
-            AnyNode::ExprBooleanLiteral(_) => NodeKind::ExprBooleanLiteral,
-            AnyNode::ExprNoneLiteral(_) => NodeKind::ExprNoneLiteral,
-            AnyNode::ExprEllipsisLiteral(_) => NodeKind::ExprEllipsisLiteral,
-            AnyNode::ExprAttribute(_) => NodeKind::ExprAttribute,
-            AnyNode::ExprSubscript(_) => NodeKind::ExprSubscript,
-            AnyNode::ExprStarred(_) => NodeKind::ExprStarred,
-            AnyNode::ExprName(_) => NodeKind::ExprName,
-            AnyNode::ExprList(_) => NodeKind::ExprList,
-            AnyNode::ExprTuple(_) => NodeKind::ExprTuple,
-            AnyNode::ExprSlice(_) => NodeKind::ExprSlice,
-            AnyNode::ExprIpyEscapeCommand(_) => NodeKind::ExprIpyEscapeCommand,
-            AnyNode::ExceptHandlerExceptHandler(_) => NodeKind::ExceptHandlerExceptHandler,
-            AnyNode::FStringExpressionElement(_) => NodeKind::FStringExpressionElement,
-            AnyNode::FStringLiteralElement(_) => NodeKind::FStringLiteralElement,
-            AnyNode::PatternMatchValue(_) => NodeKind::PatternMatchValue,
-            AnyNode::PatternMatchSingleton(_) => NodeKind::PatternMatchSingleton,
-            AnyNode::PatternMatchSequence(_) => NodeKind::PatternMatchSequence,
-            AnyNode::PatternMatchMapping(_) => NodeKind::PatternMatchMapping,
-            AnyNode::PatternMatchClass(_) => NodeKind::PatternMatchClass,
-            AnyNode::PatternMatchStar(_) => NodeKind::PatternMatchStar,
-            AnyNode::PatternMatchAs(_) => NodeKind::PatternMatchAs,
-            AnyNode::PatternMatchOr(_) => NodeKind::PatternMatchOr,
-            AnyNode::TypeParamTypeVar(_) => NodeKind::TypeParamTypeVar,
-            AnyNode::TypeParamTypeVarTuple(_) => NodeKind::TypeParamTypeVarTuple,
-            AnyNode::TypeParamParamSpec(_) => NodeKind::TypeParamParamSpec,
-            AnyNode::FStringFormatSpec(_) => NodeKind::FStringFormatSpec,
-            AnyNode::PatternArguments(_) => NodeKind::PatternArguments,
-            AnyNode::PatternKeyword(_) => NodeKind::PatternKeyword,
-            AnyNode::Comprehension(_) => NodeKind::Comprehension,
-            AnyNode::Arguments(_) => NodeKind::Arguments,
-            AnyNode::Parameters(_) => NodeKind::Parameters,
-            AnyNode::Parameter(_) => NodeKind::Parameter,
-            AnyNode::ParameterWithDefault(_) => NodeKind::ParameterWithDefault,
-            AnyNode::Keyword(_) => NodeKind::Keyword,
-            AnyNode::Alias(_) => NodeKind::Alias,
-            AnyNode::WithItem(_) => NodeKind::WithItem,
-            AnyNode::MatchCase(_) => NodeKind::MatchCase,
-            AnyNode::Decorator(_) => NodeKind::Decorator,
-            AnyNode::ElifElseClause(_) => NodeKind::ElifElseClause,
-            AnyNode::TypeParams(_) => NodeKind::TypeParams,
-            AnyNode::FString(_) => NodeKind::FString,
-            AnyNode::StringLiteral(_) => NodeKind::StringLiteral,
-            AnyNode::BytesLiteral(_) => NodeKind::BytesLiteral,
-            AnyNode::Identifier(_) => NodeKind::Identifier,
-        }
-    }
-}
-
 impl AnyNodeRef<'_> {
     pub const fn kind(self) -> NodeKind {
         match self {
@@ -5110,3681 +3784,3 @@ impl AnyNodeRef<'_> {
         }
     }
 }
-
-impl crate::AstNode for Mod {
-    type Ref<'a> = ModRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::ModModule(node) => Some(Mod::Module(node)),
-            AnyNode::ModExpression(node) => Some(Mod::Expression(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::ModModule(node) => Some(ModRef::Module(node)),
-            AnyNodeRef::ModExpression(node) => Some(ModRef::Expression(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ModModule | NodeKind::ModExpression)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ModModule {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ModModule(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ModModule(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ModModule)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ModExpression {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ModExpression(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ModExpression(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ModExpression)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for Stmt {
-    type Ref<'a> = StatementRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::StmtFunctionDef(node) => Some(Stmt::FunctionDef(node)),
-            AnyNode::StmtClassDef(node) => Some(Stmt::ClassDef(node)),
-            AnyNode::StmtReturn(node) => Some(Stmt::Return(node)),
-            AnyNode::StmtDelete(node) => Some(Stmt::Delete(node)),
-            AnyNode::StmtTypeAlias(node) => Some(Stmt::TypeAlias(node)),
-            AnyNode::StmtAssign(node) => Some(Stmt::Assign(node)),
-            AnyNode::StmtAugAssign(node) => Some(Stmt::AugAssign(node)),
-            AnyNode::StmtAnnAssign(node) => Some(Stmt::AnnAssign(node)),
-            AnyNode::StmtFor(node) => Some(Stmt::For(node)),
-            AnyNode::StmtWhile(node) => Some(Stmt::While(node)),
-            AnyNode::StmtIf(node) => Some(Stmt::If(node)),
-            AnyNode::StmtWith(node) => Some(Stmt::With(node)),
-            AnyNode::StmtMatch(node) => Some(Stmt::Match(node)),
-            AnyNode::StmtRaise(node) => Some(Stmt::Raise(node)),
-            AnyNode::StmtTry(node) => Some(Stmt::Try(node)),
-            AnyNode::StmtAssert(node) => Some(Stmt::Assert(node)),
-            AnyNode::StmtImport(node) => Some(Stmt::Import(node)),
-            AnyNode::StmtImportFrom(node) => Some(Stmt::ImportFrom(node)),
-            AnyNode::StmtGlobal(node) => Some(Stmt::Global(node)),
-            AnyNode::StmtNonlocal(node) => Some(Stmt::Nonlocal(node)),
-            AnyNode::StmtExpr(node) => Some(Stmt::Expr(node)),
-            AnyNode::StmtPass(node) => Some(Stmt::Pass(node)),
-            AnyNode::StmtBreak(node) => Some(Stmt::Break(node)),
-            AnyNode::StmtContinue(node) => Some(Stmt::Continue(node)),
-            AnyNode::StmtIpyEscapeCommand(node) => Some(Stmt::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::StmtFunctionDef(node) => Some(StatementRef::FunctionDef(node)),
-            AnyNodeRef::StmtClassDef(node) => Some(StatementRef::ClassDef(node)),
-            AnyNodeRef::StmtReturn(node) => Some(StatementRef::Return(node)),
-            AnyNodeRef::StmtDelete(node) => Some(StatementRef::Delete(node)),
-            AnyNodeRef::StmtTypeAlias(node) => Some(StatementRef::TypeAlias(node)),
-            AnyNodeRef::StmtAssign(node) => Some(StatementRef::Assign(node)),
-            AnyNodeRef::StmtAugAssign(node) => Some(StatementRef::AugAssign(node)),
-            AnyNodeRef::StmtAnnAssign(node) => Some(StatementRef::AnnAssign(node)),
-            AnyNodeRef::StmtFor(node) => Some(StatementRef::For(node)),
-            AnyNodeRef::StmtWhile(node) => Some(StatementRef::While(node)),
-            AnyNodeRef::StmtIf(node) => Some(StatementRef::If(node)),
-            AnyNodeRef::StmtWith(node) => Some(StatementRef::With(node)),
-            AnyNodeRef::StmtMatch(node) => Some(StatementRef::Match(node)),
-            AnyNodeRef::StmtRaise(node) => Some(StatementRef::Raise(node)),
-            AnyNodeRef::StmtTry(node) => Some(StatementRef::Try(node)),
-            AnyNodeRef::StmtAssert(node) => Some(StatementRef::Assert(node)),
-            AnyNodeRef::StmtImport(node) => Some(StatementRef::Import(node)),
-            AnyNodeRef::StmtImportFrom(node) => Some(StatementRef::ImportFrom(node)),
-            AnyNodeRef::StmtGlobal(node) => Some(StatementRef::Global(node)),
-            AnyNodeRef::StmtNonlocal(node) => Some(StatementRef::Nonlocal(node)),
-            AnyNodeRef::StmtExpr(node) => Some(StatementRef::Expr(node)),
-            AnyNodeRef::StmtPass(node) => Some(StatementRef::Pass(node)),
-            AnyNodeRef::StmtBreak(node) => Some(StatementRef::Break(node)),
-            AnyNodeRef::StmtContinue(node) => Some(StatementRef::Continue(node)),
-            AnyNodeRef::StmtIpyEscapeCommand(node) => Some(StatementRef::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(
-            kind,
-            NodeKind::StmtFunctionDef
-                | NodeKind::StmtClassDef
-                | NodeKind::StmtReturn
-                | NodeKind::StmtDelete
-                | NodeKind::StmtTypeAlias
-                | NodeKind::StmtAssign
-                | NodeKind::StmtAugAssign
-                | NodeKind::StmtAnnAssign
-                | NodeKind::StmtFor
-                | NodeKind::StmtWhile
-                | NodeKind::StmtIf
-                | NodeKind::StmtWith
-                | NodeKind::StmtMatch
-                | NodeKind::StmtRaise
-                | NodeKind::StmtTry
-                | NodeKind::StmtAssert
-                | NodeKind::StmtImport
-                | NodeKind::StmtImportFrom
-                | NodeKind::StmtGlobal
-                | NodeKind::StmtNonlocal
-                | NodeKind::StmtExpr
-                | NodeKind::StmtPass
-                | NodeKind::StmtBreak
-                | NodeKind::StmtContinue
-                | NodeKind::StmtIpyEscapeCommand
-        )
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtFunctionDef {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtFunctionDef(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtFunctionDef(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtFunctionDef)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtClassDef {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtClassDef(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtClassDef(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtClassDef)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtReturn {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtReturn(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtReturn(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtReturn)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtDelete {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtDelete(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtDelete(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtDelete)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtTypeAlias {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtTypeAlias(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtTypeAlias(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtTypeAlias)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtAssign {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtAssign)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtAugAssign {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtAugAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtAugAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtAugAssign)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtAnnAssign {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtAnnAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtAnnAssign(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtAnnAssign)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtFor {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtFor(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtFor(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtFor)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtWhile {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtWhile(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtWhile(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtWhile)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtIf {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtIf(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtIf(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtIf)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtWith {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtWith(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtWith(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtWith)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtMatch {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtMatch(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtMatch(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtMatch)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtRaise {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtRaise(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtRaise(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtRaise)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtTry {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtTry(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtTry(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtTry)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtAssert {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtAssert(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtAssert(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtAssert)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtImport {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtImport(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtImport(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtImport)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtImportFrom {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtImportFrom(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtImportFrom(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtImportFrom)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtGlobal {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtGlobal(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtGlobal(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtGlobal)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtNonlocal {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtNonlocal(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtNonlocal(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtNonlocal)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtExpr {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtExpr(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtExpr(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtExpr)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtPass {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtPass(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtPass(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtPass)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtBreak {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtBreak(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtBreak(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtBreak)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtContinue {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtContinue(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtContinue(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtContinue)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StmtIpyEscapeCommand {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StmtIpyEscapeCommand(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StmtIpyEscapeCommand(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StmtIpyEscapeCommand)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for Expr {
-    type Ref<'a> = ExpressionRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::ExprBoolOp(node) => Some(Expr::BoolOp(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::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::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)),
-            AnyNode::ExprCompare(node) => Some(Expr::Compare(node)),
-            AnyNode::ExprCall(node) => Some(Expr::Call(node)),
-            AnyNode::ExprFString(node) => Some(Expr::FString(node)),
-            AnyNode::ExprStringLiteral(node) => Some(Expr::StringLiteral(node)),
-            AnyNode::ExprBytesLiteral(node) => Some(Expr::BytesLiteral(node)),
-            AnyNode::ExprNumberLiteral(node) => Some(Expr::NumberLiteral(node)),
-            AnyNode::ExprBooleanLiteral(node) => Some(Expr::BooleanLiteral(node)),
-            AnyNode::ExprNoneLiteral(node) => Some(Expr::NoneLiteral(node)),
-            AnyNode::ExprEllipsisLiteral(node) => Some(Expr::EllipsisLiteral(node)),
-            AnyNode::ExprAttribute(node) => Some(Expr::Attribute(node)),
-            AnyNode::ExprSubscript(node) => Some(Expr::Subscript(node)),
-            AnyNode::ExprStarred(node) => Some(Expr::Starred(node)),
-            AnyNode::ExprName(node) => Some(Expr::Name(node)),
-            AnyNode::ExprList(node) => Some(Expr::List(node)),
-            AnyNode::ExprTuple(node) => Some(Expr::Tuple(node)),
-            AnyNode::ExprSlice(node) => Some(Expr::Slice(node)),
-            AnyNode::ExprIpyEscapeCommand(node) => Some(Expr::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::ExprBoolOp(node) => Some(ExpressionRef::BoolOp(node)),
-            AnyNodeRef::ExprNamed(node) => Some(ExpressionRef::Named(node)),
-            AnyNodeRef::ExprBinOp(node) => Some(ExpressionRef::BinOp(node)),
-            AnyNodeRef::ExprUnaryOp(node) => Some(ExpressionRef::UnaryOp(node)),
-            AnyNodeRef::ExprLambda(node) => Some(ExpressionRef::Lambda(node)),
-            AnyNodeRef::ExprIf(node) => Some(ExpressionRef::If(node)),
-            AnyNodeRef::ExprDict(node) => Some(ExpressionRef::Dict(node)),
-            AnyNodeRef::ExprSet(node) => Some(ExpressionRef::Set(node)),
-            AnyNodeRef::ExprListComp(node) => Some(ExpressionRef::ListComp(node)),
-            AnyNodeRef::ExprSetComp(node) => Some(ExpressionRef::SetComp(node)),
-            AnyNodeRef::ExprDictComp(node) => Some(ExpressionRef::DictComp(node)),
-            AnyNodeRef::ExprGenerator(node) => Some(ExpressionRef::Generator(node)),
-            AnyNodeRef::ExprAwait(node) => Some(ExpressionRef::Await(node)),
-            AnyNodeRef::ExprYield(node) => Some(ExpressionRef::Yield(node)),
-            AnyNodeRef::ExprYieldFrom(node) => Some(ExpressionRef::YieldFrom(node)),
-            AnyNodeRef::ExprCompare(node) => Some(ExpressionRef::Compare(node)),
-            AnyNodeRef::ExprCall(node) => Some(ExpressionRef::Call(node)),
-            AnyNodeRef::ExprFString(node) => Some(ExpressionRef::FString(node)),
-            AnyNodeRef::ExprStringLiteral(node) => Some(ExpressionRef::StringLiteral(node)),
-            AnyNodeRef::ExprBytesLiteral(node) => Some(ExpressionRef::BytesLiteral(node)),
-            AnyNodeRef::ExprNumberLiteral(node) => Some(ExpressionRef::NumberLiteral(node)),
-            AnyNodeRef::ExprBooleanLiteral(node) => Some(ExpressionRef::BooleanLiteral(node)),
-            AnyNodeRef::ExprNoneLiteral(node) => Some(ExpressionRef::NoneLiteral(node)),
-            AnyNodeRef::ExprEllipsisLiteral(node) => Some(ExpressionRef::EllipsisLiteral(node)),
-            AnyNodeRef::ExprAttribute(node) => Some(ExpressionRef::Attribute(node)),
-            AnyNodeRef::ExprSubscript(node) => Some(ExpressionRef::Subscript(node)),
-            AnyNodeRef::ExprStarred(node) => Some(ExpressionRef::Starred(node)),
-            AnyNodeRef::ExprName(node) => Some(ExpressionRef::Name(node)),
-            AnyNodeRef::ExprList(node) => Some(ExpressionRef::List(node)),
-            AnyNodeRef::ExprTuple(node) => Some(ExpressionRef::Tuple(node)),
-            AnyNodeRef::ExprSlice(node) => Some(ExpressionRef::Slice(node)),
-            AnyNodeRef::ExprIpyEscapeCommand(node) => Some(ExpressionRef::IpyEscapeCommand(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(
-            kind,
-            NodeKind::ExprBoolOp
-                | NodeKind::ExprNamed
-                | NodeKind::ExprBinOp
-                | NodeKind::ExprUnaryOp
-                | NodeKind::ExprLambda
-                | NodeKind::ExprIf
-                | NodeKind::ExprDict
-                | NodeKind::ExprSet
-                | NodeKind::ExprListComp
-                | NodeKind::ExprSetComp
-                | NodeKind::ExprDictComp
-                | NodeKind::ExprGenerator
-                | NodeKind::ExprAwait
-                | NodeKind::ExprYield
-                | NodeKind::ExprYieldFrom
-                | NodeKind::ExprCompare
-                | NodeKind::ExprCall
-                | NodeKind::ExprFString
-                | NodeKind::ExprStringLiteral
-                | NodeKind::ExprBytesLiteral
-                | NodeKind::ExprNumberLiteral
-                | NodeKind::ExprBooleanLiteral
-                | NodeKind::ExprNoneLiteral
-                | NodeKind::ExprEllipsisLiteral
-                | NodeKind::ExprAttribute
-                | NodeKind::ExprSubscript
-                | NodeKind::ExprStarred
-                | NodeKind::ExprName
-                | NodeKind::ExprList
-                | NodeKind::ExprTuple
-                | NodeKind::ExprSlice
-                | NodeKind::ExprIpyEscapeCommand
-        )
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprBoolOp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprBoolOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprBoolOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprBoolOp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprNamed {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprNamed(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprNamed(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprNamed)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprBinOp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprBinOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprBinOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprBinOp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprUnaryOp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprUnaryOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprUnaryOp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprUnaryOp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprLambda {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprLambda(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprLambda(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprLambda)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprIf {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprIf(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprIf(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprIf)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprDict {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprDict(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprDict(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprDict)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprSet {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprSet(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprSet(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprSet)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprListComp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprListComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprListComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprListComp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprSetComp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprSetComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprSetComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprSetComp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprDictComp {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprDictComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprDictComp(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprDictComp)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprGenerator {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprGenerator(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprGenerator(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprGenerator)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprAwait {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprAwait(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprAwait(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprAwait)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprYield {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprYield(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprYield(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprYield)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprYieldFrom {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprYieldFrom(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprYieldFrom(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprYieldFrom)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprCompare {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprCompare(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprCompare(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprCompare)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprCall {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprCall(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprCall(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprCall)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprFString {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprFString(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprFString(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprFString)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprStringLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprStringLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprStringLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprStringLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprBytesLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprBytesLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprBytesLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprBytesLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprNumberLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprNumberLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprNumberLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprNumberLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprBooleanLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprBooleanLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprBooleanLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprBooleanLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprNoneLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprNoneLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprNoneLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprNoneLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprEllipsisLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprEllipsisLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprEllipsisLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprEllipsisLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprAttribute {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprAttribute(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprAttribute(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprAttribute)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprSubscript {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprSubscript(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprSubscript(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprSubscript)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprStarred {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprStarred(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprStarred(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprStarred)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprName {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprName(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprName(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprName)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprList {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprList(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprList(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprList)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprTuple {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprTuple(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprTuple(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprTuple)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprSlice {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprSlice(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprSlice(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprSlice)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExprIpyEscapeCommand {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExprIpyEscapeCommand(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExprIpyEscapeCommand(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExprIpyEscapeCommand)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for ExceptHandler {
-    type Ref<'a> = ExceptHandlerRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::ExceptHandlerExceptHandler(node) => Some(ExceptHandler::ExceptHandler(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::ExceptHandlerExceptHandler(node) => {
-                Some(ExceptHandlerRef::ExceptHandler(node))
-            }
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExceptHandlerExceptHandler)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ExceptHandlerExceptHandler {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ExceptHandlerExceptHandler(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ExceptHandlerExceptHandler(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ExceptHandlerExceptHandler)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for FStringElement {
-    type Ref<'a> = FStringElementRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::FStringExpressionElement(node) => Some(FStringElement::Expression(node)),
-            AnyNode::FStringLiteralElement(node) => Some(FStringElement::Literal(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::FStringExpressionElement(node) => Some(FStringElementRef::Expression(node)),
-            AnyNodeRef::FStringLiteralElement(node) => Some(FStringElementRef::Literal(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(
-            kind,
-            NodeKind::FStringExpressionElement | NodeKind::FStringLiteralElement
-        )
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::FStringExpressionElement {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::FStringExpressionElement(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::FStringExpressionElement(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::FStringExpressionElement)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::FStringLiteralElement {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::FStringLiteralElement(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::FStringLiteralElement(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::FStringLiteralElement)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for Pattern {
-    type Ref<'a> = PatternRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::PatternMatchValue(node) => Some(Pattern::MatchValue(node)),
-            AnyNode::PatternMatchSingleton(node) => Some(Pattern::MatchSingleton(node)),
-            AnyNode::PatternMatchSequence(node) => Some(Pattern::MatchSequence(node)),
-            AnyNode::PatternMatchMapping(node) => Some(Pattern::MatchMapping(node)),
-            AnyNode::PatternMatchClass(node) => Some(Pattern::MatchClass(node)),
-            AnyNode::PatternMatchStar(node) => Some(Pattern::MatchStar(node)),
-            AnyNode::PatternMatchAs(node) => Some(Pattern::MatchAs(node)),
-            AnyNode::PatternMatchOr(node) => Some(Pattern::MatchOr(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::PatternMatchValue(node) => Some(PatternRef::MatchValue(node)),
-            AnyNodeRef::PatternMatchSingleton(node) => Some(PatternRef::MatchSingleton(node)),
-            AnyNodeRef::PatternMatchSequence(node) => Some(PatternRef::MatchSequence(node)),
-            AnyNodeRef::PatternMatchMapping(node) => Some(PatternRef::MatchMapping(node)),
-            AnyNodeRef::PatternMatchClass(node) => Some(PatternRef::MatchClass(node)),
-            AnyNodeRef::PatternMatchStar(node) => Some(PatternRef::MatchStar(node)),
-            AnyNodeRef::PatternMatchAs(node) => Some(PatternRef::MatchAs(node)),
-            AnyNodeRef::PatternMatchOr(node) => Some(PatternRef::MatchOr(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(
-            kind,
-            NodeKind::PatternMatchValue
-                | NodeKind::PatternMatchSingleton
-                | NodeKind::PatternMatchSequence
-                | NodeKind::PatternMatchMapping
-                | NodeKind::PatternMatchClass
-                | NodeKind::PatternMatchStar
-                | NodeKind::PatternMatchAs
-                | NodeKind::PatternMatchOr
-        )
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchValue {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchValue(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchValue(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchValue)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchSingleton {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchSingleton(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchSingleton(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchSingleton)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchSequence {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchSequence(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchSequence(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchSequence)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchMapping {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchMapping(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchMapping(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchMapping)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchClass {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchClass(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchClass(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchClass)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchStar {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchStar(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchStar(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchStar)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchAs {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchAs(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchAs(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchAs)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternMatchOr {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternMatchOr(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternMatchOr(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternMatchOr)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for TypeParam {
-    type Ref<'a> = TypeParamRef<'a>;
-
-    fn cast(node: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        match node {
-            AnyNode::TypeParamTypeVar(node) => Some(TypeParam::TypeVar(node)),
-            AnyNode::TypeParamTypeVarTuple(node) => Some(TypeParam::TypeVarTuple(node)),
-            AnyNode::TypeParamParamSpec(node) => Some(TypeParam::ParamSpec(node)),
-
-            _ => None,
-        }
-    }
-
-    fn cast_ref(node: AnyNodeRef) -> Option<Self::Ref<'_>> {
-        match node {
-            AnyNodeRef::TypeParamTypeVar(node) => Some(TypeParamRef::TypeVar(node)),
-            AnyNodeRef::TypeParamTypeVarTuple(node) => Some(TypeParamRef::TypeVarTuple(node)),
-            AnyNodeRef::TypeParamParamSpec(node) => Some(TypeParamRef::ParamSpec(node)),
-
-            _ => None,
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(
-            kind,
-            NodeKind::TypeParamTypeVar
-                | NodeKind::TypeParamTypeVarTuple
-                | NodeKind::TypeParamParamSpec
-        )
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::TypeParamTypeVar {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::TypeParamTypeVar(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::TypeParamTypeVar(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::TypeParamTypeVar)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::TypeParamTypeVarTuple {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::TypeParamTypeVarTuple(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::TypeParamTypeVarTuple(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::TypeParamTypeVarTuple)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::TypeParamParamSpec {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::TypeParamParamSpec(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::TypeParamParamSpec(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::TypeParamParamSpec)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::FStringFormatSpec {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::FStringFormatSpec(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::FStringFormatSpec(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::FStringFormatSpec)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternArguments {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternArguments(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternArguments(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternArguments)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::PatternKeyword {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::PatternKeyword(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::PatternKeyword(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::PatternKeyword)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Comprehension {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Comprehension(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Comprehension(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Comprehension)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Arguments {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Arguments(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Arguments(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Arguments)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Parameters {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Parameters(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Parameters(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Parameters)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Parameter {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Parameter(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Parameter(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Parameter)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ParameterWithDefault {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ParameterWithDefault(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ParameterWithDefault(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ParameterWithDefault)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Keyword {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Keyword(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Keyword(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Keyword)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Alias {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Alias(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Alias(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Alias)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::WithItem {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::WithItem(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::WithItem(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::WithItem)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::MatchCase {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::MatchCase(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::MatchCase(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::MatchCase)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Decorator {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Decorator(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Decorator(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Decorator)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::ElifElseClause {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::ElifElseClause(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::ElifElseClause(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::ElifElseClause)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::TypeParams {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::TypeParams(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::TypeParams(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::TypeParams)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::FString {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::FString(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::FString(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::FString)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::StringLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::StringLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::StringLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::StringLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::BytesLiteral {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::BytesLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::BytesLiteral(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::BytesLiteral)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
-
-impl crate::AstNode for crate::Identifier {
-    type Ref<'a> = &'a Self;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        if let AnyNode::Identifier(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
-        if let AnyNodeRef::Identifier(node) = kind {
-            Some(node)
-        } else {
-            None
-        }
-    }
-
-    fn can_cast(kind: NodeKind) -> bool {
-        matches!(kind, NodeKind::Identifier)
-    }
-
-    fn as_any_node_ref(&self) -> AnyNodeRef {
-        AnyNodeRef::from(self)
-    }
-
-    fn into_any_node(self) -> AnyNode {
-        AnyNode::from(self)
-    }
-}
diff --git a/crates/ruff_python_ast/src/lib.rs b/crates/ruff_python_ast/src/lib.rs
index d397d5ef5c..6f7ab46296 100644
--- a/crates/ruff_python_ast/src/lib.rs
+++ b/crates/ruff_python_ast/src/lib.rs
@@ -4,7 +4,6 @@ use std::path::Path;
 pub use expression::*;
 pub use generated::*;
 pub use int::*;
-pub use node::AstNode;
 pub use nodes::*;
 
 pub mod comparable;
diff --git a/crates/ruff_python_ast/src/node.rs b/crates/ruff_python_ast/src/node.rs
index cc61f4a759..a3bbb669d6 100644
--- a/crates/ruff_python_ast/src/node.rs
+++ b/crates/ruff_python_ast/src/node.rs
@@ -1,26 +1,8 @@
 use crate::visitor::source_order::SourceOrderVisitor;
 use crate::{
-    self as ast, Alias, AnyNode, AnyNodeRef, AnyParameterRef, ArgOrKeyword, MatchCase, NodeKind,
-    PatternArguments, PatternKeyword,
+    self as ast, Alias, AnyNodeRef, AnyParameterRef, ArgOrKeyword, MatchCase, PatternArguments,
+    PatternKeyword,
 };
-use ruff_text_size::Ranged;
-
-pub trait AstNode: Ranged {
-    type Ref<'a>;
-
-    fn cast(kind: AnyNode) -> Option<Self>
-    where
-        Self: Sized;
-    fn cast_ref(kind: AnyNodeRef<'_>) -> Option<Self::Ref<'_>>;
-
-    fn can_cast(kind: NodeKind) -> bool;
-
-    /// Returns the [`AnyNodeRef`] referencing this node.
-    fn as_any_node_ref(&self) -> AnyNodeRef;
-
-    /// Consumes `self` and returns its [`AnyNode`] representation.
-    fn into_any_node(self) -> AnyNode;
-}
 
 impl ast::ModModule {
     pub(crate) fn visit_source_order<'a, V>(&'a self, visitor: &mut V)
diff --git a/crates/ruff_python_formatter/generate.py b/crates/ruff_python_formatter/generate.py
index 2a662cdefe..4263b26c91 100755
--- a/crates/ruff_python_formatter/generate.py
+++ b/crates/ruff_python_formatter/generate.py
@@ -28,11 +28,11 @@ nodes_file = (
     .read_text()
 )
 node_lines = (
-    nodes_file.split("pub enum AnyNode {")[1].split("}")[0].strip().splitlines()
+    nodes_file.split("pub enum AnyNodeRef<'a> {")[1].split("}")[0].strip().splitlines()
 )
 nodes = []
 for node_line in node_lines:
-    node = node_line.split("(")[1].split(")")[0].split("::")[-1].split("<")[0]
+    node = node_line.split("(")[1].split(")")[0].split("::")[-1].removeprefix("&'a ")
     # `FString` has a custom implementation while the formatting for
     # `FStringLiteralElement`, `FStringFormatSpec` and `FStringExpressionElement` are handled by the `FString`
     # implementation.
diff --git a/crates/ruff_python_formatter/src/comments/debug.rs b/crates/ruff_python_formatter/src/comments/debug.rs
index 2729275fe9..a2038669b4 100644
--- a/crates/ruff_python_formatter/src/comments/debug.rs
+++ b/crates/ruff_python_formatter/src/comments/debug.rs
@@ -184,7 +184,7 @@ mod tests {
     use insta::assert_debug_snapshot;
 
     use ruff_formatter::SourceCode;
-    use ruff_python_ast::AnyNode;
+    use ruff_python_ast::AnyNodeRef;
     use ruff_python_ast::{StmtBreak, StmtContinue};
     use ruff_python_trivia::{CommentLinePosition, CommentRanges};
     use ruff_text_size::{TextRange, TextSize};
@@ -194,13 +194,13 @@ mod tests {
 
     #[test]
     fn debug() {
-        let continue_statement = AnyNode::from(StmtContinue {
+        let continue_statement = StmtContinue {
             range: TextRange::new(TextSize::new(18), TextSize::new(26)),
-        });
+        };
 
-        let break_statement = AnyNode::from(StmtBreak {
+        let break_statement = StmtBreak {
             range: TextRange::new(TextSize::new(55), TextSize::new(60)),
-        });
+        };
 
         let source = r"# leading comment
 continue; # trailing
@@ -213,7 +213,7 @@ break;
         let mut comments_map: CommentsMap = MultiMap::new();
 
         comments_map.push_leading(
-            continue_statement.as_ref().into(),
+            AnyNodeRef::from(&continue_statement).into(),
             SourceComment::new(
                 source_code.slice(TextRange::at(TextSize::new(0), TextSize::new(17))),
                 CommentLinePosition::OwnLine,
@@ -221,7 +221,7 @@ break;
         );
 
         comments_map.push_trailing(
-            continue_statement.as_ref().into(),
+            AnyNodeRef::from(&continue_statement).into(),
             SourceComment::new(
                 source_code.slice(TextRange::at(TextSize::new(28), TextSize::new(10))),
                 CommentLinePosition::EndOfLine,
@@ -229,7 +229,7 @@ break;
         );
 
         comments_map.push_leading(
-            break_statement.as_ref().into(),
+            AnyNodeRef::from(&break_statement).into(),
             SourceComment::new(
                 source_code.slice(TextRange::at(TextSize::new(39), TextSize::new(15))),
                 CommentLinePosition::OwnLine,
diff --git a/crates/ruff_python_formatter/src/comments/format.rs b/crates/ruff_python_formatter/src/comments/format.rs
index 1aef8d61ab..aa7f31ac27 100644
--- a/crates/ruff_python_formatter/src/comments/format.rs
+++ b/crates/ruff_python_formatter/src/comments/format.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use ruff_formatter::{format_args, write, FormatError, FormatOptions, SourceCode};
-use ruff_python_ast::{AnyNodeRef, AstNode, NodeKind, PySourceType};
+use ruff_python_ast::{AnyNodeRef, NodeKind, PySourceType};
 use ruff_python_trivia::{
     is_pragma_comment, lines_after, lines_after_ignoring_trivia, lines_before, CommentLinePosition,
 };
@@ -13,11 +13,11 @@ use crate::prelude::*;
 use crate::statement::suite::should_insert_blank_line_after_class_in_stub_file;
 
 /// Formats the leading comments of a node.
-pub(crate) fn leading_node_comments<T>(node: &T) -> FormatLeadingComments
+pub(crate) fn leading_node_comments<'a, T>(node: T) -> FormatLeadingComments<'a>
 where
-    T: AstNode,
+    T: Into<AnyNodeRef<'a>>,
 {
-    FormatLeadingComments::Node(node.as_any_node_ref())
+    FormatLeadingComments::Node(node.into())
 }
 
 /// Formats the passed comments as leading comments
@@ -192,11 +192,11 @@ impl Format<PyFormatContext<'_>> for FormatTrailingComments<'_> {
 }
 
 /// Formats the dangling comments of `node`.
-pub(crate) fn dangling_node_comments<T>(node: &T) -> FormatDanglingComments
+pub(crate) fn dangling_node_comments<'a, T>(node: T) -> FormatDanglingComments<'a>
 where
-    T: AstNode,
+    T: Into<AnyNodeRef<'a>>,
 {
-    FormatDanglingComments::Node(node.as_any_node_ref())
+    FormatDanglingComments::Node(node.into())
 }
 
 pub(crate) fn dangling_comments(comments: &[SourceComment]) -> FormatDanglingComments {
diff --git a/crates/ruff_python_formatter/src/expression/expr_slice.rs b/crates/ruff_python_formatter/src/expression/expr_slice.rs
index 368fe0228c..29358ab704 100644
--- a/crates/ruff_python_formatter/src/expression/expr_slice.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_slice.rs
@@ -1,5 +1,5 @@
 use ruff_formatter::{write, FormatError};
-use ruff_python_ast::{AnyNodeRef, AstNode};
+use ruff_python_ast::AnyNodeRef;
 use ruff_python_ast::{Expr, ExprSlice, ExprUnaryOp, UnaryOp};
 use ruff_python_trivia::{SimpleToken, SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange};
@@ -36,7 +36,7 @@ impl FormatNodeRule<ExprSlice> for FormatExprSlice {
         // to handle newlines and spacing, or the node is None and we insert the corresponding
         // slice of dangling comments
         let comments = f.context().comments().clone();
-        let slice_dangling_comments = comments.dangling(item.as_any_node_ref());
+        let slice_dangling_comments = comments.dangling(item);
         // Put the dangling comments (where the nodes are missing) into buckets
         let first_colon_partition_index =
             slice_dangling_comments.partition_point(|x| x.start() < first_colon.start());
diff --git a/crates/ruff_python_formatter/src/expression/expr_subscript.rs b/crates/ruff_python_formatter/src/expression/expr_subscript.rs
index 3aa6661b21..221b43ab1b 100644
--- a/crates/ruff_python_formatter/src/expression/expr_subscript.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_subscript.rs
@@ -1,5 +1,5 @@
 use ruff_formatter::{write, FormatRuleWithOptions};
-use ruff_python_ast::{AnyNodeRef, AstNode};
+use ruff_python_ast::AnyNodeRef;
 use ruff_python_ast::{Expr, ExprSubscript};
 
 use crate::expression::expr_tuple::TupleParentheses;
@@ -35,7 +35,7 @@ impl FormatNodeRule<ExprSubscript> for FormatExprSubscript {
         let call_chain_layout = self.call_chain_layout.apply_in_node(item, f);
 
         let comments = f.context().comments().clone();
-        let dangling_comments = comments.dangling(item.as_any_node_ref());
+        let dangling_comments = comments.dangling(item);
         debug_assert!(
             dangling_comments.len() <= 1,
             "A subscript expression can only have a single dangling comment, the one after the bracket"
diff --git a/crates/ruff_python_formatter/src/lib.rs b/crates/ruff_python_formatter/src/lib.rs
index cbe56762f2..a4498a3a87 100644
--- a/crates/ruff_python_formatter/src/lib.rs
+++ b/crates/ruff_python_formatter/src/lib.rs
@@ -4,10 +4,10 @@ use tracing::Level;
 pub use range::format_range;
 use ruff_formatter::prelude::*;
 use ruff_formatter::{format, write, FormatError, Formatted, PrintError, Printed, SourceCode};
-use ruff_python_ast::AstNode;
-use ruff_python_ast::Mod;
+use ruff_python_ast::{AnyNodeRef, Mod};
 use ruff_python_parser::{parse, AsMode, ParseError, Parsed};
 use ruff_python_trivia::CommentRanges;
+use ruff_text_size::Ranged;
 
 use crate::comments::{
     has_skip_comment, leading_comments, trailing_comments, Comments, SourceComment,
@@ -43,23 +43,23 @@ mod verbatim;
 /// 'ast is the lifetime of the source code (input), 'buf is the lifetime of the buffer (output)
 pub(crate) type PyFormatter<'ast, 'buf> = Formatter<'buf, PyFormatContext<'ast>>;
 
-/// Rule for formatting a Python [`AstNode`].
+/// Rule for formatting a Python AST node.
 pub(crate) trait FormatNodeRule<N>
 where
-    N: AstNode,
+    N: Ranged,
+    for<'a> AnyNodeRef<'a>: From<&'a N>,
 {
     fn fmt(&self, node: &N, f: &mut PyFormatter) -> FormatResult<()> {
         let comments = f.context().comments().clone();
 
-        let node_comments = comments.leading_dangling_trailing(node.as_any_node_ref());
+        let node_ref = AnyNodeRef::from(node);
+        let node_comments = comments.leading_dangling_trailing(node_ref);
 
         if self.is_suppressed(node_comments.trailing, f.context()) {
-            suppressed_node(node.as_any_node_ref()).fmt(f)
+            suppressed_node(node_ref).fmt(f)
         } else {
             leading_comments(node_comments.leading).fmt(f)?;
 
-            let node_ref = node.as_any_node_ref();
-
             // Emit source map information for nodes that are valid "narrowing" targets
             // in range formatting. Never emit source map information if they're disabled
             // for performance reasons.
diff --git a/crates/ruff_python_formatter/src/other/parameters.rs b/crates/ruff_python_formatter/src/other/parameters.rs
index 7515ede0a0..617233a467 100644
--- a/crates/ruff_python_formatter/src/other/parameters.rs
+++ b/crates/ruff_python_formatter/src/other/parameters.rs
@@ -1,6 +1,5 @@
 use ruff_formatter::{format_args, write, FormatRuleWithOptions};
-use ruff_python_ast::Parameters;
-use ruff_python_ast::{AnyNodeRef, AstNode};
+use ruff_python_ast::{AnyNodeRef, Parameters};
 use ruff_python_trivia::{CommentLinePosition, SimpleToken, SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
@@ -165,7 +164,7 @@ impl FormatNodeRule<Parameters> for FormatParameters {
                     token("*"),
                     vararg.format()
                 ]);
-                last_node = Some(vararg.as_any_node_ref());
+                last_node = Some(vararg.as_ref().into());
             } else if !kwonlyargs.is_empty() {
                 // Given very strange comment placement, comments here may not actually have been
                 // marked as `StarLeading`/`StarTrailing`, but that's fine since we still produce
@@ -201,7 +200,7 @@ impl FormatNodeRule<Parameters> for FormatParameters {
                     token("**"),
                     kwarg.format()
                 ]);
-                last_node = Some(kwarg.as_any_node_ref());
+                last_node = Some(kwarg.as_ref().into());
             }
 
             joiner.finish()?;
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs b/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs
index 3bbfa4cece..6b3a82c722 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::write;
-use ruff_python_ast::AstNode;
 use ruff_python_ast::{Pattern, PatternArguments};
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange, TextSize};
@@ -63,7 +62,7 @@ impl FormatNodeRule<PatternArguments> for FormatPatternArguments {
         // )
         // ```
         let comments = f.context().comments().clone();
-        let dangling_comments = comments.dangling(item.as_any_node_ref());
+        let dangling_comments = comments.dangling(item);
 
         write!(
             f,
diff --git a/crates/ruff_python_formatter/src/statement/stmt_global.rs b/crates/ruff_python_formatter/src/statement/stmt_global.rs
index ea70ee34a4..dd31d31106 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_global.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_global.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::{format_args, write};
-use ruff_python_ast::AstNode;
 use ruff_python_ast::StmtGlobal;
 
 use crate::comments::SourceComment;
@@ -14,7 +13,7 @@ impl FormatNodeRule<StmtGlobal> for FormatStmtGlobal {
         // Join the `global` names, breaking across continuation lines if necessary, unless the
         // `global` statement has a trailing comment, in which case, breaking the names would
         // move the comment "off" of the `global` statement.
-        if f.context().comments().has_trailing(item.as_any_node_ref()) {
+        if f.context().comments().has_trailing(item) {
             let joined = format_with(|f| {
                 f.join_with(format_args![token(","), space()])
                     .entries(item.names.iter().formatted())
diff --git a/crates/ruff_python_formatter/src/statement/stmt_import_from.rs b/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
index 5218f3c231..eb91c45279 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::write;
-use ruff_python_ast::AstNode;
 use ruff_python_ast::StmtImportFrom;
 use ruff_text_size::Ranged;
 
@@ -62,7 +61,7 @@ impl FormatNodeRule<StmtImportFrom> for FormatStmtImportFrom {
         // )
         // ```
         let comments = f.context().comments().clone();
-        let parenthesized_comments = comments.dangling(item.as_any_node_ref());
+        let parenthesized_comments = comments.dangling(item);
 
         if parenthesized_comments.is_empty() {
             parenthesize_if_expands(&names).fmt(f)
diff --git a/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs b/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
index 3280e0d93b..666adbacae 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::{format_args, write};
-use ruff_python_ast::AstNode;
 use ruff_python_ast::StmtNonlocal;
 
 use crate::comments::SourceComment;
@@ -14,7 +13,7 @@ impl FormatNodeRule<StmtNonlocal> for FormatStmtNonlocal {
         // Join the `nonlocal` names, breaking across continuation lines if necessary, unless the
         // `nonlocal` statement has a trailing comment, in which case, breaking the names would
         // move the comment "off" of the `nonlocal` statement.
-        if f.context().comments().has_trailing(item.as_any_node_ref()) {
+        if f.context().comments().has_trailing(item) {
             let joined = format_with(|f| {
                 f.join_with(format_args![token(","), space()])
                     .entries(item.names.iter().formatted())
diff --git a/crates/ruff_python_formatter/src/statement/stmt_while.rs b/crates/ruff_python_formatter/src/statement/stmt_while.rs
index 19dc175998..538a186920 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_while.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_while.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::{format_args, write};
-use ruff_python_ast::AstNode;
 use ruff_python_ast::{Stmt, StmtWhile};
 use ruff_text_size::Ranged;
 
@@ -22,7 +21,7 @@ impl FormatNodeRule<StmtWhile> for FormatStmtWhile {
         } = item;
 
         let comments = f.context().comments().clone();
-        let dangling_comments = comments.dangling(item.as_any_node_ref());
+        let dangling_comments = comments.dangling(item);
 
         let body_start = body.first().map_or(test.end(), Stmt::start);
         let or_else_comments_start =
diff --git a/crates/ruff_python_formatter/src/statement/stmt_with.rs b/crates/ruff_python_formatter/src/statement/stmt_with.rs
index a237763396..493be1e517 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_with.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_with.rs
@@ -1,6 +1,5 @@
 use ruff_formatter::{format_args, write, FormatContext, FormatError};
-use ruff_python_ast::StmtWith;
-use ruff_python_ast::{AstNode, WithItem};
+use ruff_python_ast::{StmtWith, WithItem};
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange};
 
@@ -36,7 +35,7 @@ impl FormatNodeRule<StmtWith> for FormatStmtWith {
         //     ...
         // ```
         let comments = f.context().comments().clone();
-        let dangling_comments = comments.dangling(with_stmt.as_any_node_ref());
+        let dangling_comments = comments.dangling(with_stmt);
         let partition_point = dangling_comments.partition_point(|comment| {
             with_stmt
                 .items
diff --git a/crates/ruff_python_formatter/src/type_param/type_params.rs b/crates/ruff_python_formatter/src/type_param/type_params.rs
index 8743fb46b8..e243dc6006 100644
--- a/crates/ruff_python_formatter/src/type_param/type_params.rs
+++ b/crates/ruff_python_formatter/src/type_param/type_params.rs
@@ -1,5 +1,4 @@
 use ruff_formatter::FormatResult;
-use ruff_python_ast::AstNode;
 use ruff_python_ast::TypeParams;
 use ruff_text_size::Ranged;
 
@@ -21,7 +20,7 @@ impl FormatNodeRule<TypeParams> for FormatTypeParams {
         //     c,
         // ] = ...
         let comments = f.context().comments().clone();
-        let dangling_comments = comments.dangling(item.as_any_node_ref());
+        let dangling_comments = comments.dangling(item);
 
         let items = format_with(|f| {
             f.join_comma_separated(item.end())