rust-analyzer - Unnamed repository; edit this file 'description' to name the repository.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[email protected]
  [email protected]
    [email protected] "fn"
    [email protected] " "
    [email protected]
      [email protected] "f"
    [email protected]
      [email protected] "("
      [email protected]
        [email protected]
          [email protected] "_"
        [email protected] ":"
        [email protected] " "
        [email protected]
          [email protected] "&"
          [email protected]
            [email protected] "dyn"
            [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
      [email protected]
        [email protected] "{"
        [email protected] "}"
error 9..12: At least one trait is required for an object type
//! Generated by `cargo xtask codegen grammar`, do not edit by hand.

#![allow(non_snake_case)]
use crate::{
    SyntaxKind::{self, *},
    SyntaxNode, SyntaxToken, T,
    ast::{self, AstChildren, AstNode, support},
};
use std::{fmt, hash};
pub struct Abi {
    pub(crate) syntax: SyntaxNode,
}
impl Abi {
    #[inline]
    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
    #[inline]
    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
}
pub struct ArgList {
    pub(crate) syntax: SyntaxNode,
}
impl ArgList {
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct ArrayExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ArrayExpr {}
impl ArrayExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
}
pub struct ArrayType {
    pub(crate) syntax: SyntaxNode,
}
impl ArrayType {
    #[inline]
    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
}
pub struct AsmClobberAbi {
    pub(crate) syntax: SyntaxNode,
}
impl AsmClobberAbi {
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn clobber_abi_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![clobber_abi])
    }
    #[inline]
    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
}
pub struct AsmConst {
    pub(crate) syntax: SyntaxNode,
}
impl AsmConst {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
}
pub struct AsmDirSpec {
    pub(crate) syntax: SyntaxNode,
}
impl AsmDirSpec {
    #[inline]
    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
    #[inline]
    pub fn inlateout_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![inlateout])
    }
    #[inline]
    pub fn inout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![inout]) }
    #[inline]
    pub fn lateout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![lateout]) }
    #[inline]
    pub fn out_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![out]) }
}
pub struct AsmExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for AsmExpr {}
impl AsmExpr {
    #[inline]
    pub fn asm_pieces(&self) -> AstChildren<AsmPiece> { support::children(&self.syntax) }
    #[inline]
    pub fn template(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
    #[inline]
    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) }
    #[inline]
    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
    #[inline]
    pub fn global_asm_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![global_asm])
    }
    #[inline]
    pub fn naked_asm_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![naked_asm])
    }
}
pub struct AsmLabel {
    pub(crate) syntax: SyntaxNode,
}
impl AsmLabel {
    #[inline]
    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
    #[inline]
    pub fn label_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![label]) }
}
pub struct AsmOperandExpr {
    pub(crate) syntax: SyntaxNode,
}
impl AsmOperandExpr {
    #[inline]
    pub fn in_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn out_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
}
pub struct AsmOperandNamed {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasName for AsmOperandNamed {}
impl AsmOperandNamed {
    #[inline]
    pub fn asm_operand(&self) -> Option<AsmOperand> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
}
pub struct AsmOption {
    pub(crate) syntax: SyntaxNode,
}
impl AsmOption {
    #[inline]
    pub fn att_syntax_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![att_syntax])
    }
    #[inline]
    pub fn may_unwind_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![may_unwind])
    }
    #[inline]
    pub fn nomem_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nomem]) }
    #[inline]
    pub fn noreturn_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![noreturn])
    }
    #[inline]
    pub fn nostack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nostack]) }
    #[inline]
    pub fn preserves_flags_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![preserves_flags])
    }
    #[inline]
    pub fn pure_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pure]) }
    #[inline]
    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
    #[inline]
    pub fn readonly_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![readonly])
    }
}
pub struct AsmOptions {
    pub(crate) syntax: SyntaxNode,
}
impl AsmOptions {
    #[inline]
    pub fn asm_options(&self) -> AstChildren<AsmOption> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn options_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![options]) }
}
pub struct AsmRegOperand {
    pub(crate) syntax: SyntaxNode,
}
impl AsmRegOperand {
    #[inline]
    pub fn asm_dir_spec(&self) -> Option<AsmDirSpec> { support::child(&self.syntax) }
    #[inline]
    pub fn asm_operand_expr(&self) -> Option<AsmOperandExpr> { support::child(&self.syntax) }
    #[inline]
    pub fn asm_reg_spec(&self) -> Option<AsmRegSpec> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct AsmRegSpec {
    pub(crate) syntax: SyntaxNode,
}
impl AsmRegSpec {
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
}
pub struct AsmSym {
    pub(crate) syntax: SyntaxNode,
}
impl AsmSym {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn sym_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![sym]) }
}
pub struct AssocItemList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for AssocItemList {}
impl AssocItemList {
    #[inline]
    pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct AssocTypeArg {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasGenericArgs for AssocTypeArg {}
impl ast::HasTypeBounds for AssocTypeArg {}
impl AssocTypeArg {
    #[inline]
    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
    #[inline]
    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
    #[inline]
    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
}
pub struct Attr {
    pub(crate) syntax: SyntaxNode,
}
impl Attr {
    #[inline]
    pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) }
    #[inline]
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
    #[inline]
    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
}
pub struct AwaitExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for AwaitExpr {}
impl AwaitExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
    #[inline]
    pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
}
pub struct BecomeExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for BecomeExpr {}
impl BecomeExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn become_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![become]) }
}
pub struct BinExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for BinExpr {}
impl BinExpr {}
pub struct BlockExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for BlockExpr {}
impl BlockExpr {
    #[inline]
    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
    #[inline]
    pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) }
    #[inline]
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
    #[inline]
    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
    #[inline]
    pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct BoxPat {
    pub(crate) syntax: SyntaxNode,
}
impl BoxPat {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
}
pub struct BreakExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for BreakExpr {}
impl BreakExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
}
pub struct CallExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasArgList for CallExpr {}
impl ast::HasAttrs for CallExpr {}
impl CallExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
pub struct CastExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for CastExpr {}
impl CastExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
}
pub struct ClosureExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ClosureExpr {}
impl ClosureExpr {
    #[inline]
    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
    #[inline]
    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
    #[inline]
    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
    #[inline]
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
    #[inline]
    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
    #[inline]
    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
}
pub struct Const {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Const {}
impl ast::HasDocComments for Const {}
impl ast::HasGenericParams for Const {}
impl ast::HasName for Const {}
impl ast::HasVisibility for Const {}
impl Const {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
}
pub struct ConstArg {
    pub(crate) syntax: SyntaxNode,
}
impl ConstArg {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
pub struct ConstBlockPat {
    pub(crate) syntax: SyntaxNode,
}
impl ConstBlockPat {
    #[inline]
    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
}
pub struct ConstParam {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ConstParam {}
impl ast::HasName for ConstParam {}
impl ConstParam {
    #[inline]
    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
}
pub struct ContinueExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ContinueExpr {}
impl ContinueExpr {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn continue_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![continue])
    }
}
pub struct DynTraitType {
    pub(crate) syntax: SyntaxNode,
}
impl DynTraitType {
    #[inline]
    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
    #[inline]
    pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
}
pub struct Enum {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Enum {}
impl ast::HasDocComments for Enum {}
impl ast::HasGenericParams for Enum {}
impl ast::HasName for Enum {}
impl ast::HasVisibility for Enum {}
impl Enum {
    #[inline]
    pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
    #[inline]
    pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
}
pub struct ExprStmt {
    pub(crate) syntax: SyntaxNode,
}
impl ExprStmt {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
}
pub struct ExternBlock {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ExternBlock {}
impl ast::HasDocComments for ExternBlock {}
impl ExternBlock {
    #[inline]
    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
    #[inline]
    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct ExternCrate {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ExternCrate {}
impl ast::HasDocComments for ExternCrate {}
impl ast::HasVisibility for ExternCrate {}
impl ExternCrate {
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
    #[inline]
    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
}
pub struct ExternItemList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ExternItemList {}
impl ExternItemList {
    #[inline]
    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct FieldExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for FieldExpr {}
impl FieldExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
}
pub struct Fn {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Fn {}
impl ast::HasDocComments for Fn {}
impl ast::HasGenericParams for Fn {}
impl ast::HasName for Fn {}
impl ast::HasVisibility for Fn {}
impl Fn {
    #[inline]
    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
    #[inline]
    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
    #[inline]
    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
    #[inline]
    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
    #[inline]
    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
    #[inline]
    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct FnPtrType {
    pub(crate) syntax: SyntaxNode,
}
impl FnPtrType {
    #[inline]
    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
    #[inline]
    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
    #[inline]
    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
    #[inline]
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct ForBinder {
    pub(crate) syntax: SyntaxNode,
}
impl ForBinder {
    #[inline]
    pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
    #[inline]
    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
}
pub struct ForExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ForExpr {}
impl ForExpr {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
    #[inline]
    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
}
pub struct ForType {
    pub(crate) syntax: SyntaxNode,
}
impl ForType {
    #[inline]
    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
}
pub struct FormatArgsArg {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasName for FormatArgsArg {}
impl FormatArgsArg {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
}
pub struct FormatArgsExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for FormatArgsExpr {}
impl FormatArgsExpr {
    #[inline]
    pub fn template(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
    #[inline]
    pub fn format_args_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![format_args])
    }
}
pub struct GenericArgList {
    pub(crate) syntax: SyntaxNode,
}
impl GenericArgList {
    #[inline]
    pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
    #[inline]
    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
    #[inline]
    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
    #[inline]
    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
}
pub struct GenericParamList {
    pub(crate) syntax: SyntaxNode,
}
impl GenericParamList {
    #[inline]
    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
    #[inline]
    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
    #[inline]
    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
}
pub struct IdentPat {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for IdentPat {}
impl ast::HasName for IdentPat {}
impl IdentPat {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
    #[inline]
    pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
}
pub struct IfExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for IfExpr {}
impl IfExpr {
    #[inline]
    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
    #[inline]
    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
}
pub struct Impl {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Impl {}
impl ast::HasDocComments for Impl {}
impl ast::HasGenericParams for Impl {}
impl ast::HasVisibility for Impl {}
impl Impl {
    #[inline]
    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
    #[inline]
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
    #[inline]
    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
    #[inline]
    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct ImplTraitType {
    pub(crate) syntax: SyntaxNode,
}
impl ImplTraitType {
    #[inline]
    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
    #[inline]
    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
}
pub struct IndexExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for IndexExpr {}
impl IndexExpr {
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
}
pub struct InferType {
    pub(crate) syntax: SyntaxNode,
}
impl InferType {
    #[inline]
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
}
pub struct ItemList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ItemList {}
impl ast::HasModuleItem for ItemList {}
impl ItemList {
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct Label {
    pub(crate) syntax: SyntaxNode,
}
impl Label {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
}
pub struct LetElse {
    pub(crate) syntax: SyntaxNode,
}
impl LetElse {
    #[inline]
    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
    #[inline]
    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
}
pub struct LetExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for LetExpr {}
impl LetExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
}
pub struct LetStmt {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for LetStmt {}
impl LetStmt {
    #[inline]
    pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) }
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
    #[inline]
    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
}
pub struct Lifetime {
    pub(crate) syntax: SyntaxNode,
}
impl Lifetime {
    #[inline]
    pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![lifetime_ident])
    }
}
pub struct LifetimeArg {
    pub(crate) syntax: SyntaxNode,
}
impl LifetimeArg {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
}
pub struct LifetimeParam {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for LifetimeParam {}
impl ast::HasTypeBounds for LifetimeParam {}
impl LifetimeParam {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
}
pub struct Literal {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Literal {}
impl Literal {}
pub struct LiteralPat {
    pub(crate) syntax: SyntaxNode,
}
impl LiteralPat {
    #[inline]
    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
    #[inline]
    pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }
}
pub struct LoopExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for LoopExpr {}
impl ast::HasLoopBody for LoopExpr {}
impl LoopExpr {
    #[inline]
    pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
}
pub struct MacroCall {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MacroCall {}
impl ast::HasDocComments for MacroCall {}
impl MacroCall {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
    #[inline]
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
}
pub struct MacroDef {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MacroDef {}
impl ast::HasDocComments for MacroDef {}
impl ast::HasName for MacroDef {}
impl ast::HasVisibility for MacroDef {}
impl MacroDef {
    #[inline]
    pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) }
}
pub struct MacroExpr {
    pub(crate) syntax: SyntaxNode,
}
impl MacroExpr {
    #[inline]
    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
}
pub struct MacroItems {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasModuleItem for MacroItems {}
impl MacroItems {}
pub struct MacroPat {
    pub(crate) syntax: SyntaxNode,
}
impl MacroPat {
    #[inline]
    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
}
pub struct MacroRules {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MacroRules {}
impl ast::HasDocComments for MacroRules {}
impl ast::HasName for MacroRules {}
impl ast::HasVisibility for MacroRules {}
impl MacroRules {
    #[inline]
    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
    #[inline]
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
    #[inline]
    pub fn macro_rules_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![macro_rules])
    }
}
pub struct MacroStmts {
    pub(crate) syntax: SyntaxNode,
}
impl MacroStmts {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
}
pub struct MacroType {
    pub(crate) syntax: SyntaxNode,
}
impl MacroType {
    #[inline]
    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
}
pub struct MatchArm {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MatchArm {}
impl MatchArm {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
}
pub struct MatchArmList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MatchArmList {}
impl MatchArmList {
    #[inline]
    pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct MatchExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for MatchExpr {}
impl MatchExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
    #[inline]
    pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
}
pub struct MatchGuard {
    pub(crate) syntax: SyntaxNode,
}
impl MatchGuard {
    #[inline]
    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
}
pub struct Meta {
    pub(crate) syntax: SyntaxNode,
}
impl Meta {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct MethodCallExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasArgList for MethodCallExpr {}
impl ast::HasAttrs for MethodCallExpr {}
impl ast::HasGenericArgs for MethodCallExpr {}
impl MethodCallExpr {
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
}
pub struct Module {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Module {}
impl ast::HasDocComments for Module {}
impl ast::HasName for Module {}
impl ast::HasVisibility for Module {}
impl Module {
    #[inline]
    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
}
pub struct Name {
    pub(crate) syntax: SyntaxNode,
}
impl Name {
    #[inline]
    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
    #[inline]
    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
}
pub struct NameRef {
    pub(crate) syntax: SyntaxNode,
}
impl NameRef {
    #[inline]
    pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) }
    #[inline]
    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
    #[inline]
    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
    #[inline]
    pub fn int_number_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![int_number])
    }
    #[inline]
    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
    #[inline]
    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
}
pub struct NeverType {
    pub(crate) syntax: SyntaxNode,
}
impl NeverType {
    #[inline]
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
}
pub struct OffsetOfExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for OffsetOfExpr {}
impl OffsetOfExpr {
    #[inline]
    pub fn fields(&self) -> AstChildren<NameRef> { support::children(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
    #[inline]
    pub fn offset_of_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![offset_of])
    }
}
pub struct OrPat {
    pub(crate) syntax: SyntaxNode,
}
impl OrPat {
    #[inline]
    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
    #[inline]
    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
}
pub struct Param {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Param {}
impl Param {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
}
pub struct ParamList {
    pub(crate) syntax: SyntaxNode,
}
impl ParamList {
    #[inline]
    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
    #[inline]
    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
    #[inline]
    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
}
pub struct ParenExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ParenExpr {}
impl ParenExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct ParenPat {
    pub(crate) syntax: SyntaxNode,
}
impl ParenPat {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct ParenType {
    pub(crate) syntax: SyntaxNode,
}
impl ParenType {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct ParenthesizedArgList {
    pub(crate) syntax: SyntaxNode,
}
impl ParenthesizedArgList {
    #[inline]
    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
}
pub struct Path {
    pub(crate) syntax: SyntaxNode,
}
impl Path {
    #[inline]
    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
    #[inline]
    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
}
pub struct PathExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for PathExpr {}
impl PathExpr {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
}
pub struct PathPat {
    pub(crate) syntax: SyntaxNode,
}
impl PathPat {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
}
pub struct PathSegment {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasGenericArgs for PathSegment {}
impl PathSegment {
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn parenthesized_arg_list(&self) -> Option<ParenthesizedArgList> {
        support::child(&self.syntax)
    }
    #[inline]
    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
    #[inline]
    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }
    #[inline]
    pub fn type_anchor(&self) -> Option<TypeAnchor> { support::child(&self.syntax) }
    #[inline]
    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
}
pub struct PathType {
    pub(crate) syntax: SyntaxNode,
}
impl PathType {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
}
pub struct PrefixExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for PrefixExpr {}
impl PrefixExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
pub struct PtrType {
    pub(crate) syntax: SyntaxNode,
}
impl PtrType {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
}
pub struct RangeExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RangeExpr {}
impl RangeExpr {}
pub struct RangePat {
    pub(crate) syntax: SyntaxNode,
}
impl RangePat {}
pub struct RecordExpr {
    pub(crate) syntax: SyntaxNode,
}
impl RecordExpr {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
        support::child(&self.syntax)
    }
}
pub struct RecordExprField {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RecordExprField {}
impl RecordExprField {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
}
pub struct RecordExprFieldList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RecordExprFieldList {}
impl RecordExprFieldList {
    #[inline]
    pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
    #[inline]
    pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
    #[inline]
    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
}
pub struct RecordField {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RecordField {}
impl ast::HasDocComments for RecordField {}
impl ast::HasName for RecordField {}
impl ast::HasVisibility for RecordField {}
impl RecordField {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct RecordFieldList {
    pub(crate) syntax: SyntaxNode,
}
impl RecordFieldList {
    #[inline]
    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct RecordPat {
    pub(crate) syntax: SyntaxNode,
}
impl RecordPat {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
        support::child(&self.syntax)
    }
}
pub struct RecordPatField {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RecordPatField {}
impl RecordPatField {
    #[inline]
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
}
pub struct RecordPatFieldList {
    pub(crate) syntax: SyntaxNode,
}
impl RecordPatFieldList {
    #[inline]
    pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
    #[inline]
    pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct RefExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RefExpr {}
impl RefExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
    #[inline]
    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
}
pub struct RefPat {
    pub(crate) syntax: SyntaxNode,
}
impl RefPat {
    #[inline]
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
    #[inline]
    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
}
pub struct RefType {
    pub(crate) syntax: SyntaxNode,
}
impl RefType {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
}
pub struct Rename {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasName for Rename {}
impl Rename {
    #[inline]
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
    #[inline]
    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
}
pub struct RestPat {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for RestPat {}
impl RestPat {
    #[inline]
    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
}
pub struct RetType {
    pub(crate) syntax: SyntaxNode,
}
impl RetType {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
}
pub struct ReturnExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for ReturnExpr {}
impl ReturnExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
}
pub struct ReturnTypeSyntax {
    pub(crate) syntax: SyntaxNode,
}
impl ReturnTypeSyntax {
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
}
pub struct SelfParam {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for SelfParam {}
impl ast::HasName for SelfParam {}
impl SelfParam {
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
}
pub struct SlicePat {
    pub(crate) syntax: SyntaxNode,
}
impl SlicePat {
    #[inline]
    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
}
pub struct SliceType {
    pub(crate) syntax: SyntaxNode,
}
impl SliceType {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
}
pub struct SourceFile {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for SourceFile {}
impl ast::HasDocComments for SourceFile {}
impl ast::HasModuleItem for SourceFile {}
impl SourceFile {
    #[inline]
    pub fn frontmatter_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, T![frontmatter])
    }
    #[inline]
    pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
}
pub struct Static {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Static {}
impl ast::HasDocComments for Static {}
impl ast::HasName for Static {}
impl ast::HasVisibility for Static {}
impl Static {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
    #[inline]
    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }
    #[inline]
    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct StmtList {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for StmtList {}
impl StmtList {
    #[inline]
    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
    #[inline]
    pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct Struct {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Struct {}
impl ast::HasDocComments for Struct {}
impl ast::HasGenericParams for Struct {}
impl ast::HasName for Struct {}
impl ast::HasVisibility for Struct {}
impl Struct {
    #[inline]
    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
}
pub struct TokenTree {
    pub(crate) syntax: SyntaxNode,
}
impl TokenTree {
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct Trait {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Trait {}
impl ast::HasDocComments for Trait {}
impl ast::HasGenericParams for Trait {}
impl ast::HasName for Trait {}
impl ast::HasTypeBounds for Trait {}
impl ast::HasVisibility for Trait {}
impl Trait {
    #[inline]
    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
    #[inline]
    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
    #[inline]
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct TryExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TryExpr {}
impl TryExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
}
pub struct TupleExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TupleExpr {}
impl TupleExpr {
    #[inline]
    pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct TupleField {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TupleField {}
impl ast::HasDocComments for TupleField {}
impl ast::HasVisibility for TupleField {}
impl TupleField {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
}
pub struct TupleFieldList {
    pub(crate) syntax: SyntaxNode,
}
impl TupleFieldList {
    #[inline]
    pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct TuplePat {
    pub(crate) syntax: SyntaxNode,
}
impl TuplePat {
    #[inline]
    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct TupleStructPat {
    pub(crate) syntax: SyntaxNode,
}
impl TupleStructPat {
    #[inline]
    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct TupleType {
    pub(crate) syntax: SyntaxNode,
}
impl TupleType {
    #[inline]
    pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
}
pub struct TypeAlias {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TypeAlias {}
impl ast::HasDocComments for TypeAlias {}
impl ast::HasGenericParams for TypeAlias {}
impl ast::HasName for TypeAlias {}
impl ast::HasTypeBounds for TypeAlias {}
impl ast::HasVisibility for TypeAlias {}
impl TypeAlias {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
    #[inline]
    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
    #[inline]
    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
}
pub struct TypeAnchor {
    pub(crate) syntax: SyntaxNode,
}
impl TypeAnchor {
    #[inline]
    pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
    #[inline]
    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
    #[inline]
    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
}
pub struct TypeArg {
    pub(crate) syntax: SyntaxNode,
}
impl TypeArg {
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
}
pub struct TypeBound {
    pub(crate) syntax: SyntaxNode,
}
impl TypeBound {
    #[inline]
    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn use_bound_generic_args(&self) -> Option<UseBoundGenericArgs> {
        support::child(&self.syntax)
    }
    #[inline]
    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
    #[inline]
    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
    #[inline]
    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
    #[inline]
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
    #[inline]
    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    #[inline]
    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
    #[inline]
    pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }
}
pub struct TypeBoundList {
    pub(crate) syntax: SyntaxNode,
}
impl TypeBoundList {
    #[inline]
    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
}
pub struct TypeParam {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TypeParam {}
impl ast::HasName for TypeParam {}
impl ast::HasTypeBounds for TypeParam {}
impl TypeParam {
    #[inline]
    pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
}
pub struct UnderscoreExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for UnderscoreExpr {}
impl UnderscoreExpr {
    #[inline]
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
}
pub struct Union {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Union {}
impl ast::HasDocComments for Union {}
impl ast::HasGenericParams for Union {}
impl ast::HasName for Union {}
impl ast::HasVisibility for Union {}
impl Union {
    #[inline]
    pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
    #[inline]
    pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
}
pub struct Use {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Use {}
impl ast::HasDocComments for Use {}
impl ast::HasVisibility for Use {}
impl Use {
    #[inline]
    pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
    #[inline]
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
    #[inline]
    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
}
pub struct UseBoundGenericArgs {
    pub(crate) syntax: SyntaxNode,
}
impl UseBoundGenericArgs {
    #[inline]
    pub fn use_bound_generic_args(&self) -> AstChildren<UseBoundGenericArg> {
        support::children(&self.syntax)
    }
    #[inline]
    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
    #[inline]
    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
}
pub struct UseTree {
    pub(crate) syntax: SyntaxNode,
}
impl UseTree {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
    #[inline]
    pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
    #[inline]
    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
    #[inline]
    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
}
pub struct UseTreeList {
    pub(crate) syntax: SyntaxNode,
}
impl UseTreeList {
    #[inline]
    pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct Variant {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for Variant {}
impl ast::HasDocComments for Variant {}
impl ast::HasName for Variant {}
impl ast::HasVisibility for Variant {}
impl Variant {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
    #[inline]
    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
}
pub struct VariantList {
    pub(crate) syntax: SyntaxNode,
}
impl VariantList {
    #[inline]
    pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
    #[inline]
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    #[inline]
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
}
pub struct Visibility {
    pub(crate) syntax: SyntaxNode,
}
impl Visibility {
    #[inline]
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    #[inline]
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
    #[inline]
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
    #[inline]
    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
    #[inline]
    pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
}
pub struct WhereClause {
    pub(crate) syntax: SyntaxNode,
}
impl WhereClause {
    #[inline]
    pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
    #[inline]
    pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
}
pub struct WherePred {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasTypeBounds for WherePred {}
impl WherePred {
    #[inline]
    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
    #[inline]
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    #[inline]
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
}
pub struct WhileExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for WhileExpr {}
impl WhileExpr {
    #[inline]
    pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
}
pub struct WildcardPat {
    pub(crate) syntax: SyntaxNode,
}
impl WildcardPat {
    #[inline]
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
}
pub struct YeetExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for YeetExpr {}
impl YeetExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn do_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![do]) }
    #[inline]
    pub fn yeet_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yeet]) }
}
pub struct YieldExpr {
    pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for YieldExpr {}
impl YieldExpr {
    #[inline]
    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    #[inline]
    pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Adt {
    Enum(Enum),
    Struct(Struct),
    Union(Union),
}
impl ast::HasAttrs for Adt {}
impl ast::HasDocComments for Adt {}
impl ast::HasGenericParams for Adt {}
impl ast::HasName for Adt {}
impl ast::HasVisibility for Adt {}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AsmOperand {
    AsmConst(AsmConst),
    AsmLabel(AsmLabel),
    AsmRegOperand(AsmRegOperand),
    AsmSym(AsmSym),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AsmPiece {
    AsmClobberAbi(AsmClobberAbi),
    AsmOperandNamed(AsmOperandNamed),
    AsmOptions(AsmOptions),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AssocItem {
    Const(Const),
    Fn(Fn),
    MacroCall(MacroCall),
    TypeAlias(TypeAlias),
}
impl ast::HasAttrs for AssocItem {}
impl ast::HasDocComments for AssocItem {}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Expr {
    ArrayExpr(ArrayExpr),
    AsmExpr(AsmExpr),
    AwaitExpr(AwaitExpr),
    BecomeExpr(BecomeExpr),
    BinExpr(BinExpr),
    BlockExpr(BlockExpr),
    BreakExpr(BreakExpr),
    CallExpr(CallExpr),
    CastExpr(CastExpr),
    ClosureExpr(ClosureExpr),
    ContinueExpr(ContinueExpr),
    FieldExpr(FieldExpr),
    ForExpr(ForExpr),
    FormatArgsExpr(FormatArgsExpr),
    IfExpr(IfExpr),
    IndexExpr(IndexExpr),
    LetExpr(LetExpr),
    Literal(Literal),
    LoopExpr(LoopExpr),
    MacroExpr(MacroExpr),
    MatchExpr(MatchExpr),
    MethodCallExpr(MethodCallExpr),
    OffsetOfExpr(OffsetOfExpr),
    ParenExpr(ParenExpr),
    PathExpr(PathExpr),
    PrefixExpr(PrefixExpr),
    RangeExpr(RangeExpr),
    RecordExpr(RecordExpr),
    RefExpr(RefExpr),
    ReturnExpr(ReturnExpr),
    TryExpr(TryExpr),
    TupleExpr(TupleExpr),
    UnderscoreExpr(UnderscoreExpr),
    WhileExpr(WhileExpr),
    YeetExpr(YeetExpr),
    YieldExpr(YieldExpr),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ExternItem {
    Fn(Fn),
    MacroCall(MacroCall),
    Static(Static),
    TypeAlias(TypeAlias),
}
impl ast::HasAttrs for ExternItem {}
impl ast::HasDocComments for ExternItem {}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum FieldList {
    RecordFieldList(RecordFieldList),
    TupleFieldList(TupleFieldList),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GenericArg {
    AssocTypeArg(AssocTypeArg),
    ConstArg(ConstArg),
    LifetimeArg(LifetimeArg),
    TypeArg(TypeArg),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GenericParam {
    ConstParam(ConstParam),
    LifetimeParam(LifetimeParam),
    TypeParam(TypeParam),
}
impl ast::HasAttrs for GenericParam {}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Item {
    AsmExpr(AsmExpr),
    Const(Const),
    Enum(Enum),
    ExternBlock(ExternBlock),
    ExternCrate(ExternCrate),
    Fn(Fn),
    Impl(Impl),
    MacroCall(MacroCall),
    MacroDef(MacroDef),
    MacroRules(MacroRules),
    Module(Module),
    Static(Static),
    Struct(Struct),
    Trait(Trait),
    TypeAlias(TypeAlias),
    Union(Union),
    Use(Use),
}
impl ast::HasAttrs for Item {}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Pat {
    BoxPat(BoxPat),
    ConstBlockPat(ConstBlockPat),
    IdentPat(IdentPat),
    LiteralPat(LiteralPat),
    MacroPat(MacroPat),
    OrPat(OrPat),
    ParenPat(ParenPat),
    PathPat(PathPat),
    RangePat(RangePat),
    RecordPat(RecordPat),
    RefPat(RefPat),
    RestPat(RestPat),
    SlicePat(SlicePat),
    TuplePat(TuplePat),
    TupleStructPat(TupleStructPat),
    WildcardPat(WildcardPat),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Stmt {
    ExprStmt(ExprStmt),
    Item(Item),
    LetStmt(LetStmt),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Type {
    ArrayType(ArrayType),
    DynTraitType(DynTraitType),
    FnPtrType(FnPtrType),
    ForType(ForType),
    ImplTraitType(ImplTraitType),
    InferType(InferType),
    MacroType(MacroType),
    NeverType(NeverType),
    ParenType(ParenType),
    PathType(PathType),
    PtrType(PtrType),
    RefType(RefType),
    SliceType(SliceType),
    TupleType(TupleType),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum UseBoundGenericArg {
    Lifetime(Lifetime),
    NameRef(NameRef),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VariantDef {
    Struct(Struct),
    Union(Union),
    Variant(Variant),
}
impl ast::HasAttrs for VariantDef {}
impl ast::HasDocComments for VariantDef {}
impl ast::HasName for VariantDef {}
impl ast::HasVisibility for VariantDef {}
pub struct AnyHasArgList {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasArgList {
    #[inline]
    pub fn new<T: ast::HasArgList>(node: T) -> AnyHasArgList {
        AnyHasArgList { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasAttrs {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasAttrs {
    #[inline]
    pub fn new<T: ast::HasAttrs>(node: T) -> AnyHasAttrs {
        AnyHasAttrs { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasDocComments {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasDocComments {
    #[inline]
    pub fn new<T: ast::HasDocComments>(node: T) -> AnyHasDocComments {
        AnyHasDocComments { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasGenericArgs {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasGenericArgs {
    #[inline]
    pub fn new<T: ast::HasGenericArgs>(node: T) -> AnyHasGenericArgs {
        AnyHasGenericArgs { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasGenericParams {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasGenericParams {
    #[inline]
    pub fn new<T: ast::HasGenericParams>(node: T) -> AnyHasGenericParams {
        AnyHasGenericParams { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasLoopBody {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasLoopBody {
    #[inline]
    pub fn new<T: ast::HasLoopBody>(node: T) -> AnyHasLoopBody {
        AnyHasLoopBody { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasModuleItem {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasModuleItem {
    #[inline]
    pub fn new<T: ast::HasModuleItem>(node: T) -> AnyHasModuleItem {
        AnyHasModuleItem { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasName {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasName {
    #[inline]
    pub fn new<T: ast::HasName>(node: T) -> AnyHasName {
        AnyHasName { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasTypeBounds {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasTypeBounds {
    #[inline]
    pub fn new<T: ast::HasTypeBounds>(node: T) -> AnyHasTypeBounds {
        AnyHasTypeBounds { syntax: node.syntax().clone() }
    }
}
pub struct AnyHasVisibility {
    pub(crate) syntax: SyntaxNode,
}
impl AnyHasVisibility {
    #[inline]
    pub fn new<T: ast::HasVisibility>(node: T) -> AnyHasVisibility {
        AnyHasVisibility { syntax: node.syntax().clone() }
    }
}
impl AstNode for Abi {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ABI
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Abi {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Abi {}
impl PartialEq for Abi {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Abi {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Abi {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Abi").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ArgList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ARG_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ArgList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ArgList {}
impl PartialEq for ArgList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ArgList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ArgList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ArgList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ArrayExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ARRAY_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ArrayExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ArrayExpr {}
impl PartialEq for ArrayExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ArrayExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ArrayExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ArrayExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ArrayType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ARRAY_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ArrayType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ArrayType {}
impl PartialEq for ArrayType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ArrayType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ArrayType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ArrayType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmClobberAbi {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_CLOBBER_ABI
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CLOBBER_ABI }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmClobberAbi {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmClobberAbi {}
impl PartialEq for AsmClobberAbi {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmClobberAbi {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmClobberAbi {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmClobberAbi").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmConst {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_CONST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CONST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmConst {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmConst {}
impl PartialEq for AsmConst {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmConst {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmConst {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmConst").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmDirSpec {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_DIR_SPEC
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_DIR_SPEC }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmDirSpec {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmDirSpec {}
impl PartialEq for AsmDirSpec {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmDirSpec {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmDirSpec {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmDirSpec").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmExpr {}
impl PartialEq for AsmExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmLabel {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_LABEL
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_LABEL }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmLabel {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmLabel {}
impl PartialEq for AsmLabel {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmLabel {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmLabel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmLabel").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmOperandExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_OPERAND_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmOperandExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmOperandExpr {}
impl PartialEq for AsmOperandExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmOperandExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmOperandExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmOperandExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmOperandNamed {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_OPERAND_NAMED
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_NAMED }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmOperandNamed {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmOperandNamed {}
impl PartialEq for AsmOperandNamed {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmOperandNamed {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmOperandNamed {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmOperandNamed").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmOption {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_OPTION
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTION }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmOption {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmOption {}
impl PartialEq for AsmOption {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmOption {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmOption {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmOption").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmOptions {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_OPTIONS
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTIONS }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmOptions {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmOptions {}
impl PartialEq for AsmOptions {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmOptions {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmOptions {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmOptions").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmRegOperand {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_REG_OPERAND
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_OPERAND }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmRegOperand {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmRegOperand {}
impl PartialEq for AsmRegOperand {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmRegOperand {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmRegOperand {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmRegOperand").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmRegSpec {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_REG_SPEC
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_SPEC }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmRegSpec {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmRegSpec {}
impl PartialEq for AsmRegSpec {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmRegSpec {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmRegSpec {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmRegSpec").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AsmSym {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASM_SYM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_SYM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AsmSym {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AsmSym {}
impl PartialEq for AsmSym {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AsmSym {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AsmSym {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AsmSym").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AssocItemList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASSOC_ITEM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AssocItemList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AssocItemList {}
impl PartialEq for AssocItemList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AssocItemList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AssocItemList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AssocItemList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AssocTypeArg {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ASSOC_TYPE_ARG
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AssocTypeArg {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AssocTypeArg {}
impl PartialEq for AssocTypeArg {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AssocTypeArg {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AssocTypeArg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AssocTypeArg").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Attr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ATTR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Attr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Attr {}
impl PartialEq for Attr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Attr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Attr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Attr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for AwaitExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        AWAIT_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AwaitExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AwaitExpr {}
impl PartialEq for AwaitExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AwaitExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AwaitExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AwaitExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for BecomeExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        BECOME_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == BECOME_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for BecomeExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for BecomeExpr {}
impl PartialEq for BecomeExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for BecomeExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for BecomeExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("BecomeExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for BinExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        BIN_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for BinExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for BinExpr {}
impl PartialEq for BinExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for BinExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for BinExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("BinExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for BlockExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        BLOCK_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for BlockExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for BlockExpr {}
impl PartialEq for BlockExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for BlockExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for BlockExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("BlockExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for BoxPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        BOX_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for BoxPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for BoxPat {}
impl PartialEq for BoxPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for BoxPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for BoxPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("BoxPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for BreakExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        BREAK_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for BreakExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for BreakExpr {}
impl PartialEq for BreakExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for BreakExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for BreakExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("BreakExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for CallExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CALL_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for CallExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for CallExpr {}
impl PartialEq for CallExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for CallExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for CallExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("CallExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for CastExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CAST_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for CastExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for CastExpr {}
impl PartialEq for CastExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for CastExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for CastExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("CastExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ClosureExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CLOSURE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ClosureExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ClosureExpr {}
impl PartialEq for ClosureExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ClosureExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ClosureExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ClosureExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Const {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CONST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Const {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Const {}
impl PartialEq for Const {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Const {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Const {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Const").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ConstArg {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CONST_ARG
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ConstArg {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ConstArg {}
impl PartialEq for ConstArg {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ConstArg {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ConstArg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ConstArg").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ConstBlockPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CONST_BLOCK_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ConstBlockPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ConstBlockPat {}
impl PartialEq for ConstBlockPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ConstBlockPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ConstBlockPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ConstBlockPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ConstParam {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CONST_PARAM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ConstParam {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ConstParam {}
impl PartialEq for ConstParam {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ConstParam {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ConstParam {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ConstParam").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ContinueExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        CONTINUE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ContinueExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ContinueExpr {}
impl PartialEq for ContinueExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ContinueExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ContinueExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ContinueExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for DynTraitType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        DYN_TRAIT_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for DynTraitType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for DynTraitType {}
impl PartialEq for DynTraitType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for DynTraitType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for DynTraitType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DynTraitType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Enum {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ENUM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Enum {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Enum {}
impl PartialEq for Enum {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Enum {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Enum {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Enum").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ExprStmt {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        EXPR_STMT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ExprStmt {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ExprStmt {}
impl PartialEq for ExprStmt {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ExprStmt {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ExprStmt {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExprStmt").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ExternBlock {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        EXTERN_BLOCK
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ExternBlock {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ExternBlock {}
impl PartialEq for ExternBlock {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ExternBlock {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ExternBlock {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExternBlock").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ExternCrate {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        EXTERN_CRATE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ExternCrate {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ExternCrate {}
impl PartialEq for ExternCrate {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ExternCrate {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ExternCrate {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExternCrate").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ExternItemList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        EXTERN_ITEM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ExternItemList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ExternItemList {}
impl PartialEq for ExternItemList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ExternItemList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ExternItemList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExternItemList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for FieldExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FIELD_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for FieldExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for FieldExpr {}
impl PartialEq for FieldExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for FieldExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for FieldExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FieldExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Fn {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FN
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Fn {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Fn {}
impl PartialEq for Fn {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Fn {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Fn {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Fn").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for FnPtrType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FN_PTR_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for FnPtrType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for FnPtrType {}
impl PartialEq for FnPtrType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for FnPtrType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for FnPtrType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FnPtrType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ForBinder {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FOR_BINDER
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_BINDER }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ForBinder {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ForBinder {}
impl PartialEq for ForBinder {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ForBinder {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ForBinder {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ForBinder").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ForExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FOR_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ForExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ForExpr {}
impl PartialEq for ForExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ForExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ForExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ForExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ForType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FOR_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ForType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ForType {}
impl PartialEq for ForType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ForType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ForType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ForType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for FormatArgsArg {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FORMAT_ARGS_ARG
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for FormatArgsArg {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for FormatArgsArg {}
impl PartialEq for FormatArgsArg {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for FormatArgsArg {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for FormatArgsArg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FormatArgsArg").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for FormatArgsExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        FORMAT_ARGS_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for FormatArgsExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for FormatArgsExpr {}
impl PartialEq for FormatArgsExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for FormatArgsExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for FormatArgsExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FormatArgsExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for GenericArgList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        GENERIC_ARG_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for GenericArgList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for GenericArgList {}
impl PartialEq for GenericArgList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for GenericArgList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for GenericArgList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GenericArgList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for GenericParamList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        GENERIC_PARAM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for GenericParamList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for GenericParamList {}
impl PartialEq for GenericParamList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for GenericParamList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for GenericParamList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GenericParamList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for IdentPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        IDENT_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for IdentPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for IdentPat {}
impl PartialEq for IdentPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for IdentPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for IdentPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("IdentPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for IfExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        IF_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for IfExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for IfExpr {}
impl PartialEq for IfExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for IfExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for IfExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("IfExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Impl {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        IMPL
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Impl {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Impl {}
impl PartialEq for Impl {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Impl {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Impl {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Impl").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ImplTraitType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        IMPL_TRAIT_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ImplTraitType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ImplTraitType {}
impl PartialEq for ImplTraitType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ImplTraitType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ImplTraitType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ImplTraitType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for IndexExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        INDEX_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for IndexExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for IndexExpr {}
impl PartialEq for IndexExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for IndexExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for IndexExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("IndexExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for InferType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        INFER_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for InferType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for InferType {}
impl PartialEq for InferType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for InferType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for InferType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("InferType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ItemList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        ITEM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ItemList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ItemList {}
impl PartialEq for ItemList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ItemList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ItemList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ItemList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Label {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LABEL
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Label {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Label {}
impl PartialEq for Label {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Label {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Label {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Label").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LetElse {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LET_ELSE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LetElse {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LetElse {}
impl PartialEq for LetElse {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LetElse {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LetElse {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LetElse").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LetExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LET_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LetExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LetExpr {}
impl PartialEq for LetExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LetExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LetExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LetExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LetStmt {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LET_STMT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LetStmt {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LetStmt {}
impl PartialEq for LetStmt {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LetStmt {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LetStmt {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LetStmt").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Lifetime {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LIFETIME
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Lifetime {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Lifetime {}
impl PartialEq for Lifetime {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Lifetime {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Lifetime {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Lifetime").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LifetimeArg {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LIFETIME_ARG
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LifetimeArg {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LifetimeArg {}
impl PartialEq for LifetimeArg {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LifetimeArg {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LifetimeArg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LifetimeArg").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LifetimeParam {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LIFETIME_PARAM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LifetimeParam {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LifetimeParam {}
impl PartialEq for LifetimeParam {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LifetimeParam {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LifetimeParam {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LifetimeParam").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Literal {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LITERAL
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Literal {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Literal {}
impl PartialEq for Literal {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Literal {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Literal {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Literal").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LiteralPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LITERAL_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LiteralPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LiteralPat {}
impl PartialEq for LiteralPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LiteralPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LiteralPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LiteralPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for LoopExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        LOOP_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for LoopExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for LoopExpr {}
impl PartialEq for LoopExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for LoopExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for LoopExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LoopExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroCall {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_CALL
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroCall {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroCall {}
impl PartialEq for MacroCall {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroCall {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroCall {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroCall").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroDef {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_DEF
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroDef {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroDef {}
impl PartialEq for MacroDef {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroDef {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroDef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroDef").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroExpr {}
impl PartialEq for MacroExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroItems {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_ITEMS
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroItems {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroItems {}
impl PartialEq for MacroItems {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroItems {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroItems {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroItems").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroPat {}
impl PartialEq for MacroPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroRules {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_RULES
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroRules {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroRules {}
impl PartialEq for MacroRules {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroRules {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroRules {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroRules").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroStmts {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_STMTS
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroStmts {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroStmts {}
impl PartialEq for MacroStmts {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroStmts {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroStmts {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroStmts").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MacroType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MACRO_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MacroType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MacroType {}
impl PartialEq for MacroType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MacroType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MacroType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MacroType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MatchArm {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MATCH_ARM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MatchArm {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MatchArm {}
impl PartialEq for MatchArm {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MatchArm {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MatchArm {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MatchArm").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MatchArmList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MATCH_ARM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MatchArmList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MatchArmList {}
impl PartialEq for MatchArmList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MatchArmList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MatchArmList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MatchArmList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MatchExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MATCH_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MatchExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MatchExpr {}
impl PartialEq for MatchExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MatchExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MatchExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MatchExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MatchGuard {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MATCH_GUARD
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MatchGuard {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MatchGuard {}
impl PartialEq for MatchGuard {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MatchGuard {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MatchGuard {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MatchGuard").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Meta {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        META
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == META }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Meta {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Meta {}
impl PartialEq for Meta {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Meta {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Meta {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Meta").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for MethodCallExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        METHOD_CALL_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for MethodCallExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for MethodCallExpr {}
impl PartialEq for MethodCallExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for MethodCallExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for MethodCallExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MethodCallExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Module {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        MODULE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Module {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Module {}
impl PartialEq for Module {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Module {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Module {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Module").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Name {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        NAME
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Name {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Name {}
impl PartialEq for Name {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Name {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Name {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Name").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for NameRef {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        NAME_REF
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for NameRef {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for NameRef {}
impl PartialEq for NameRef {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for NameRef {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for NameRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("NameRef").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for NeverType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        NEVER_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for NeverType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for NeverType {}
impl PartialEq for NeverType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for NeverType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for NeverType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("NeverType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for OffsetOfExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        OFFSET_OF_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == OFFSET_OF_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for OffsetOfExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for OffsetOfExpr {}
impl PartialEq for OffsetOfExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for OffsetOfExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for OffsetOfExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("OffsetOfExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for OrPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        OR_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for OrPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for OrPat {}
impl PartialEq for OrPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for OrPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for OrPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("OrPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Param {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PARAM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Param {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Param {}
impl PartialEq for Param {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Param {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Param {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Param").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ParamList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PARAM_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ParamList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ParamList {}
impl PartialEq for ParamList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ParamList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ParamList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ParamList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ParenExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PAREN_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ParenExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ParenExpr {}
impl PartialEq for ParenExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ParenExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ParenExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ParenExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ParenPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PAREN_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ParenPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ParenPat {}
impl PartialEq for ParenPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ParenPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ParenPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ParenPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ParenType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PAREN_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ParenType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ParenType {}
impl PartialEq for ParenType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ParenType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ParenType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ParenType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ParenthesizedArgList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PARENTHESIZED_ARG_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PARENTHESIZED_ARG_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ParenthesizedArgList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ParenthesizedArgList {}
impl PartialEq for ParenthesizedArgList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ParenthesizedArgList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ParenthesizedArgList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ParenthesizedArgList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Path {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PATH
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Path {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Path {}
impl PartialEq for Path {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Path {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Path {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Path").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PathExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PATH_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PathExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PathExpr {}
impl PartialEq for PathExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PathExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PathExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PathExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PathPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PATH_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PathPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PathPat {}
impl PartialEq for PathPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PathPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PathPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PathPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PathSegment {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PATH_SEGMENT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PathSegment {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PathSegment {}
impl PartialEq for PathSegment {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PathSegment {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PathSegment {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PathSegment").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PathType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PATH_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PathType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PathType {}
impl PartialEq for PathType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PathType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PathType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PathType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PrefixExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PREFIX_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PrefixExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PrefixExpr {}
impl PartialEq for PrefixExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PrefixExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PrefixExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PrefixExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for PtrType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        PTR_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for PtrType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for PtrType {}
impl PartialEq for PtrType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for PtrType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for PtrType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PtrType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RangeExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RANGE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RangeExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RangeExpr {}
impl PartialEq for RangeExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RangeExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RangeExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RangeExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RangePat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RANGE_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RangePat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RangePat {}
impl PartialEq for RangePat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RangePat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RangePat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RangePat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordExpr {}
impl PartialEq for RecordExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordExprField {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_EXPR_FIELD
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordExprField {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordExprField {}
impl PartialEq for RecordExprField {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordExprField {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordExprField {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordExprField").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordExprFieldList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_EXPR_FIELD_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordExprFieldList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordExprFieldList {}
impl PartialEq for RecordExprFieldList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordExprFieldList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordExprFieldList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordExprFieldList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordField {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_FIELD
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordField {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordField {}
impl PartialEq for RecordField {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordField {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordField {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordField").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordFieldList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_FIELD_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordFieldList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordFieldList {}
impl PartialEq for RecordFieldList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordFieldList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordFieldList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordFieldList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordPat {}
impl PartialEq for RecordPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordPatField {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_PAT_FIELD
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordPatField {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordPatField {}
impl PartialEq for RecordPatField {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordPatField {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordPatField {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordPatField").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RecordPatFieldList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RECORD_PAT_FIELD_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RecordPatFieldList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RecordPatFieldList {}
impl PartialEq for RecordPatFieldList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RecordPatFieldList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RecordPatFieldList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecordPatFieldList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RefExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        REF_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RefExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RefExpr {}
impl PartialEq for RefExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RefExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RefExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RefExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RefPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        REF_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RefPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RefPat {}
impl PartialEq for RefPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RefPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RefPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RefPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RefType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        REF_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RefType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RefType {}
impl PartialEq for RefType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RefType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RefType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RefType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Rename {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RENAME
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Rename {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Rename {}
impl PartialEq for Rename {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Rename {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Rename {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Rename").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RestPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        REST_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RestPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RestPat {}
impl PartialEq for RestPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RestPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RestPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RestPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for RetType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RET_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for RetType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for RetType {}
impl PartialEq for RetType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for RetType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for RetType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RetType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ReturnExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RETURN_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ReturnExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ReturnExpr {}
impl PartialEq for ReturnExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ReturnExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ReturnExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ReturnExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for ReturnTypeSyntax {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        RETURN_TYPE_SYNTAX
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_TYPE_SYNTAX }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for ReturnTypeSyntax {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ReturnTypeSyntax {}
impl PartialEq for ReturnTypeSyntax {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for ReturnTypeSyntax {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for ReturnTypeSyntax {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ReturnTypeSyntax").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for SelfParam {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        SELF_PARAM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for SelfParam {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for SelfParam {}
impl PartialEq for SelfParam {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for SelfParam {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for SelfParam {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SelfParam").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for SlicePat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        SLICE_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for SlicePat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for SlicePat {}
impl PartialEq for SlicePat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for SlicePat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for SlicePat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SlicePat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for SliceType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        SLICE_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for SliceType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for SliceType {}
impl PartialEq for SliceType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for SliceType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for SliceType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SliceType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for SourceFile {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        SOURCE_FILE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for SourceFile {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for SourceFile {}
impl PartialEq for SourceFile {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for SourceFile {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for SourceFile {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SourceFile").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Static {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        STATIC
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Static {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Static {}
impl PartialEq for Static {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Static {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Static {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Static").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for StmtList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        STMT_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for StmtList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for StmtList {}
impl PartialEq for StmtList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for StmtList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for StmtList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("StmtList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Struct {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        STRUCT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Struct {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Struct {}
impl PartialEq for Struct {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Struct {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Struct {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Struct").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TokenTree {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TOKEN_TREE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TokenTree {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TokenTree {}
impl PartialEq for TokenTree {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TokenTree {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TokenTree {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TokenTree").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Trait {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TRAIT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Trait {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Trait {}
impl PartialEq for Trait {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Trait {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Trait {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Trait").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TryExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TRY_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TryExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TryExpr {}
impl PartialEq for TryExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TryExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TryExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TryExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TupleExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TupleExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TupleExpr {}
impl PartialEq for TupleExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TupleExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TupleExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TupleExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TupleField {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_FIELD
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TupleField {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TupleField {}
impl PartialEq for TupleField {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TupleField {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TupleField {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TupleField").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TupleFieldList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_FIELD_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TupleFieldList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TupleFieldList {}
impl PartialEq for TupleFieldList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TupleFieldList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TupleFieldList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TupleFieldList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TuplePat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TuplePat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TuplePat {}
impl PartialEq for TuplePat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TuplePat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TuplePat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TuplePat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TupleStructPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_STRUCT_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TupleStructPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TupleStructPat {}
impl PartialEq for TupleStructPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TupleStructPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TupleStructPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TupleStructPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TupleType {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TUPLE_TYPE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TupleType {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TupleType {}
impl PartialEq for TupleType {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TupleType {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TupleType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TupleType").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeAlias {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_ALIAS
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeAlias {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeAlias {}
impl PartialEq for TypeAlias {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeAlias {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeAlias {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeAlias").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeAnchor {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_ANCHOR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ANCHOR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeAnchor {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeAnchor {}
impl PartialEq for TypeAnchor {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeAnchor {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeAnchor {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeAnchor").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeArg {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_ARG
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeArg {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeArg {}
impl PartialEq for TypeArg {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeArg {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeArg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeArg").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeBound {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_BOUND
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeBound {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeBound {}
impl PartialEq for TypeBound {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeBound {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeBound {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeBound").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeBoundList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_BOUND_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeBoundList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeBoundList {}
impl PartialEq for TypeBoundList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeBoundList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeBoundList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeBoundList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for TypeParam {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        TYPE_PARAM
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TypeParam {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TypeParam {}
impl PartialEq for TypeParam {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TypeParam {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TypeParam {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("TypeParam").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for UnderscoreExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        UNDERSCORE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for UnderscoreExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for UnderscoreExpr {}
impl PartialEq for UnderscoreExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for UnderscoreExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for UnderscoreExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UnderscoreExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Union {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        UNION
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Union {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Union {}
impl PartialEq for Union {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Union {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Union {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Union").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Use {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        USE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Use {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Use {}
impl PartialEq for Use {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Use {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Use {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Use").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for UseBoundGenericArgs {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        USE_BOUND_GENERIC_ARGS
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_BOUND_GENERIC_ARGS }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for UseBoundGenericArgs {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for UseBoundGenericArgs {}
impl PartialEq for UseBoundGenericArgs {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for UseBoundGenericArgs {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for UseBoundGenericArgs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UseBoundGenericArgs").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for UseTree {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        USE_TREE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for UseTree {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for UseTree {}
impl PartialEq for UseTree {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for UseTree {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for UseTree {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UseTree").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for UseTreeList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        USE_TREE_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for UseTreeList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for UseTreeList {}
impl PartialEq for UseTreeList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for UseTreeList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for UseTreeList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UseTreeList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Variant {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        VARIANT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Variant {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Variant {}
impl PartialEq for Variant {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Variant {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Variant {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Variant").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for VariantList {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        VARIANT_LIST
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for VariantList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for VariantList {}
impl PartialEq for VariantList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for VariantList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for VariantList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("VariantList").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for Visibility {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        VISIBILITY
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for Visibility {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Visibility {}
impl PartialEq for Visibility {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for Visibility {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for Visibility {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Visibility").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for WhereClause {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        WHERE_CLAUSE
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for WhereClause {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for WhereClause {}
impl PartialEq for WhereClause {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for WhereClause {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for WhereClause {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WhereClause").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for WherePred {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        WHERE_PRED
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for WherePred {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for WherePred {}
impl PartialEq for WherePred {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for WherePred {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for WherePred {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WherePred").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for WhileExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        WHILE_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for WhileExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for WhileExpr {}
impl PartialEq for WhileExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for WhileExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for WhileExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WhileExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for WildcardPat {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        WILDCARD_PAT
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for WildcardPat {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for WildcardPat {}
impl PartialEq for WildcardPat {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for WildcardPat {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for WildcardPat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WildcardPat").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for YeetExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        YEET_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for YeetExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for YeetExpr {}
impl PartialEq for YeetExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for YeetExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for YeetExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("YeetExpr").field("syntax", &self.syntax).finish()
    }
}
impl AstNode for YieldExpr {
    #[inline]
    fn kind() -> SyntaxKind
    where
        Self: Sized,
    {
        YIELD_EXPR
    }
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for YieldExpr {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for YieldExpr {}
impl PartialEq for YieldExpr {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for YieldExpr {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for YieldExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("YieldExpr").field("syntax", &self.syntax).finish()
    }
}
impl From<Enum> for Adt {
    #[inline]
    fn from(node: Enum) -> Adt { Adt::Enum(node) }
}
impl From<Struct> for Adt {
    #[inline]
    fn from(node: Struct) -> Adt { Adt::Struct(node) }
}
impl From<Union> for Adt {
    #[inline]
    fn from(node: Union) -> Adt { Adt::Union(node) }
}
impl AstNode for Adt {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | STRUCT | UNION) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ENUM => Adt::Enum(Enum { syntax }),
            STRUCT => Adt::Struct(Struct { syntax }),
            UNION => Adt::Union(Union { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            Adt::Enum(it) => &it.syntax,
            Adt::Struct(it) => &it.syntax,
            Adt::Union(it) => &it.syntax,
        }
    }
}
impl From<AsmConst> for AsmOperand {
    #[inline]
    fn from(node: AsmConst) -> AsmOperand { AsmOperand::AsmConst(node) }
}
impl From<AsmLabel> for AsmOperand {
    #[inline]
    fn from(node: AsmLabel) -> AsmOperand { AsmOperand::AsmLabel(node) }
}
impl From<AsmRegOperand> for AsmOperand {
    #[inline]
    fn from(node: AsmRegOperand) -> AsmOperand { AsmOperand::AsmRegOperand(node) }
}
impl From<AsmSym> for AsmOperand {
    #[inline]
    fn from(node: AsmSym) -> AsmOperand { AsmOperand::AsmSym(node) }
}
impl AstNode for AsmOperand {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, ASM_CONST | ASM_LABEL | ASM_REG_OPERAND | ASM_SYM)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ASM_CONST => AsmOperand::AsmConst(AsmConst { syntax }),
            ASM_LABEL => AsmOperand::AsmLabel(AsmLabel { syntax }),
            ASM_REG_OPERAND => AsmOperand::AsmRegOperand(AsmRegOperand { syntax }),
            ASM_SYM => AsmOperand::AsmSym(AsmSym { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            AsmOperand::AsmConst(it) => &it.syntax,
            AsmOperand::AsmLabel(it) => &it.syntax,
            AsmOperand::AsmRegOperand(it) => &it.syntax,
            AsmOperand::AsmSym(it) => &it.syntax,
        }
    }
}
impl From<AsmClobberAbi> for AsmPiece {
    #[inline]
    fn from(node: AsmClobberAbi) -> AsmPiece { AsmPiece::AsmClobberAbi(node) }
}
impl From<AsmOperandNamed> for AsmPiece {
    #[inline]
    fn from(node: AsmOperandNamed) -> AsmPiece { AsmPiece::AsmOperandNamed(node) }
}
impl From<AsmOptions> for AsmPiece {
    #[inline]
    fn from(node: AsmOptions) -> AsmPiece { AsmPiece::AsmOptions(node) }
}
impl AstNode for AsmPiece {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, ASM_CLOBBER_ABI | ASM_OPERAND_NAMED | ASM_OPTIONS)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ASM_CLOBBER_ABI => AsmPiece::AsmClobberAbi(AsmClobberAbi { syntax }),
            ASM_OPERAND_NAMED => AsmPiece::AsmOperandNamed(AsmOperandNamed { syntax }),
            ASM_OPTIONS => AsmPiece::AsmOptions(AsmOptions { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            AsmPiece::AsmClobberAbi(it) => &it.syntax,
            AsmPiece::AsmOperandNamed(it) => &it.syntax,
            AsmPiece::AsmOptions(it) => &it.syntax,
        }
    }
}
impl From<Const> for AssocItem {
    #[inline]
    fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
}
impl From<Fn> for AssocItem {
    #[inline]
    fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
}
impl From<MacroCall> for AssocItem {
    #[inline]
    fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
}
impl From<TypeAlias> for AssocItem {
    #[inline]
    fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
}
impl AstNode for AssocItem {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST | FN | MACRO_CALL | TYPE_ALIAS) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            CONST => AssocItem::Const(Const { syntax }),
            FN => AssocItem::Fn(Fn { syntax }),
            MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
            TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            AssocItem::Const(it) => &it.syntax,
            AssocItem::Fn(it) => &it.syntax,
            AssocItem::MacroCall(it) => &it.syntax,
            AssocItem::TypeAlias(it) => &it.syntax,
        }
    }
}
impl From<ArrayExpr> for Expr {
    #[inline]
    fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
}
impl From<AsmExpr> for Expr {
    #[inline]
    fn from(node: AsmExpr) -> Expr { Expr::AsmExpr(node) }
}
impl From<AwaitExpr> for Expr {
    #[inline]
    fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
}
impl From<BecomeExpr> for Expr {
    #[inline]
    fn from(node: BecomeExpr) -> Expr { Expr::BecomeExpr(node) }
}
impl From<BinExpr> for Expr {
    #[inline]
    fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
}
impl From<BlockExpr> for Expr {
    #[inline]
    fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
}
impl From<BreakExpr> for Expr {
    #[inline]
    fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
}
impl From<CallExpr> for Expr {
    #[inline]
    fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
}
impl From<CastExpr> for Expr {
    #[inline]
    fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
}
impl From<ClosureExpr> for Expr {
    #[inline]
    fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
}
impl From<ContinueExpr> for Expr {
    #[inline]
    fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
}
impl From<FieldExpr> for Expr {
    #[inline]
    fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
}
impl From<ForExpr> for Expr {
    #[inline]
    fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
}
impl From<FormatArgsExpr> for Expr {
    #[inline]
    fn from(node: FormatArgsExpr) -> Expr { Expr::FormatArgsExpr(node) }
}
impl From<IfExpr> for Expr {
    #[inline]
    fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
}
impl From<IndexExpr> for Expr {
    #[inline]
    fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
}
impl From<LetExpr> for Expr {
    #[inline]
    fn from(node: LetExpr) -> Expr { Expr::LetExpr(node) }
}
impl From<Literal> for Expr {
    #[inline]
    fn from(node: Literal) -> Expr { Expr::Literal(node) }
}
impl From<LoopExpr> for Expr {
    #[inline]
    fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
}
impl From<MacroExpr> for Expr {
    #[inline]
    fn from(node: MacroExpr) -> Expr { Expr::MacroExpr(node) }
}
impl From<MatchExpr> for Expr {
    #[inline]
    fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
}
impl From<MethodCallExpr> for Expr {
    #[inline]
    fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
}
impl From<OffsetOfExpr> for Expr {
    #[inline]
    fn from(node: OffsetOfExpr) -> Expr { Expr::OffsetOfExpr(node) }
}
impl From<ParenExpr> for Expr {
    #[inline]
    fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
}
impl From<PathExpr> for Expr {
    #[inline]
    fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
}
impl From<PrefixExpr> for Expr {
    #[inline]
    fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
}
impl From<RangeExpr> for Expr {
    #[inline]
    fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
}
impl From<RecordExpr> for Expr {
    #[inline]
    fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
}
impl From<RefExpr> for Expr {
    #[inline]
    fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
}
impl From<ReturnExpr> for Expr {
    #[inline]
    fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
}
impl From<TryExpr> for Expr {
    #[inline]
    fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
}
impl From<TupleExpr> for Expr {
    #[inline]
    fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
}
impl From<UnderscoreExpr> for Expr {
    #[inline]
    fn from(node: UnderscoreExpr) -> Expr { Expr::UnderscoreExpr(node) }
}
impl From<WhileExpr> for Expr {
    #[inline]
    fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
}
impl From<YeetExpr> for Expr {
    #[inline]
    fn from(node: YeetExpr) -> Expr { Expr::YeetExpr(node) }
}
impl From<YieldExpr> for Expr {
    #[inline]
    fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) }
}
impl AstNode for Expr {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ARRAY_EXPR
                | ASM_EXPR
                | AWAIT_EXPR
                | BECOME_EXPR
                | BIN_EXPR
                | BLOCK_EXPR
                | BREAK_EXPR
                | CALL_EXPR
                | CAST_EXPR
                | CLOSURE_EXPR
                | CONTINUE_EXPR
                | FIELD_EXPR
                | FOR_EXPR
                | FORMAT_ARGS_EXPR
                | IF_EXPR
                | INDEX_EXPR
                | LET_EXPR
                | LITERAL
                | LOOP_EXPR
                | MACRO_EXPR
                | MATCH_EXPR
                | METHOD_CALL_EXPR
                | OFFSET_OF_EXPR
                | PAREN_EXPR
                | PATH_EXPR
                | PREFIX_EXPR
                | RANGE_EXPR
                | RECORD_EXPR
                | REF_EXPR
                | RETURN_EXPR
                | TRY_EXPR
                | TUPLE_EXPR
                | UNDERSCORE_EXPR
                | WHILE_EXPR
                | YEET_EXPR
                | YIELD_EXPR
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
            ASM_EXPR => Expr::AsmExpr(AsmExpr { syntax }),
            AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
            BECOME_EXPR => Expr::BecomeExpr(BecomeExpr { syntax }),
            BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
            BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
            BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
            CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
            CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
            CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
            CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
            FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
            FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
            FORMAT_ARGS_EXPR => Expr::FormatArgsExpr(FormatArgsExpr { syntax }),
            IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
            INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
            LET_EXPR => Expr::LetExpr(LetExpr { syntax }),
            LITERAL => Expr::Literal(Literal { syntax }),
            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
            MACRO_EXPR => Expr::MacroExpr(MacroExpr { syntax }),
            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
            OFFSET_OF_EXPR => Expr::OffsetOfExpr(OffsetOfExpr { syntax }),
            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
            PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
            PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
            RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
            RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
            REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
            RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
            TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
            TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
            UNDERSCORE_EXPR => Expr::UnderscoreExpr(UnderscoreExpr { syntax }),
            WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
            YEET_EXPR => Expr::YeetExpr(YeetExpr { syntax }),
            YIELD_EXPR => Expr::YieldExpr(YieldExpr { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            Expr::ArrayExpr(it) => &it.syntax,
            Expr::AsmExpr(it) => &it.syntax,
            Expr::AwaitExpr(it) => &it.syntax,
            Expr::BecomeExpr(it) => &it.syntax,
            Expr::BinExpr(it) => &it.syntax,
            Expr::BlockExpr(it) => &it.syntax,
            Expr::BreakExpr(it) => &it.syntax,
            Expr::CallExpr(it) => &it.syntax,
            Expr::CastExpr(it) => &it.syntax,
            Expr::ClosureExpr(it) => &it.syntax,
            Expr::ContinueExpr(it) => &it.syntax,
            Expr::FieldExpr(it) => &it.syntax,
            Expr::ForExpr(it) => &it.syntax,
            Expr::FormatArgsExpr(it) => &it.syntax,
            Expr::IfExpr(it) => &it.syntax,
            Expr::IndexExpr(it) => &it.syntax,
            Expr::LetExpr(it) => &it.syntax,
            Expr::Literal(it) => &it.syntax,
            Expr::LoopExpr(it) => &it.syntax,
            Expr::MacroExpr(it) => &it.syntax,
            Expr::MatchExpr(it) => &it.syntax,
            Expr::MethodCallExpr(it) => &it.syntax,
            Expr::OffsetOfExpr(it) => &it.syntax,
            Expr::ParenExpr(it) => &it.syntax,
            Expr::PathExpr(it) => &it.syntax,
            Expr::PrefixExpr(it) => &it.syntax,
            Expr::RangeExpr(it) => &it.syntax,
            Expr::RecordExpr(it) => &it.syntax,
            Expr::RefExpr(it) => &it.syntax,
            Expr::ReturnExpr(it) => &it.syntax,
            Expr::TryExpr(it) => &it.syntax,
            Expr::TupleExpr(it) => &it.syntax,
            Expr::UnderscoreExpr(it) => &it.syntax,
            Expr::WhileExpr(it) => &it.syntax,
            Expr::YeetExpr(it) => &it.syntax,
            Expr::YieldExpr(it) => &it.syntax,
        }
    }
}
impl From<Fn> for ExternItem {
    #[inline]
    fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
}
impl From<MacroCall> for ExternItem {
    #[inline]
    fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
}
impl From<Static> for ExternItem {
    #[inline]
    fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
}
impl From<TypeAlias> for ExternItem {
    #[inline]
    fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) }
}
impl AstNode for ExternItem {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FN | MACRO_CALL | STATIC | TYPE_ALIAS) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            FN => ExternItem::Fn(Fn { syntax }),
            MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
            STATIC => ExternItem::Static(Static { syntax }),
            TYPE_ALIAS => ExternItem::TypeAlias(TypeAlias { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            ExternItem::Fn(it) => &it.syntax,
            ExternItem::MacroCall(it) => &it.syntax,
            ExternItem::Static(it) => &it.syntax,
            ExternItem::TypeAlias(it) => &it.syntax,
        }
    }
}
impl From<RecordFieldList> for FieldList {
    #[inline]
    fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
}
impl From<TupleFieldList> for FieldList {
    #[inline]
    fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
}
impl AstNode for FieldList {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, RECORD_FIELD_LIST | TUPLE_FIELD_LIST) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
            TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            FieldList::RecordFieldList(it) => &it.syntax,
            FieldList::TupleFieldList(it) => &it.syntax,
        }
    }
}
impl From<AssocTypeArg> for GenericArg {
    #[inline]
    fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
}
impl From<ConstArg> for GenericArg {
    #[inline]
    fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
}
impl From<LifetimeArg> for GenericArg {
    #[inline]
    fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
}
impl From<TypeArg> for GenericArg {
    #[inline]
    fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
}
impl AstNode for GenericArg {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, ASSOC_TYPE_ARG | CONST_ARG | LIFETIME_ARG | TYPE_ARG)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
            CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
            LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
            TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            GenericArg::AssocTypeArg(it) => &it.syntax,
            GenericArg::ConstArg(it) => &it.syntax,
            GenericArg::LifetimeArg(it) => &it.syntax,
            GenericArg::TypeArg(it) => &it.syntax,
        }
    }
}
impl From<ConstParam> for GenericParam {
    #[inline]
    fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
}
impl From<LifetimeParam> for GenericParam {
    #[inline]
    fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
}
impl From<TypeParam> for GenericParam {
    #[inline]
    fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
}
impl AstNode for GenericParam {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
            LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
            TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            GenericParam::ConstParam(it) => &it.syntax,
            GenericParam::LifetimeParam(it) => &it.syntax,
            GenericParam::TypeParam(it) => &it.syntax,
        }
    }
}
impl From<AsmExpr> for Item {
    #[inline]
    fn from(node: AsmExpr) -> Item { Item::AsmExpr(node) }
}
impl From<Const> for Item {
    #[inline]
    fn from(node: Const) -> Item { Item::Const(node) }
}
impl From<Enum> for Item {
    #[inline]
    fn from(node: Enum) -> Item { Item::Enum(node) }
}
impl From<ExternBlock> for Item {
    #[inline]
    fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
}
impl From<ExternCrate> for Item {
    #[inline]
    fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
}
impl From<Fn> for Item {
    #[inline]
    fn from(node: Fn) -> Item { Item::Fn(node) }
}
impl From<Impl> for Item {
    #[inline]
    fn from(node: Impl) -> Item { Item::Impl(node) }
}
impl From<MacroCall> for Item {
    #[inline]
    fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
}
impl From<MacroDef> for Item {
    #[inline]
    fn from(node: MacroDef) -> Item { Item::MacroDef(node) }
}
impl From<MacroRules> for Item {
    #[inline]
    fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
}
impl From<Module> for Item {
    #[inline]
    fn from(node: Module) -> Item { Item::Module(node) }
}
impl From<Static> for Item {
    #[inline]
    fn from(node: Static) -> Item { Item::Static(node) }
}
impl From<Struct> for Item {
    #[inline]
    fn from(node: Struct) -> Item { Item::Struct(node) }
}
impl From<Trait> for Item {
    #[inline]
    fn from(node: Trait) -> Item { Item::Trait(node) }
}
impl From<TypeAlias> for Item {
    #[inline]
    fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
}
impl From<Union> for Item {
    #[inline]
    fn from(node: Union) -> Item { Item::Union(node) }
}
impl From<Use> for Item {
    #[inline]
    fn from(node: Use) -> Item { Item::Use(node) }
}
impl AstNode for Item {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ASM_EXPR
                | CONST
                | ENUM
                | EXTERN_BLOCK
                | EXTERN_CRATE
                | FN
                | IMPL
                | MACRO_CALL
                | MACRO_DEF
                | MACRO_RULES
                | MODULE
                | STATIC
                | STRUCT
                | TRAIT
                | TYPE_ALIAS
                | UNION
                | USE
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ASM_EXPR => Item::AsmExpr(AsmExpr { syntax }),
            CONST => Item::Const(Const { syntax }),
            ENUM => Item::Enum(Enum { syntax }),
            EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
            EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
            FN => Item::Fn(Fn { syntax }),
            IMPL => Item::Impl(Impl { syntax }),
            MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
            MACRO_DEF => Item::MacroDef(MacroDef { syntax }),
            MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
            MODULE => Item::Module(Module { syntax }),
            STATIC => Item::Static(Static { syntax }),
            STRUCT => Item::Struct(Struct { syntax }),
            TRAIT => Item::Trait(Trait { syntax }),
            TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
            UNION => Item::Union(Union { syntax }),
            USE => Item::Use(Use { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            Item::AsmExpr(it) => &it.syntax,
            Item::Const(it) => &it.syntax,
            Item::Enum(it) => &it.syntax,
            Item::ExternBlock(it) => &it.syntax,
            Item::ExternCrate(it) => &it.syntax,
            Item::Fn(it) => &it.syntax,
            Item::Impl(it) => &it.syntax,
            Item::MacroCall(it) => &it.syntax,
            Item::MacroDef(it) => &it.syntax,
            Item::MacroRules(it) => &it.syntax,
            Item::Module(it) => &it.syntax,
            Item::Static(it) => &it.syntax,
            Item::Struct(it) => &it.syntax,
            Item::Trait(it) => &it.syntax,
            Item::TypeAlias(it) => &it.syntax,
            Item::Union(it) => &it.syntax,
            Item::Use(it) => &it.syntax,
        }
    }
}
impl From<BoxPat> for Pat {
    #[inline]
    fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
}
impl From<ConstBlockPat> for Pat {
    #[inline]
    fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
}
impl From<IdentPat> for Pat {
    #[inline]
    fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
}
impl From<LiteralPat> for Pat {
    #[inline]
    fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
}
impl From<MacroPat> for Pat {
    #[inline]
    fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
}
impl From<OrPat> for Pat {
    #[inline]
    fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
}
impl From<ParenPat> for Pat {
    #[inline]
    fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
}
impl From<PathPat> for Pat {
    #[inline]
    fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
}
impl From<RangePat> for Pat {
    #[inline]
    fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
}
impl From<RecordPat> for Pat {
    #[inline]
    fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
}
impl From<RefPat> for Pat {
    #[inline]
    fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
}
impl From<RestPat> for Pat {
    #[inline]
    fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
}
impl From<SlicePat> for Pat {
    #[inline]
    fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
}
impl From<TuplePat> for Pat {
    #[inline]
    fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
}
impl From<TupleStructPat> for Pat {
    #[inline]
    fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
}
impl From<WildcardPat> for Pat {
    #[inline]
    fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
}
impl AstNode for Pat {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            BOX_PAT
                | CONST_BLOCK_PAT
                | IDENT_PAT
                | LITERAL_PAT
                | MACRO_PAT
                | OR_PAT
                | PAREN_PAT
                | PATH_PAT
                | RANGE_PAT
                | RECORD_PAT
                | REF_PAT
                | REST_PAT
                | SLICE_PAT
                | TUPLE_PAT
                | TUPLE_STRUCT_PAT
                | WILDCARD_PAT
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
            CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
            IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
            LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
            MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
            OR_PAT => Pat::OrPat(OrPat { syntax }),
            PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
            PATH_PAT => Pat::PathPat(PathPat { syntax }),
            RANGE_PAT => Pat::RangePat(RangePat { syntax }),
            RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
            REF_PAT => Pat::RefPat(RefPat { syntax }),
            REST_PAT => Pat::RestPat(RestPat { syntax }),
            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
            WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            Pat::BoxPat(it) => &it.syntax,
            Pat::ConstBlockPat(it) => &it.syntax,
            Pat::IdentPat(it) => &it.syntax,
            Pat::LiteralPat(it) => &it.syntax,
            Pat::MacroPat(it) => &it.syntax,
            Pat::OrPat(it) => &it.syntax,
            Pat::ParenPat(it) => &it.syntax,
            Pat::PathPat(it) => &it.syntax,
            Pat::RangePat(it) => &it.syntax,
            Pat::RecordPat(it) => &it.syntax,
            Pat::RefPat(it) => &it.syntax,
            Pat::RestPat(it) => &it.syntax,
            Pat::SlicePat(it) => &it.syntax,
            Pat::TuplePat(it) => &it.syntax,
            Pat::TupleStructPat(it) => &it.syntax,
            Pat::WildcardPat(it) => &it.syntax,
        }
    }
}
impl From<ExprStmt> for Stmt {
    #[inline]
    fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
}
impl From<Item> for Stmt {
    #[inline]
    fn from(node: Item) -> Stmt { Stmt::Item(node) }
}
impl From<LetStmt> for Stmt {
    #[inline]
    fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
}
impl From<ArrayType> for Type {
    #[inline]
    fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
}
impl From<DynTraitType> for Type {
    #[inline]
    fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
}
impl From<FnPtrType> for Type {
    #[inline]
    fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
}
impl From<ForType> for Type {
    #[inline]
    fn from(node: ForType) -> Type { Type::ForType(node) }
}
impl From<ImplTraitType> for Type {
    #[inline]
    fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
}
impl From<InferType> for Type {
    #[inline]
    fn from(node: InferType) -> Type { Type::InferType(node) }
}
impl From<MacroType> for Type {
    #[inline]
    fn from(node: MacroType) -> Type { Type::MacroType(node) }
}
impl From<NeverType> for Type {
    #[inline]
    fn from(node: NeverType) -> Type { Type::NeverType(node) }
}
impl From<ParenType> for Type {
    #[inline]
    fn from(node: ParenType) -> Type { Type::ParenType(node) }
}
impl From<PathType> for Type {
    #[inline]
    fn from(node: PathType) -> Type { Type::PathType(node) }
}
impl From<PtrType> for Type {
    #[inline]
    fn from(node: PtrType) -> Type { Type::PtrType(node) }
}
impl From<RefType> for Type {
    #[inline]
    fn from(node: RefType) -> Type { Type::RefType(node) }
}
impl From<SliceType> for Type {
    #[inline]
    fn from(node: SliceType) -> Type { Type::SliceType(node) }
}
impl From<TupleType> for Type {
    #[inline]
    fn from(node: TupleType) -> Type { Type::TupleType(node) }
}
impl AstNode for Type {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ARRAY_TYPE
                | DYN_TRAIT_TYPE
                | FN_PTR_TYPE
                | FOR_TYPE
                | IMPL_TRAIT_TYPE
                | INFER_TYPE
                | MACRO_TYPE
                | NEVER_TYPE
                | PAREN_TYPE
                | PATH_TYPE
                | PTR_TYPE
                | REF_TYPE
                | SLICE_TYPE
                | TUPLE_TYPE
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
            DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
            FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
            FOR_TYPE => Type::ForType(ForType { syntax }),
            IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
            INFER_TYPE => Type::InferType(InferType { syntax }),
            MACRO_TYPE => Type::MacroType(MacroType { syntax }),
            NEVER_TYPE => Type::NeverType(NeverType { syntax }),
            PAREN_TYPE => Type::ParenType(ParenType { syntax }),
            PATH_TYPE => Type::PathType(PathType { syntax }),
            PTR_TYPE => Type::PtrType(PtrType { syntax }),
            REF_TYPE => Type::RefType(RefType { syntax }),
            SLICE_TYPE => Type::SliceType(SliceType { syntax }),
            TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            Type::ArrayType(it) => &it.syntax,
            Type::DynTraitType(it) => &it.syntax,
            Type::FnPtrType(it) => &it.syntax,
            Type::ForType(it) => &it.syntax,
            Type::ImplTraitType(it) => &it.syntax,
            Type::InferType(it) => &it.syntax,
            Type::MacroType(it) => &it.syntax,
            Type::NeverType(it) => &it.syntax,
            Type::ParenType(it) => &it.syntax,
            Type::PathType(it) => &it.syntax,
            Type::PtrType(it) => &it.syntax,
            Type::RefType(it) => &it.syntax,
            Type::SliceType(it) => &it.syntax,
            Type::TupleType(it) => &it.syntax,
        }
    }
}
impl From<Lifetime> for UseBoundGenericArg {
    #[inline]
    fn from(node: Lifetime) -> UseBoundGenericArg { UseBoundGenericArg::Lifetime(node) }
}
impl From<NameRef> for UseBoundGenericArg {
    #[inline]
    fn from(node: NameRef) -> UseBoundGenericArg { UseBoundGenericArg::NameRef(node) }
}
impl AstNode for UseBoundGenericArg {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, LIFETIME | NAME_REF) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            LIFETIME => UseBoundGenericArg::Lifetime(Lifetime { syntax }),
            NAME_REF => UseBoundGenericArg::NameRef(NameRef { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            UseBoundGenericArg::Lifetime(it) => &it.syntax,
            UseBoundGenericArg::NameRef(it) => &it.syntax,
        }
    }
}
impl From<Struct> for VariantDef {
    #[inline]
    fn from(node: Struct) -> VariantDef { VariantDef::Struct(node) }
}
impl From<Union> for VariantDef {
    #[inline]
    fn from(node: Union) -> VariantDef { VariantDef::Union(node) }
}
impl From<Variant> for VariantDef {
    #[inline]
    fn from(node: Variant) -> VariantDef { VariantDef::Variant(node) }
}
impl AstNode for VariantDef {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, STRUCT | UNION | VARIANT) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
            STRUCT => VariantDef::Struct(Struct { syntax }),
            UNION => VariantDef::Union(Union { syntax }),
            VARIANT => VariantDef::Variant(Variant { syntax }),
            _ => return None,
        };
        Some(res)
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode {
        match self {
            VariantDef::Struct(it) => &it.syntax,
            VariantDef::Union(it) => &it.syntax,
            VariantDef::Variant(it) => &it.syntax,
        }
    }
}
impl ast::HasArgList for AnyHasArgList {}
impl AstNode for AnyHasArgList {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CALL_EXPR | METHOD_CALL_EXPR) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasArgList { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasArgList {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasArgList {}
impl PartialEq for AnyHasArgList {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasArgList {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasArgList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasArgList").field("syntax", &self.syntax).finish()
    }
}
impl From<CallExpr> for AnyHasArgList {
    #[inline]
    fn from(node: CallExpr) -> AnyHasArgList { AnyHasArgList { syntax: node.syntax } }
}
impl From<MethodCallExpr> for AnyHasArgList {
    #[inline]
    fn from(node: MethodCallExpr) -> AnyHasArgList { AnyHasArgList { syntax: node.syntax } }
}
impl ast::HasAttrs for AnyHasAttrs {}
impl AstNode for AnyHasAttrs {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ARRAY_EXPR
                | ASM_EXPR
                | ASSOC_ITEM_LIST
                | AWAIT_EXPR
                | BECOME_EXPR
                | BIN_EXPR
                | BLOCK_EXPR
                | BREAK_EXPR
                | CALL_EXPR
                | CAST_EXPR
                | CLOSURE_EXPR
                | CONST
                | CONST_PARAM
                | CONTINUE_EXPR
                | ENUM
                | EXTERN_BLOCK
                | EXTERN_CRATE
                | EXTERN_ITEM_LIST
                | FIELD_EXPR
                | FN
                | FOR_EXPR
                | FORMAT_ARGS_EXPR
                | IDENT_PAT
                | IF_EXPR
                | IMPL
                | INDEX_EXPR
                | ITEM_LIST
                | LET_EXPR
                | LET_STMT
                | LIFETIME_PARAM
                | LITERAL
                | LOOP_EXPR
                | MACRO_CALL
                | MACRO_DEF
                | MACRO_RULES
                | MATCH_ARM
                | MATCH_ARM_LIST
                | MATCH_EXPR
                | METHOD_CALL_EXPR
                | MODULE
                | OFFSET_OF_EXPR
                | PARAM
                | PAREN_EXPR
                | PATH_EXPR
                | PREFIX_EXPR
                | RANGE_EXPR
                | RECORD_EXPR_FIELD
                | RECORD_EXPR_FIELD_LIST
                | RECORD_FIELD
                | RECORD_PAT_FIELD
                | REF_EXPR
                | REST_PAT
                | RETURN_EXPR
                | SELF_PARAM
                | SOURCE_FILE
                | STATIC
                | STMT_LIST
                | STRUCT
                | TRAIT
                | TRY_EXPR
                | TUPLE_EXPR
                | TUPLE_FIELD
                | TYPE_ALIAS
                | TYPE_PARAM
                | UNDERSCORE_EXPR
                | UNION
                | USE
                | VARIANT
                | WHILE_EXPR
                | YEET_EXPR
                | YIELD_EXPR
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasAttrs { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasAttrs {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasAttrs {}
impl PartialEq for AnyHasAttrs {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasAttrs {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasAttrs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasAttrs").field("syntax", &self.syntax).finish()
    }
}
impl From<ArrayExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ArrayExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<AsmExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: AsmExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<AssocItemList> for AnyHasAttrs {
    #[inline]
    fn from(node: AssocItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<AwaitExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: AwaitExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<BecomeExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: BecomeExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<BinExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: BinExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<BlockExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: BlockExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<BreakExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: BreakExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<CallExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: CallExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<CastExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: CastExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ClosureExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ClosureExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Const> for AnyHasAttrs {
    #[inline]
    fn from(node: Const) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ConstParam> for AnyHasAttrs {
    #[inline]
    fn from(node: ConstParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ContinueExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ContinueExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Enum> for AnyHasAttrs {
    #[inline]
    fn from(node: Enum) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ExternBlock> for AnyHasAttrs {
    #[inline]
    fn from(node: ExternBlock) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ExternCrate> for AnyHasAttrs {
    #[inline]
    fn from(node: ExternCrate) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ExternItemList> for AnyHasAttrs {
    #[inline]
    fn from(node: ExternItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<FieldExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: FieldExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Fn> for AnyHasAttrs {
    #[inline]
    fn from(node: Fn) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ForExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ForExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<FormatArgsExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: FormatArgsExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<IdentPat> for AnyHasAttrs {
    #[inline]
    fn from(node: IdentPat) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<IfExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: IfExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Impl> for AnyHasAttrs {
    #[inline]
    fn from(node: Impl) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<IndexExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: IndexExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ItemList> for AnyHasAttrs {
    #[inline]
    fn from(node: ItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<LetExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: LetExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<LetStmt> for AnyHasAttrs {
    #[inline]
    fn from(node: LetStmt) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<LifetimeParam> for AnyHasAttrs {
    #[inline]
    fn from(node: LifetimeParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Literal> for AnyHasAttrs {
    #[inline]
    fn from(node: Literal) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<LoopExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: LoopExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MacroCall> for AnyHasAttrs {
    #[inline]
    fn from(node: MacroCall) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MacroDef> for AnyHasAttrs {
    #[inline]
    fn from(node: MacroDef) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MacroRules> for AnyHasAttrs {
    #[inline]
    fn from(node: MacroRules) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MatchArm> for AnyHasAttrs {
    #[inline]
    fn from(node: MatchArm) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MatchArmList> for AnyHasAttrs {
    #[inline]
    fn from(node: MatchArmList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MatchExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: MatchExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<MethodCallExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: MethodCallExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Module> for AnyHasAttrs {
    #[inline]
    fn from(node: Module) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<OffsetOfExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: OffsetOfExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Param> for AnyHasAttrs {
    #[inline]
    fn from(node: Param) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ParenExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ParenExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<PathExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: PathExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<PrefixExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: PrefixExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RangeExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: RangeExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RecordExprField> for AnyHasAttrs {
    #[inline]
    fn from(node: RecordExprField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RecordExprFieldList> for AnyHasAttrs {
    #[inline]
    fn from(node: RecordExprFieldList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RecordField> for AnyHasAttrs {
    #[inline]
    fn from(node: RecordField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RecordPatField> for AnyHasAttrs {
    #[inline]
    fn from(node: RecordPatField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RefExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: RefExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<RestPat> for AnyHasAttrs {
    #[inline]
    fn from(node: RestPat) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<ReturnExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: ReturnExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<SelfParam> for AnyHasAttrs {
    #[inline]
    fn from(node: SelfParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<SourceFile> for AnyHasAttrs {
    #[inline]
    fn from(node: SourceFile) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Static> for AnyHasAttrs {
    #[inline]
    fn from(node: Static) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<StmtList> for AnyHasAttrs {
    #[inline]
    fn from(node: StmtList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Struct> for AnyHasAttrs {
    #[inline]
    fn from(node: Struct) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Trait> for AnyHasAttrs {
    #[inline]
    fn from(node: Trait) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TryExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: TryExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TupleExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: TupleExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TupleField> for AnyHasAttrs {
    #[inline]
    fn from(node: TupleField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasAttrs {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TypeParam> for AnyHasAttrs {
    #[inline]
    fn from(node: TypeParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<UnderscoreExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: UnderscoreExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Union> for AnyHasAttrs {
    #[inline]
    fn from(node: Union) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Use> for AnyHasAttrs {
    #[inline]
    fn from(node: Use) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<Variant> for AnyHasAttrs {
    #[inline]
    fn from(node: Variant) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<WhileExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: WhileExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<YeetExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: YeetExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<YieldExpr> for AnyHasAttrs {
    #[inline]
    fn from(node: YieldExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl ast::HasDocComments for AnyHasDocComments {}
impl AstNode for AnyHasDocComments {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            CONST
                | ENUM
                | EXTERN_BLOCK
                | EXTERN_CRATE
                | FN
                | IMPL
                | MACRO_CALL
                | MACRO_DEF
                | MACRO_RULES
                | MODULE
                | RECORD_FIELD
                | SOURCE_FILE
                | STATIC
                | STRUCT
                | TRAIT
                | TUPLE_FIELD
                | TYPE_ALIAS
                | UNION
                | USE
                | VARIANT
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasDocComments { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasDocComments {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasDocComments {}
impl PartialEq for AnyHasDocComments {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasDocComments {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasDocComments {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasDocComments").field("syntax", &self.syntax).finish()
    }
}
impl From<Const> for AnyHasDocComments {
    #[inline]
    fn from(node: Const) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Enum> for AnyHasDocComments {
    #[inline]
    fn from(node: Enum) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<ExternBlock> for AnyHasDocComments {
    #[inline]
    fn from(node: ExternBlock) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<ExternCrate> for AnyHasDocComments {
    #[inline]
    fn from(node: ExternCrate) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Fn> for AnyHasDocComments {
    #[inline]
    fn from(node: Fn) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Impl> for AnyHasDocComments {
    #[inline]
    fn from(node: Impl) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<MacroCall> for AnyHasDocComments {
    #[inline]
    fn from(node: MacroCall) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<MacroDef> for AnyHasDocComments {
    #[inline]
    fn from(node: MacroDef) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<MacroRules> for AnyHasDocComments {
    #[inline]
    fn from(node: MacroRules) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Module> for AnyHasDocComments {
    #[inline]
    fn from(node: Module) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<RecordField> for AnyHasDocComments {
    #[inline]
    fn from(node: RecordField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<SourceFile> for AnyHasDocComments {
    #[inline]
    fn from(node: SourceFile) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Static> for AnyHasDocComments {
    #[inline]
    fn from(node: Static) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Struct> for AnyHasDocComments {
    #[inline]
    fn from(node: Struct) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Trait> for AnyHasDocComments {
    #[inline]
    fn from(node: Trait) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<TupleField> for AnyHasDocComments {
    #[inline]
    fn from(node: TupleField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasDocComments {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Union> for AnyHasDocComments {
    #[inline]
    fn from(node: Union) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Use> for AnyHasDocComments {
    #[inline]
    fn from(node: Use) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<Variant> for AnyHasDocComments {
    #[inline]
    fn from(node: Variant) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl ast::HasGenericArgs for AnyHasGenericArgs {}
impl AstNode for AnyHasGenericArgs {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, ASSOC_TYPE_ARG | METHOD_CALL_EXPR | PATH_SEGMENT)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasGenericArgs { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasGenericArgs {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasGenericArgs {}
impl PartialEq for AnyHasGenericArgs {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasGenericArgs {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasGenericArgs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasGenericArgs").field("syntax", &self.syntax).finish()
    }
}
impl From<AssocTypeArg> for AnyHasGenericArgs {
    #[inline]
    fn from(node: AssocTypeArg) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
}
impl From<MethodCallExpr> for AnyHasGenericArgs {
    #[inline]
    fn from(node: MethodCallExpr) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
}
impl From<PathSegment> for AnyHasGenericArgs {
    #[inline]
    fn from(node: PathSegment) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
}
impl ast::HasGenericParams for AnyHasGenericParams {}
impl AstNode for AnyHasGenericParams {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TYPE_ALIAS | UNION)
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasGenericParams { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasGenericParams {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasGenericParams {}
impl PartialEq for AnyHasGenericParams {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasGenericParams {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasGenericParams {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasGenericParams").field("syntax", &self.syntax).finish()
    }
}
impl From<Const> for AnyHasGenericParams {
    #[inline]
    fn from(node: Const) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Enum> for AnyHasGenericParams {
    #[inline]
    fn from(node: Enum) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Fn> for AnyHasGenericParams {
    #[inline]
    fn from(node: Fn) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Impl> for AnyHasGenericParams {
    #[inline]
    fn from(node: Impl) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Struct> for AnyHasGenericParams {
    #[inline]
    fn from(node: Struct) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Trait> for AnyHasGenericParams {
    #[inline]
    fn from(node: Trait) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasGenericParams {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<Union> for AnyHasGenericParams {
    #[inline]
    fn from(node: Union) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl ast::HasLoopBody for AnyHasLoopBody {}
impl AstNode for AnyHasLoopBody {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FOR_EXPR | LOOP_EXPR | WHILE_EXPR) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasLoopBody { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasLoopBody {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasLoopBody {}
impl PartialEq for AnyHasLoopBody {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasLoopBody {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasLoopBody {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasLoopBody").field("syntax", &self.syntax).finish()
    }
}
impl From<ForExpr> for AnyHasLoopBody {
    #[inline]
    fn from(node: ForExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
}
impl From<LoopExpr> for AnyHasLoopBody {
    #[inline]
    fn from(node: LoopExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
}
impl From<WhileExpr> for AnyHasLoopBody {
    #[inline]
    fn from(node: WhileExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
}
impl ast::HasModuleItem for AnyHasModuleItem {}
impl AstNode for AnyHasModuleItem {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ITEM_LIST | MACRO_ITEMS | SOURCE_FILE) }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasModuleItem { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasModuleItem {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasModuleItem {}
impl PartialEq for AnyHasModuleItem {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasModuleItem {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasModuleItem {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasModuleItem").field("syntax", &self.syntax).finish()
    }
}
impl From<ItemList> for AnyHasModuleItem {
    #[inline]
    fn from(node: ItemList) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
}
impl From<MacroItems> for AnyHasModuleItem {
    #[inline]
    fn from(node: MacroItems) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
}
impl From<SourceFile> for AnyHasModuleItem {
    #[inline]
    fn from(node: SourceFile) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
}
impl ast::HasName for AnyHasName {}
impl AstNode for AnyHasName {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ASM_OPERAND_NAMED
                | CONST
                | CONST_PARAM
                | ENUM
                | FN
                | FORMAT_ARGS_ARG
                | IDENT_PAT
                | MACRO_DEF
                | MACRO_RULES
                | MODULE
                | RECORD_FIELD
                | RENAME
                | SELF_PARAM
                | STATIC
                | STRUCT
                | TRAIT
                | TYPE_ALIAS
                | TYPE_PARAM
                | UNION
                | VARIANT
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasName { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasName {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasName {}
impl PartialEq for AnyHasName {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasName {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasName {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasName").field("syntax", &self.syntax).finish()
    }
}
impl From<AsmOperandNamed> for AnyHasName {
    #[inline]
    fn from(node: AsmOperandNamed) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Const> for AnyHasName {
    #[inline]
    fn from(node: Const) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<ConstParam> for AnyHasName {
    #[inline]
    fn from(node: ConstParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Enum> for AnyHasName {
    #[inline]
    fn from(node: Enum) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Fn> for AnyHasName {
    #[inline]
    fn from(node: Fn) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<FormatArgsArg> for AnyHasName {
    #[inline]
    fn from(node: FormatArgsArg) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<IdentPat> for AnyHasName {
    #[inline]
    fn from(node: IdentPat) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<MacroDef> for AnyHasName {
    #[inline]
    fn from(node: MacroDef) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<MacroRules> for AnyHasName {
    #[inline]
    fn from(node: MacroRules) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Module> for AnyHasName {
    #[inline]
    fn from(node: Module) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<RecordField> for AnyHasName {
    #[inline]
    fn from(node: RecordField) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Rename> for AnyHasName {
    #[inline]
    fn from(node: Rename) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<SelfParam> for AnyHasName {
    #[inline]
    fn from(node: SelfParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Static> for AnyHasName {
    #[inline]
    fn from(node: Static) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Struct> for AnyHasName {
    #[inline]
    fn from(node: Struct) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Trait> for AnyHasName {
    #[inline]
    fn from(node: Trait) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasName {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<TypeParam> for AnyHasName {
    #[inline]
    fn from(node: TypeParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Union> for AnyHasName {
    #[inline]
    fn from(node: Union) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<Variant> for AnyHasName {
    #[inline]
    fn from(node: Variant) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl ast::HasTypeBounds for AnyHasTypeBounds {}
impl AstNode for AnyHasTypeBounds {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            ASSOC_TYPE_ARG | LIFETIME_PARAM | TRAIT | TYPE_ALIAS | TYPE_PARAM | WHERE_PRED
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasTypeBounds { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasTypeBounds {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasTypeBounds {}
impl PartialEq for AnyHasTypeBounds {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasTypeBounds {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasTypeBounds {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasTypeBounds").field("syntax", &self.syntax).finish()
    }
}
impl From<AssocTypeArg> for AnyHasTypeBounds {
    #[inline]
    fn from(node: AssocTypeArg) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl From<LifetimeParam> for AnyHasTypeBounds {
    #[inline]
    fn from(node: LifetimeParam) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl From<Trait> for AnyHasTypeBounds {
    #[inline]
    fn from(node: Trait) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasTypeBounds {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl From<TypeParam> for AnyHasTypeBounds {
    #[inline]
    fn from(node: TypeParam) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl From<WherePred> for AnyHasTypeBounds {
    #[inline]
    fn from(node: WherePred) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
}
impl ast::HasVisibility for AnyHasVisibility {}
impl AstNode for AnyHasVisibility {
    #[inline]
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            CONST
                | ENUM
                | EXTERN_CRATE
                | FN
                | IMPL
                | MACRO_DEF
                | MACRO_RULES
                | MODULE
                | RECORD_FIELD
                | STATIC
                | STRUCT
                | TRAIT
                | TUPLE_FIELD
                | TYPE_ALIAS
                | UNION
                | USE
                | VARIANT
        )
    }
    #[inline]
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        Self::can_cast(syntax.kind()).then_some(AnyHasVisibility { syntax })
    }
    #[inline]
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for AnyHasVisibility {
    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for AnyHasVisibility {}
impl PartialEq for AnyHasVisibility {
    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for AnyHasVisibility {
    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for AnyHasVisibility {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AnyHasVisibility").field("syntax", &self.syntax).finish()
    }
}
impl From<Const> for AnyHasVisibility {
    #[inline]
    fn from(node: Const) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Enum> for AnyHasVisibility {
    #[inline]
    fn from(node: Enum) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<ExternCrate> for AnyHasVisibility {
    #[inline]
    fn from(node: ExternCrate) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Fn> for AnyHasVisibility {
    #[inline]
    fn from(node: Fn) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Impl> for AnyHasVisibility {
    #[inline]
    fn from(node: Impl) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<MacroDef> for AnyHasVisibility {
    #[inline]
    fn from(node: MacroDef) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<MacroRules> for AnyHasVisibility {
    #[inline]
    fn from(node: MacroRules) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Module> for AnyHasVisibility {
    #[inline]
    fn from(node: Module) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<RecordField> for AnyHasVisibility {
    #[inline]
    fn from(node: RecordField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Static> for AnyHasVisibility {
    #[inline]
    fn from(node: Static) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Struct> for AnyHasVisibility {
    #[inline]
    fn from(node: Struct) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Trait> for AnyHasVisibility {
    #[inline]
    fn from(node: Trait) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<TupleField> for AnyHasVisibility {
    #[inline]
    fn from(node: TupleField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasVisibility {
    #[inline]
    fn from(node: TypeAlias) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Union> for AnyHasVisibility {
    #[inline]
    fn from(node: Union) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Use> for AnyHasVisibility {
    #[inline]
    fn from(node: Use) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<Variant> for AnyHasVisibility {
    #[inline]
    fn from(node: Variant) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl std::fmt::Display for Adt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmOperand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmPiece {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AssocItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Expr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ExternItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for FieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for GenericArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for GenericParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Item {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Pat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Stmt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Type {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for UseBoundGenericArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for VariantDef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Abi {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ArgList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ArrayExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ArrayType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmClobberAbi {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmConst {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmDirSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmLabel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmOperandExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmOperandNamed {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmOption {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmRegOperand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmRegSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AsmSym {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AssocItemList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AssocTypeArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Attr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for AwaitExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for BecomeExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for BinExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for BlockExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for BoxPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for BreakExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for CallExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for CastExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ClosureExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Const {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ConstArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ConstBlockPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ConstParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ContinueExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for DynTraitType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ExprStmt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ExternBlock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ExternCrate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ExternItemList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for FieldExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Fn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for FnPtrType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ForBinder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ForExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ForType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for FormatArgsArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for FormatArgsExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for GenericArgList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for GenericParamList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for IdentPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for IfExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Impl {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ImplTraitType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for IndexExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for InferType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ItemList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Label {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LetElse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LetExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LetStmt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Lifetime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LifetimeArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LifetimeParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Literal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LiteralPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for LoopExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroCall {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroDef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroItems {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroRules {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroStmts {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MacroType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MatchArm {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MatchArmList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MatchExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MatchGuard {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Meta {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for MethodCallExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Module {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Name {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for NameRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for NeverType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for OffsetOfExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for OrPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Param {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ParamList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ParenExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ParenPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ParenType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ParenthesizedArgList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Path {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PathExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PathPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PathSegment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PathType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PrefixExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for PtrType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RangeExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RangePat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordExprField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordExprFieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordFieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordPatField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RecordPatFieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RefExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RefPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RefType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Rename {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RestPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for RetType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ReturnExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for ReturnTypeSyntax {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for SelfParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for SlicePat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for SliceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for SourceFile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Static {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for StmtList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Struct {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TokenTree {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Trait {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TryExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TupleExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TupleField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TupleFieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TuplePat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TupleStructPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TupleType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeAlias {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeAnchor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeArg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeBound {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeBoundList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for TypeParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for UnderscoreExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Union {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Use {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for UseBoundGenericArgs {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for UseTree {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for UseTreeList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Variant {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for VariantList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for Visibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for WhereClause {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for WherePred {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for WhileExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for WildcardPat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for YeetExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}
impl std::fmt::Display for YieldExpr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
}