crates/syntax/src/ast/generated/nodes.rs

   1 //! Generated file, do not edit by hand, see `xtask/src/codegen`
   2
   3 use crate::{
   4     ast::{self, support, AstChildren, AstNode},
   5     SyntaxKind::{self, *},
   6     SyntaxNode, SyntaxToken, T,
   7 };
   8 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
   9 pub struct Name {
  10     pub(crate) syntax: SyntaxNode,
  11 }
  12 impl Name {
  13     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
  14 }
  15 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  16 pub struct NameRef {
  17     pub(crate) syntax: SyntaxNode,
  18 }
  19 impl NameRef {
  20     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
  21 }
  22 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  23 pub struct Lifetime {
  24     pub(crate) syntax: SyntaxNode,
  25 }
  26 impl Lifetime {
  27     pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> {
  28         support::token(&self.syntax, T![lifetime_ident])
  29     }
  30 }
  31 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  32 pub struct Path {
  33     pub(crate) syntax: SyntaxNode,
  34 }
  35 impl Path {
  36     pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
  37     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
  38     pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
  39 }
  40 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  41 pub struct PathSegment {
  42     pub(crate) syntax: SyntaxNode,
  43 }
  44 impl PathSegment {
  45     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
  46     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
  47     pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
  48     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
  49     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
  50     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
  51     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
  52     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
  53     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
  54     pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
  55     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
  56     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
  57 }
  58 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  59 pub struct GenericArgList {
  60     pub(crate) syntax: SyntaxNode,
  61 }
  62 impl GenericArgList {
  63     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
  64     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
  65     pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
  66     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
  67 }
  68 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  69 pub struct ParamList {
  70     pub(crate) syntax: SyntaxNode,
  71 }
  72 impl ParamList {
  73     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
  74     pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
  75     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
  76     pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
  77     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
  78     pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
  79 }
  80 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  81 pub struct RetType {
  82     pub(crate) syntax: SyntaxNode,
  83 }
  84 impl RetType {
  85     pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
  86     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
  87 }
  88 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  89 pub struct PathType {
  90     pub(crate) syntax: SyntaxNode,
  91 }
  92 impl PathType {
  93     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
  94 }
  95 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  96 pub struct TypeArg {
  97     pub(crate) syntax: SyntaxNode,
  98 }
  99 impl TypeArg {
 100     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 101 }
 102 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 103 pub struct AssocTypeArg {
 104     pub(crate) syntax: SyntaxNode,
 105 }
 106 impl ast::TypeBoundsOwner for AssocTypeArg {}
 107 impl AssocTypeArg {
 108     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 109     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 110     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 111 }
 112 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 113 pub struct LifetimeArg {
 114     pub(crate) syntax: SyntaxNode,
 115 }
 116 impl LifetimeArg {
 117     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 118 }
 119 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 120 pub struct ConstArg {
 121     pub(crate) syntax: SyntaxNode,
 122 }
 123 impl ConstArg {
 124     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 125 }
 126 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 127 pub struct TypeBoundList {
 128     pub(crate) syntax: SyntaxNode,
 129 }
 130 impl TypeBoundList {
 131     pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
 132 }
 133 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 134 pub struct MacroCall {
 135     pub(crate) syntax: SyntaxNode,
 136 }
 137 impl ast::AttrsOwner for MacroCall {}
 138 impl MacroCall {
 139     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 140     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
 141     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 142     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 143 }
 144 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 145 pub struct Attr {
 146     pub(crate) syntax: SyntaxNode,
 147 }
 148 impl Attr {
 149     pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
 150     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
 151     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
 152     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 153     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 154     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
 155     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 156     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 157 }
 158 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 159 pub struct TokenTree {
 160     pub(crate) syntax: SyntaxNode,
 161 }
 162 impl TokenTree {
 163     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 164     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 165     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 166     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 167     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
 168     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 169 }
 170 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 171 pub struct MacroItems {
 172     pub(crate) syntax: SyntaxNode,
 173 }
 174 impl ast::ModuleItemOwner for MacroItems {}
 175 impl MacroItems {}
 176 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 177 pub struct MacroStmts {
 178     pub(crate) syntax: SyntaxNode,
 179 }
 180 impl MacroStmts {
 181     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
 182     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 183 }
 184 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 185 pub struct SourceFile {
 186     pub(crate) syntax: SyntaxNode,
 187 }
 188 impl ast::AttrsOwner for SourceFile {}
 189 impl ast::ModuleItemOwner for SourceFile {}
 190 impl SourceFile {
 191     pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
 192 }
 193 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 194 pub struct Const {
 195     pub(crate) syntax: SyntaxNode,
 196 }
 197 impl ast::AttrsOwner for Const {}
 198 impl ast::NameOwner for Const {}
 199 impl ast::VisibilityOwner for Const {}
 200 impl Const {
 201     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
 202     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 203     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 204     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 205     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 206     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 207     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
 208     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 209 }
 210 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 211 pub struct Enum {
 212     pub(crate) syntax: SyntaxNode,
 213 }
 214 impl ast::AttrsOwner for Enum {}
 215 impl ast::NameOwner for Enum {}
 216 impl ast::VisibilityOwner for Enum {}
 217 impl ast::GenericParamsOwner for Enum {}
 218 impl Enum {
 219     pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
 220     pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
 221 }
 222 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 223 pub struct ExternBlock {
 224     pub(crate) syntax: SyntaxNode,
 225 }
 226 impl ast::AttrsOwner for ExternBlock {}
 227 impl ExternBlock {
 228     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
 229     pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
 230 }
 231 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 232 pub struct ExternCrate {
 233     pub(crate) syntax: SyntaxNode,
 234 }
 235 impl ast::AttrsOwner for ExternCrate {}
 236 impl ast::VisibilityOwner for ExternCrate {}
 237 impl ExternCrate {
 238     pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
 239     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
 240     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 241     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
 242     pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
 243     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 244 }
 245 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 246 pub struct Fn {
 247     pub(crate) syntax: SyntaxNode,
 248 }
 249 impl ast::AttrsOwner for Fn {}
 250 impl ast::NameOwner for Fn {}
 251 impl ast::VisibilityOwner for Fn {}
 252 impl ast::GenericParamsOwner for Fn {}
 253 impl Fn {
 254     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
 255     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 256     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
 257     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
 258     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
 259     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
 260     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
 261     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
 262     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 263     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 264 }
 265 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 266 pub struct Impl {
 267     pub(crate) syntax: SyntaxNode,
 268 }
 269 impl ast::AttrsOwner for Impl {}
 270 impl ast::VisibilityOwner for Impl {}
 271 impl ast::GenericParamsOwner for Impl {}
 272 impl Impl {
 273     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
 274     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
 275     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
 276     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 277     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
 278     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
 279     pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
 280 }
 281 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 282 pub struct MacroRules {
 283     pub(crate) syntax: SyntaxNode,
 284 }
 285 impl ast::AttrsOwner for MacroRules {}
 286 impl ast::NameOwner for MacroRules {}
 287 impl ast::VisibilityOwner for MacroRules {}
 288 impl MacroRules {
 289     pub fn macro_rules_token(&self) -> Option<SyntaxToken> {
 290         support::token(&self.syntax, T![macro_rules])
 291     }
 292     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
 293     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 294 }
 295 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 296 pub struct MacroDef {
 297     pub(crate) syntax: SyntaxNode,
 298 }
 299 impl ast::AttrsOwner for MacroDef {}
 300 impl ast::NameOwner for MacroDef {}
 301 impl ast::VisibilityOwner for MacroDef {}
 302 impl MacroDef {
 303     pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) }
 304     pub fn args(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 305     pub fn body(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 306 }
 307 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 308 pub struct Module {
 309     pub(crate) syntax: SyntaxNode,
 310 }
 311 impl ast::AttrsOwner for Module {}
 312 impl ast::NameOwner for Module {}
 313 impl ast::VisibilityOwner for Module {}
 314 impl Module {
 315     pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
 316     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 317     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 318 }
 319 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 320 pub struct Static {
 321     pub(crate) syntax: SyntaxNode,
 322 }
 323 impl ast::AttrsOwner for Static {}
 324 impl ast::NameOwner for Static {}
 325 impl ast::VisibilityOwner for Static {}
 326 impl Static {
 327     pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
 328     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
 329     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 330     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 331     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 332     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
 333     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 334 }
 335 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 336 pub struct Struct {
 337     pub(crate) syntax: SyntaxNode,
 338 }
 339 impl ast::AttrsOwner for Struct {}
 340 impl ast::NameOwner for Struct {}
 341 impl ast::VisibilityOwner for Struct {}
 342 impl ast::GenericParamsOwner for Struct {}
 343 impl Struct {
 344     pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
 345     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 346     pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
 347 }
 348 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 349 pub struct Trait {
 350     pub(crate) syntax: SyntaxNode,
 351 }
 352 impl ast::AttrsOwner for Trait {}
 353 impl ast::NameOwner for Trait {}
 354 impl ast::VisibilityOwner for Trait {}
 355 impl ast::GenericParamsOwner for Trait {}
 356 impl ast::TypeBoundsOwner for Trait {}
 357 impl Trait {
 358     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
 359     pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
 360     pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
 361     pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
 362 }
 363 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 364 pub struct TypeAlias {
 365     pub(crate) syntax: SyntaxNode,
 366 }
 367 impl ast::AttrsOwner for TypeAlias {}
 368 impl ast::NameOwner for TypeAlias {}
 369 impl ast::VisibilityOwner for TypeAlias {}
 370 impl ast::GenericParamsOwner for TypeAlias {}
 371 impl ast::TypeBoundsOwner for TypeAlias {}
 372 impl TypeAlias {
 373     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
 374     pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
 375     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 376     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 377     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 378 }
 379 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 380 pub struct Union {
 381     pub(crate) syntax: SyntaxNode,
 382 }
 383 impl ast::AttrsOwner for Union {}
 384 impl ast::NameOwner for Union {}
 385 impl ast::VisibilityOwner for Union {}
 386 impl ast::GenericParamsOwner for Union {}
 387 impl Union {
 388     pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
 389     pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
 390 }
 391 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 392 pub struct Use {
 393     pub(crate) syntax: SyntaxNode,
 394 }
 395 impl ast::AttrsOwner for Use {}
 396 impl ast::VisibilityOwner for Use {}
 397 impl Use {
 398     pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
 399     pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
 400     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 401 }
 402 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 403 pub struct Visibility {
 404     pub(crate) syntax: SyntaxNode,
 405 }
 406 impl Visibility {
 407     pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
 408     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 409     pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
 410     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
 411     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
 412     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
 413     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 414     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 415 }
 416 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 417 pub struct ItemList {
 418     pub(crate) syntax: SyntaxNode,
 419 }
 420 impl ast::AttrsOwner for ItemList {}
 421 impl ast::ModuleItemOwner for ItemList {}
 422 impl ItemList {
 423     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 424     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 425 }
 426 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 427 pub struct Rename {
 428     pub(crate) syntax: SyntaxNode,
 429 }
 430 impl ast::NameOwner for Rename {}
 431 impl Rename {
 432     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
 433     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 434 }
 435 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 436 pub struct UseTree {
 437     pub(crate) syntax: SyntaxNode,
 438 }
 439 impl UseTree {
 440     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 441     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
 442     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
 443     pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
 444     pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
 445 }
 446 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 447 pub struct UseTreeList {
 448     pub(crate) syntax: SyntaxNode,
 449 }
 450 impl UseTreeList {
 451     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 452     pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
 453     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 454 }
 455 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 456 pub struct Abi {
 457     pub(crate) syntax: SyntaxNode,
 458 }
 459 impl Abi {
 460     pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
 461 }
 462 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 463 pub struct GenericParamList {
 464     pub(crate) syntax: SyntaxNode,
 465 }
 466 impl GenericParamList {
 467     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
 468     pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
 469     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
 470 }
 471 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 472 pub struct WhereClause {
 473     pub(crate) syntax: SyntaxNode,
 474 }
 475 impl WhereClause {
 476     pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
 477     pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
 478 }
 479 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 480 pub struct BlockExpr {
 481     pub(crate) syntax: SyntaxNode,
 482 }
 483 impl ast::AttrsOwner for BlockExpr {}
 484 impl BlockExpr {
 485     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 486     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
 487     pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 488     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 489 }
 490 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 491 pub struct SelfParam {
 492     pub(crate) syntax: SyntaxNode,
 493 }
 494 impl ast::AttrsOwner for SelfParam {}
 495 impl SelfParam {
 496     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
 497     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 498     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
 499     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
 500     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 501     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 502 }
 503 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 504 pub struct Param {
 505     pub(crate) syntax: SyntaxNode,
 506 }
 507 impl ast::AttrsOwner for Param {}
 508 impl Param {
 509     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 510     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 511     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 512     pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
 513 }
 514 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 515 pub struct RecordFieldList {
 516     pub(crate) syntax: SyntaxNode,
 517 }
 518 impl RecordFieldList {
 519     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 520     pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
 521     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 522 }
 523 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 524 pub struct TupleFieldList {
 525     pub(crate) syntax: SyntaxNode,
 526 }
 527 impl TupleFieldList {
 528     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 529     pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
 530     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 531 }
 532 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 533 pub struct RecordField {
 534     pub(crate) syntax: SyntaxNode,
 535 }
 536 impl ast::AttrsOwner for RecordField {}
 537 impl ast::NameOwner for RecordField {}
 538 impl ast::VisibilityOwner for RecordField {}
 539 impl RecordField {
 540     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 541     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 542 }
 543 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 544 pub struct TupleField {
 545     pub(crate) syntax: SyntaxNode,
 546 }
 547 impl ast::AttrsOwner for TupleField {}
 548 impl ast::VisibilityOwner for TupleField {}
 549 impl TupleField {
 550     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 551 }
 552 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 553 pub struct VariantList {
 554     pub(crate) syntax: SyntaxNode,
 555 }
 556 impl VariantList {
 557     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 558     pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
 559     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 560 }
 561 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 562 pub struct Variant {
 563     pub(crate) syntax: SyntaxNode,
 564 }
 565 impl ast::AttrsOwner for Variant {}
 566 impl ast::NameOwner for Variant {}
 567 impl ast::VisibilityOwner for Variant {}
 568 impl Variant {
 569     pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
 570     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 571     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 572 }
 573 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 574 pub struct AssocItemList {
 575     pub(crate) syntax: SyntaxNode,
 576 }
 577 impl ast::AttrsOwner for AssocItemList {}
 578 impl AssocItemList {
 579     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 580     pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
 581     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 582 }
 583 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 584 pub struct ExternItemList {
 585     pub(crate) syntax: SyntaxNode,
 586 }
 587 impl ast::AttrsOwner for ExternItemList {}
 588 impl ExternItemList {
 589     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 590     pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
 591     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 592 }
 593 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 594 pub struct ConstParam {
 595     pub(crate) syntax: SyntaxNode,
 596 }
 597 impl ast::AttrsOwner for ConstParam {}
 598 impl ast::NameOwner for ConstParam {}
 599 impl ConstParam {
 600     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 601     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 602     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 603     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 604     pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
 605 }
 606 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 607 pub struct LifetimeParam {
 608     pub(crate) syntax: SyntaxNode,
 609 }
 610 impl ast::AttrsOwner for LifetimeParam {}
 611 impl ast::TypeBoundsOwner for LifetimeParam {}
 612 impl LifetimeParam {
 613     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 614 }
 615 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 616 pub struct TypeParam {
 617     pub(crate) syntax: SyntaxNode,
 618 }
 619 impl ast::AttrsOwner for TypeParam {}
 620 impl ast::NameOwner for TypeParam {}
 621 impl ast::TypeBoundsOwner for TypeParam {}
 622 impl TypeParam {
 623     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 624     pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
 625 }
 626 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 627 pub struct WherePred {
 628     pub(crate) syntax: SyntaxNode,
 629 }
 630 impl ast::TypeBoundsOwner for WherePred {}
 631 impl WherePred {
 632     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
 633     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
 634     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 635     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 636 }
 637 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 638 pub struct Literal {
 639     pub(crate) syntax: SyntaxNode,
 640 }
 641 impl ast::AttrsOwner for Literal {}
 642 impl Literal {}
 643 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 644 pub struct ExprStmt {
 645     pub(crate) syntax: SyntaxNode,
 646 }
 647 impl ast::AttrsOwner for ExprStmt {}
 648 impl ExprStmt {
 649     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 650     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 651 }
 652 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 653 pub struct LetStmt {
 654     pub(crate) syntax: SyntaxNode,
 655 }
 656 impl ast::AttrsOwner for LetStmt {}
 657 impl LetStmt {
 658     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
 659     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 660     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 661     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 662     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 663     pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
 664     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 665 }
 666 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 667 pub struct ArrayExpr {
 668     pub(crate) syntax: SyntaxNode,
 669 }
 670 impl ast::AttrsOwner for ArrayExpr {}
 671 impl ArrayExpr {
 672     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
 673     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
 674     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 675     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 676     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 677 }
 678 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 679 pub struct AwaitExpr {
 680     pub(crate) syntax: SyntaxNode,
 681 }
 682 impl ast::AttrsOwner for AwaitExpr {}
 683 impl AwaitExpr {
 684     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 685     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
 686     pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
 687 }
 688 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 689 pub struct BinExpr {
 690     pub(crate) syntax: SyntaxNode,
 691 }
 692 impl ast::AttrsOwner for BinExpr {}
 693 impl BinExpr {}
 694 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 695 pub struct BoxExpr {
 696     pub(crate) syntax: SyntaxNode,
 697 }
 698 impl ast::AttrsOwner for BoxExpr {}
 699 impl BoxExpr {
 700     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
 701     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 702 }
 703 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 704 pub struct BreakExpr {
 705     pub(crate) syntax: SyntaxNode,
 706 }
 707 impl ast::AttrsOwner for BreakExpr {}
 708 impl BreakExpr {
 709     pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
 710     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 711     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 712 }
 713 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 714 pub struct CallExpr {
 715     pub(crate) syntax: SyntaxNode,
 716 }
 717 impl ast::AttrsOwner for CallExpr {}
 718 impl ast::ArgListOwner for CallExpr {}
 719 impl CallExpr {
 720     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 721 }
 722 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 723 pub struct CastExpr {
 724     pub(crate) syntax: SyntaxNode,
 725 }
 726 impl ast::AttrsOwner for CastExpr {}
 727 impl CastExpr {
 728     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 729     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
 730     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 731 }
 732 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 733 pub struct ClosureExpr {
 734     pub(crate) syntax: SyntaxNode,
 735 }
 736 impl ast::AttrsOwner for ClosureExpr {}
 737 impl ClosureExpr {
 738     pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
 739     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
 740     pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
 741     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
 742     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
 743     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
 744 }
 745 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 746 pub struct ContinueExpr {
 747     pub(crate) syntax: SyntaxNode,
 748 }
 749 impl ast::AttrsOwner for ContinueExpr {}
 750 impl ContinueExpr {
 751     pub fn continue_token(&self) -> Option<SyntaxToken> {
 752         support::token(&self.syntax, T![continue])
 753     }
 754     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 755 }
 756 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 757 pub struct EffectExpr {
 758     pub(crate) syntax: SyntaxNode,
 759 }
 760 impl ast::AttrsOwner for EffectExpr {}
 761 impl EffectExpr {
 762     pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
 763     pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
 764     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
 765     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
 766     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 767     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 768 }
 769 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 770 pub struct FieldExpr {
 771     pub(crate) syntax: SyntaxNode,
 772 }
 773 impl ast::AttrsOwner for FieldExpr {}
 774 impl FieldExpr {
 775     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 776     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
 777     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 778 }
 779 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 780 pub struct ForExpr {
 781     pub(crate) syntax: SyntaxNode,
 782 }
 783 impl ast::AttrsOwner for ForExpr {}
 784 impl ast::LoopBodyOwner for ForExpr {}
 785 impl ForExpr {
 786     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
 787     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 788     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
 789     pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
 790 }
 791 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 792 pub struct IfExpr {
 793     pub(crate) syntax: SyntaxNode,
 794 }
 795 impl ast::AttrsOwner for IfExpr {}
 796 impl IfExpr {
 797     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
 798     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 799     pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
 800 }
 801 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 802 pub struct IndexExpr {
 803     pub(crate) syntax: SyntaxNode,
 804 }
 805 impl ast::AttrsOwner for IndexExpr {}
 806 impl IndexExpr {
 807     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
 808     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 809 }
 810 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 811 pub struct LoopExpr {
 812     pub(crate) syntax: SyntaxNode,
 813 }
 814 impl ast::AttrsOwner for LoopExpr {}
 815 impl ast::LoopBodyOwner for LoopExpr {}
 816 impl LoopExpr {
 817     pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
 818 }
 819 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 820 pub struct MatchExpr {
 821     pub(crate) syntax: SyntaxNode,
 822 }
 823 impl ast::AttrsOwner for MatchExpr {}
 824 impl MatchExpr {
 825     pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
 826     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 827     pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
 828 }
 829 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 830 pub struct MethodCallExpr {
 831     pub(crate) syntax: SyntaxNode,
 832 }
 833 impl ast::AttrsOwner for MethodCallExpr {}
 834 impl ast::ArgListOwner for MethodCallExpr {}
 835 impl MethodCallExpr {
 836     pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }
 837     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
 838     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 839     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
 840 }
 841 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 842 pub struct ParenExpr {
 843     pub(crate) syntax: SyntaxNode,
 844 }
 845 impl ast::AttrsOwner for ParenExpr {}
 846 impl ParenExpr {
 847     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 848     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 849     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 850 }
 851 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 852 pub struct PathExpr {
 853     pub(crate) syntax: SyntaxNode,
 854 }
 855 impl ast::AttrsOwner for PathExpr {}
 856 impl PathExpr {
 857     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 858 }
 859 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 860 pub struct PrefixExpr {
 861     pub(crate) syntax: SyntaxNode,
 862 }
 863 impl ast::AttrsOwner for PrefixExpr {}
 864 impl PrefixExpr {
 865     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 866 }
 867 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 868 pub struct RangeExpr {
 869     pub(crate) syntax: SyntaxNode,
 870 }
 871 impl ast::AttrsOwner for RangeExpr {}
 872 impl RangeExpr {}
 873 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 874 pub struct RecordExpr {
 875     pub(crate) syntax: SyntaxNode,
 876 }
 877 impl RecordExpr {
 878     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 879     pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
 880         support::child(&self.syntax)
 881     }
 882 }
 883 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 884 pub struct RefExpr {
 885     pub(crate) syntax: SyntaxNode,
 886 }
 887 impl ast::AttrsOwner for RefExpr {}
 888 impl RefExpr {
 889     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
 890     pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
 891     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
 892     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
 893     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 894 }
 895 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 896 pub struct ReturnExpr {
 897     pub(crate) syntax: SyntaxNode,
 898 }
 899 impl ast::AttrsOwner for ReturnExpr {}
 900 impl ReturnExpr {
 901     pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
 902     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 903 }
 904 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 905 pub struct TryExpr {
 906     pub(crate) syntax: SyntaxNode,
 907 }
 908 impl ast::AttrsOwner for TryExpr {}
 909 impl TryExpr {
 910     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 911     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
 912 }
 913 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 914 pub struct TupleExpr {
 915     pub(crate) syntax: SyntaxNode,
 916 }
 917 impl ast::AttrsOwner for TupleExpr {}
 918 impl TupleExpr {
 919     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 920     pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
 921     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 922 }
 923 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 924 pub struct WhileExpr {
 925     pub(crate) syntax: SyntaxNode,
 926 }
 927 impl ast::AttrsOwner for WhileExpr {}
 928 impl ast::LoopBodyOwner for WhileExpr {}
 929 impl WhileExpr {
 930     pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
 931     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 932 }
 933 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 934 pub struct YieldExpr {
 935     pub(crate) syntax: SyntaxNode,
 936 }
 937 impl ast::AttrsOwner for YieldExpr {}
 938 impl YieldExpr {
 939     pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) }
 940     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 941 }
 942 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 943 pub struct Label {
 944     pub(crate) syntax: SyntaxNode,
 945 }
 946 impl Label {
 947     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 948     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 949 }
 950 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 951 pub struct RecordExprFieldList {
 952     pub(crate) syntax: SyntaxNode,
 953 }
 954 impl ast::AttrsOwner for RecordExprFieldList {}
 955 impl RecordExprFieldList {
 956     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 957     pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
 958     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
 959     pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
 960     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 961 }
 962 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 963 pub struct RecordExprField {
 964     pub(crate) syntax: SyntaxNode,
 965 }
 966 impl ast::AttrsOwner for RecordExprField {}
 967 impl RecordExprField {
 968     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 969     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 970     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 971 }
 972 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 973 pub struct ArgList {
 974     pub(crate) syntax: SyntaxNode,
 975 }
 976 impl ArgList {
 977     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 978     pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
 979     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 980 }
 981 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 982 pub struct Condition {
 983     pub(crate) syntax: SyntaxNode,
 984 }
 985 impl Condition {
 986     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
 987     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 988     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 989     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 990 }
 991 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 992 pub struct MatchArmList {
 993     pub(crate) syntax: SyntaxNode,
 994 }
 995 impl ast::AttrsOwner for MatchArmList {}
 996 impl MatchArmList {
 997     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 998     pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
 999     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1000 }
1001 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1002 pub struct MatchArm {
1003     pub(crate) syntax: SyntaxNode,
1004 }
1005 impl ast::AttrsOwner for MatchArm {}
1006 impl MatchArm {
1007     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1008     pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
1009     pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
1010     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1011     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1012 }
1013 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1014 pub struct MatchGuard {
1015     pub(crate) syntax: SyntaxNode,
1016 }
1017 impl MatchGuard {
1018     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
1019     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1020 }
1021 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1022 pub struct ArrayType {
1023     pub(crate) syntax: SyntaxNode,
1024 }
1025 impl ArrayType {
1026     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1027     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1028     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1029     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1030     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1031 }
1032 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1033 pub struct DynTraitType {
1034     pub(crate) syntax: SyntaxNode,
1035 }
1036 impl DynTraitType {
1037     pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
1038     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1039 }
1040 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1041 pub struct FnPtrType {
1042     pub(crate) syntax: SyntaxNode,
1043 }
1044 impl FnPtrType {
1045     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1046     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
1047     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1048     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
1049     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
1050     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
1051     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
1052 }
1053 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1054 pub struct ForType {
1055     pub(crate) syntax: SyntaxNode,
1056 }
1057 impl ForType {
1058     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
1059     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
1060     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1061 }
1062 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1063 pub struct ImplTraitType {
1064     pub(crate) syntax: SyntaxNode,
1065 }
1066 impl ImplTraitType {
1067     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
1068     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1069 }
1070 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1071 pub struct InferType {
1072     pub(crate) syntax: SyntaxNode,
1073 }
1074 impl InferType {
1075     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1076 }
1077 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1078 pub struct NeverType {
1079     pub(crate) syntax: SyntaxNode,
1080 }
1081 impl NeverType {
1082     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1083 }
1084 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1085 pub struct ParenType {
1086     pub(crate) syntax: SyntaxNode,
1087 }
1088 impl ParenType {
1089     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1090     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1091     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1092 }
1093 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1094 pub struct PtrType {
1095     pub(crate) syntax: SyntaxNode,
1096 }
1097 impl PtrType {
1098     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
1099     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1100     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1101     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1102 }
1103 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1104 pub struct RefType {
1105     pub(crate) syntax: SyntaxNode,
1106 }
1107 impl RefType {
1108     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1109     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1110     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1111     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1112 }
1113 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1114 pub struct SliceType {
1115     pub(crate) syntax: SyntaxNode,
1116 }
1117 impl SliceType {
1118     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1119     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1120     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1121 }
1122 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1123 pub struct TupleType {
1124     pub(crate) syntax: SyntaxNode,
1125 }
1126 impl TupleType {
1127     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1128     pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
1129     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1130 }
1131 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1132 pub struct TypeBound {
1133     pub(crate) syntax: SyntaxNode,
1134 }
1135 impl TypeBound {
1136     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1137     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1138     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1139 }
1140 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1141 pub struct IdentPat {
1142     pub(crate) syntax: SyntaxNode,
1143 }
1144 impl ast::AttrsOwner for IdentPat {}
1145 impl ast::NameOwner for IdentPat {}
1146 impl IdentPat {
1147     pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
1148     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1149     pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
1150     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1151 }
1152 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1153 pub struct BoxPat {
1154     pub(crate) syntax: SyntaxNode,
1155 }
1156 impl BoxPat {
1157     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
1158     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1159 }
1160 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1161 pub struct RestPat {
1162     pub(crate) syntax: SyntaxNode,
1163 }
1164 impl RestPat {
1165     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1166 }
1167 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1168 pub struct LiteralPat {
1169     pub(crate) syntax: SyntaxNode,
1170 }
1171 impl LiteralPat {
1172     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1173 }
1174 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1175 pub struct MacroPat {
1176     pub(crate) syntax: SyntaxNode,
1177 }
1178 impl MacroPat {
1179     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1180 }
1181 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1182 pub struct OrPat {
1183     pub(crate) syntax: SyntaxNode,
1184 }
1185 impl OrPat {
1186     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1187 }
1188 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1189 pub struct ParenPat {
1190     pub(crate) syntax: SyntaxNode,
1191 }
1192 impl ParenPat {
1193     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1194     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1195     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1196 }
1197 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1198 pub struct PathPat {
1199     pub(crate) syntax: SyntaxNode,
1200 }
1201 impl PathPat {
1202     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1203 }
1204 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1205 pub struct WildcardPat {
1206     pub(crate) syntax: SyntaxNode,
1207 }
1208 impl WildcardPat {
1209     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1210 }
1211 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1212 pub struct RangePat {
1213     pub(crate) syntax: SyntaxNode,
1214 }
1215 impl RangePat {}
1216 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1217 pub struct RecordPat {
1218     pub(crate) syntax: SyntaxNode,
1219 }
1220 impl RecordPat {
1221     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1222     pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
1223         support::child(&self.syntax)
1224     }
1225 }
1226 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1227 pub struct RefPat {
1228     pub(crate) syntax: SyntaxNode,
1229 }
1230 impl RefPat {
1231     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1232     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1233     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1234 }
1235 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1236 pub struct SlicePat {
1237     pub(crate) syntax: SyntaxNode,
1238 }
1239 impl SlicePat {
1240     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1241     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1242     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1243 }
1244 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1245 pub struct TuplePat {
1246     pub(crate) syntax: SyntaxNode,
1247 }
1248 impl TuplePat {
1249     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1250     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1251     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1252 }
1253 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1254 pub struct TupleStructPat {
1255     pub(crate) syntax: SyntaxNode,
1256 }
1257 impl TupleStructPat {
1258     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1259     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1260     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1261     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1262 }
1263 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1264 pub struct ConstBlockPat {
1265     pub(crate) syntax: SyntaxNode,
1266 }
1267 impl ConstBlockPat {
1268     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1269     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
1270 }
1271 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1272 pub struct RecordPatFieldList {
1273     pub(crate) syntax: SyntaxNode,
1274 }
1275 impl RecordPatFieldList {
1276     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1277     pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
1278     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1279     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1280 }
1281 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1282 pub struct RecordPatField {
1283     pub(crate) syntax: SyntaxNode,
1284 }
1285 impl ast::AttrsOwner for RecordPatField {}
1286 impl RecordPatField {
1287     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1288     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1289     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1290 }
1291 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1292 pub enum GenericArg {
1293     TypeArg(TypeArg),
1294     AssocTypeArg(AssocTypeArg),
1295     LifetimeArg(LifetimeArg),
1296     ConstArg(ConstArg),
1297 }
1298 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1299 pub enum Type {
1300     ArrayType(ArrayType),
1301     DynTraitType(DynTraitType),
1302     FnPtrType(FnPtrType),
1303     ForType(ForType),
1304     ImplTraitType(ImplTraitType),
1305     InferType(InferType),
1306     NeverType(NeverType),
1307     ParenType(ParenType),
1308     PathType(PathType),
1309     PtrType(PtrType),
1310     RefType(RefType),
1311     SliceType(SliceType),
1312     TupleType(TupleType),
1313 }
1314 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1315 pub enum Expr {
1316     ArrayExpr(ArrayExpr),
1317     AwaitExpr(AwaitExpr),
1318     BinExpr(BinExpr),
1319     BlockExpr(BlockExpr),
1320     BoxExpr(BoxExpr),
1321     BreakExpr(BreakExpr),
1322     CallExpr(CallExpr),
1323     CastExpr(CastExpr),
1324     ClosureExpr(ClosureExpr),
1325     ContinueExpr(ContinueExpr),
1326     EffectExpr(EffectExpr),
1327     FieldExpr(FieldExpr),
1328     ForExpr(ForExpr),
1329     IfExpr(IfExpr),
1330     IndexExpr(IndexExpr),
1331     Literal(Literal),
1332     LoopExpr(LoopExpr),
1333     MacroCall(MacroCall),
1334     MatchExpr(MatchExpr),
1335     MethodCallExpr(MethodCallExpr),
1336     ParenExpr(ParenExpr),
1337     PathExpr(PathExpr),
1338     PrefixExpr(PrefixExpr),
1339     RangeExpr(RangeExpr),
1340     RecordExpr(RecordExpr),
1341     RefExpr(RefExpr),
1342     ReturnExpr(ReturnExpr),
1343     TryExpr(TryExpr),
1344     TupleExpr(TupleExpr),
1345     WhileExpr(WhileExpr),
1346     YieldExpr(YieldExpr),
1347 }
1348 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1349 pub enum Item {
1350     Const(Const),
1351     Enum(Enum),
1352     ExternBlock(ExternBlock),
1353     ExternCrate(ExternCrate),
1354     Fn(Fn),
1355     Impl(Impl),
1356     MacroCall(MacroCall),
1357     MacroRules(MacroRules),
1358     MacroDef(MacroDef),
1359     Module(Module),
1360     Static(Static),
1361     Struct(Struct),
1362     Trait(Trait),
1363     TypeAlias(TypeAlias),
1364     Union(Union),
1365     Use(Use),
1366 }
1367 impl ast::AttrsOwner for Item {}
1368 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1369 pub enum Stmt {
1370     ExprStmt(ExprStmt),
1371     Item(Item),
1372     LetStmt(LetStmt),
1373 }
1374 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1375 pub enum Pat {
1376     IdentPat(IdentPat),
1377     BoxPat(BoxPat),
1378     RestPat(RestPat),
1379     LiteralPat(LiteralPat),
1380     MacroPat(MacroPat),
1381     OrPat(OrPat),
1382     ParenPat(ParenPat),
1383     PathPat(PathPat),
1384     WildcardPat(WildcardPat),
1385     RangePat(RangePat),
1386     RecordPat(RecordPat),
1387     RefPat(RefPat),
1388     SlicePat(SlicePat),
1389     TuplePat(TuplePat),
1390     TupleStructPat(TupleStructPat),
1391     ConstBlockPat(ConstBlockPat),
1392 }
1393 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1394 pub enum FieldList {
1395     RecordFieldList(RecordFieldList),
1396     TupleFieldList(TupleFieldList),
1397 }
1398 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1399 pub enum AdtDef {
1400     Enum(Enum),
1401     Struct(Struct),
1402     Union(Union),
1403 }
1404 impl ast::AttrsOwner for AdtDef {}
1405 impl ast::GenericParamsOwner for AdtDef {}
1406 impl ast::NameOwner for AdtDef {}
1407 impl ast::VisibilityOwner for AdtDef {}
1408 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1409 pub enum AssocItem {
1410     Const(Const),
1411     Fn(Fn),
1412     MacroCall(MacroCall),
1413     TypeAlias(TypeAlias),
1414 }
1415 impl ast::AttrsOwner for AssocItem {}
1416 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1417 pub enum ExternItem {
1418     Fn(Fn),
1419     MacroCall(MacroCall),
1420     Static(Static),
1421     TypeAlias(TypeAlias),
1422 }
1423 impl ast::AttrsOwner for ExternItem {}
1424 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1425 pub enum GenericParam {
1426     ConstParam(ConstParam),
1427     LifetimeParam(LifetimeParam),
1428     TypeParam(TypeParam),
1429 }
1430 impl ast::AttrsOwner for GenericParam {}
1431 impl AstNode for Name {
1432     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
1433     fn cast(syntax: SyntaxNode) -> Option<Self> {
1434         if Self::can_cast(syntax.kind()) {
1435             Some(Self { syntax })
1436         } else {
1437             None
1438         }
1439     }
1440     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1441 }
1442 impl AstNode for NameRef {
1443     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
1444     fn cast(syntax: SyntaxNode) -> Option<Self> {
1445         if Self::can_cast(syntax.kind()) {
1446             Some(Self { syntax })
1447         } else {
1448             None
1449         }
1450     }
1451     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1452 }
1453 impl AstNode for Lifetime {
1454     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME }
1455     fn cast(syntax: SyntaxNode) -> Option<Self> {
1456         if Self::can_cast(syntax.kind()) {
1457             Some(Self { syntax })
1458         } else {
1459             None
1460         }
1461     }
1462     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1463 }
1464 impl AstNode for Path {
1465     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
1466     fn cast(syntax: SyntaxNode) -> Option<Self> {
1467         if Self::can_cast(syntax.kind()) {
1468             Some(Self { syntax })
1469         } else {
1470             None
1471         }
1472     }
1473     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1474 }
1475 impl AstNode for PathSegment {
1476     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
1477     fn cast(syntax: SyntaxNode) -> Option<Self> {
1478         if Self::can_cast(syntax.kind()) {
1479             Some(Self { syntax })
1480         } else {
1481             None
1482         }
1483     }
1484     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1485 }
1486 impl AstNode for GenericArgList {
1487     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
1488     fn cast(syntax: SyntaxNode) -> Option<Self> {
1489         if Self::can_cast(syntax.kind()) {
1490             Some(Self { syntax })
1491         } else {
1492             None
1493         }
1494     }
1495     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1496 }
1497 impl AstNode for ParamList {
1498     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
1499     fn cast(syntax: SyntaxNode) -> Option<Self> {
1500         if Self::can_cast(syntax.kind()) {
1501             Some(Self { syntax })
1502         } else {
1503             None
1504         }
1505     }
1506     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1507 }
1508 impl AstNode for RetType {
1509     fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
1510     fn cast(syntax: SyntaxNode) -> Option<Self> {
1511         if Self::can_cast(syntax.kind()) {
1512             Some(Self { syntax })
1513         } else {
1514             None
1515         }
1516     }
1517     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1518 }
1519 impl AstNode for PathType {
1520     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
1521     fn cast(syntax: SyntaxNode) -> Option<Self> {
1522         if Self::can_cast(syntax.kind()) {
1523             Some(Self { syntax })
1524         } else {
1525             None
1526         }
1527     }
1528     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1529 }
1530 impl AstNode for TypeArg {
1531     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
1532     fn cast(syntax: SyntaxNode) -> Option<Self> {
1533         if Self::can_cast(syntax.kind()) {
1534             Some(Self { syntax })
1535         } else {
1536             None
1537         }
1538     }
1539     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1540 }
1541 impl AstNode for AssocTypeArg {
1542     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
1543     fn cast(syntax: SyntaxNode) -> Option<Self> {
1544         if Self::can_cast(syntax.kind()) {
1545             Some(Self { syntax })
1546         } else {
1547             None
1548         }
1549     }
1550     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1551 }
1552 impl AstNode for LifetimeArg {
1553     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
1554     fn cast(syntax: SyntaxNode) -> Option<Self> {
1555         if Self::can_cast(syntax.kind()) {
1556             Some(Self { syntax })
1557         } else {
1558             None
1559         }
1560     }
1561     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1562 }
1563 impl AstNode for ConstArg {
1564     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
1565     fn cast(syntax: SyntaxNode) -> Option<Self> {
1566         if Self::can_cast(syntax.kind()) {
1567             Some(Self { syntax })
1568         } else {
1569             None
1570         }
1571     }
1572     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1573 }
1574 impl AstNode for TypeBoundList {
1575     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
1576     fn cast(syntax: SyntaxNode) -> Option<Self> {
1577         if Self::can_cast(syntax.kind()) {
1578             Some(Self { syntax })
1579         } else {
1580             None
1581         }
1582     }
1583     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1584 }
1585 impl AstNode for MacroCall {
1586     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
1587     fn cast(syntax: SyntaxNode) -> Option<Self> {
1588         if Self::can_cast(syntax.kind()) {
1589             Some(Self { syntax })
1590         } else {
1591             None
1592         }
1593     }
1594     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1595 }
1596 impl AstNode for Attr {
1597     fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
1598     fn cast(syntax: SyntaxNode) -> Option<Self> {
1599         if Self::can_cast(syntax.kind()) {
1600             Some(Self { syntax })
1601         } else {
1602             None
1603         }
1604     }
1605     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1606 }
1607 impl AstNode for TokenTree {
1608     fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
1609     fn cast(syntax: SyntaxNode) -> Option<Self> {
1610         if Self::can_cast(syntax.kind()) {
1611             Some(Self { syntax })
1612         } else {
1613             None
1614         }
1615     }
1616     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1617 }
1618 impl AstNode for MacroItems {
1619     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
1620     fn cast(syntax: SyntaxNode) -> Option<Self> {
1621         if Self::can_cast(syntax.kind()) {
1622             Some(Self { syntax })
1623         } else {
1624             None
1625         }
1626     }
1627     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1628 }
1629 impl AstNode for MacroStmts {
1630     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
1631     fn cast(syntax: SyntaxNode) -> Option<Self> {
1632         if Self::can_cast(syntax.kind()) {
1633             Some(Self { syntax })
1634         } else {
1635             None
1636         }
1637     }
1638     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1639 }
1640 impl AstNode for SourceFile {
1641     fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
1642     fn cast(syntax: SyntaxNode) -> Option<Self> {
1643         if Self::can_cast(syntax.kind()) {
1644             Some(Self { syntax })
1645         } else {
1646             None
1647         }
1648     }
1649     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1650 }
1651 impl AstNode for Const {
1652     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
1653     fn cast(syntax: SyntaxNode) -> Option<Self> {
1654         if Self::can_cast(syntax.kind()) {
1655             Some(Self { syntax })
1656         } else {
1657             None
1658         }
1659     }
1660     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1661 }
1662 impl AstNode for Enum {
1663     fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
1664     fn cast(syntax: SyntaxNode) -> Option<Self> {
1665         if Self::can_cast(syntax.kind()) {
1666             Some(Self { syntax })
1667         } else {
1668             None
1669         }
1670     }
1671     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1672 }
1673 impl AstNode for ExternBlock {
1674     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
1675     fn cast(syntax: SyntaxNode) -> Option<Self> {
1676         if Self::can_cast(syntax.kind()) {
1677             Some(Self { syntax })
1678         } else {
1679             None
1680         }
1681     }
1682     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1683 }
1684 impl AstNode for ExternCrate {
1685     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
1686     fn cast(syntax: SyntaxNode) -> Option<Self> {
1687         if Self::can_cast(syntax.kind()) {
1688             Some(Self { syntax })
1689         } else {
1690             None
1691         }
1692     }
1693     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1694 }
1695 impl AstNode for Fn {
1696     fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
1697     fn cast(syntax: SyntaxNode) -> Option<Self> {
1698         if Self::can_cast(syntax.kind()) {
1699             Some(Self { syntax })
1700         } else {
1701             None
1702         }
1703     }
1704     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1705 }
1706 impl AstNode for Impl {
1707     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
1708     fn cast(syntax: SyntaxNode) -> Option<Self> {
1709         if Self::can_cast(syntax.kind()) {
1710             Some(Self { syntax })
1711         } else {
1712             None
1713         }
1714     }
1715     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1716 }
1717 impl AstNode for MacroRules {
1718     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
1719     fn cast(syntax: SyntaxNode) -> Option<Self> {
1720         if Self::can_cast(syntax.kind()) {
1721             Some(Self { syntax })
1722         } else {
1723             None
1724         }
1725     }
1726     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1727 }
1728 impl AstNode for MacroDef {
1729     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
1730     fn cast(syntax: SyntaxNode) -> Option<Self> {
1731         if Self::can_cast(syntax.kind()) {
1732             Some(Self { syntax })
1733         } else {
1734             None
1735         }
1736     }
1737     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1738 }
1739 impl AstNode for Module {
1740     fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
1741     fn cast(syntax: SyntaxNode) -> Option<Self> {
1742         if Self::can_cast(syntax.kind()) {
1743             Some(Self { syntax })
1744         } else {
1745             None
1746         }
1747     }
1748     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1749 }
1750 impl AstNode for Static {
1751     fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
1752     fn cast(syntax: SyntaxNode) -> Option<Self> {
1753         if Self::can_cast(syntax.kind()) {
1754             Some(Self { syntax })
1755         } else {
1756             None
1757         }
1758     }
1759     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1760 }
1761 impl AstNode for Struct {
1762     fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
1763     fn cast(syntax: SyntaxNode) -> Option<Self> {
1764         if Self::can_cast(syntax.kind()) {
1765             Some(Self { syntax })
1766         } else {
1767             None
1768         }
1769     }
1770     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1771 }
1772 impl AstNode for Trait {
1773     fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
1774     fn cast(syntax: SyntaxNode) -> Option<Self> {
1775         if Self::can_cast(syntax.kind()) {
1776             Some(Self { syntax })
1777         } else {
1778             None
1779         }
1780     }
1781     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1782 }
1783 impl AstNode for TypeAlias {
1784     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
1785     fn cast(syntax: SyntaxNode) -> Option<Self> {
1786         if Self::can_cast(syntax.kind()) {
1787             Some(Self { syntax })
1788         } else {
1789             None
1790         }
1791     }
1792     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1793 }
1794 impl AstNode for Union {
1795     fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
1796     fn cast(syntax: SyntaxNode) -> Option<Self> {
1797         if Self::can_cast(syntax.kind()) {
1798             Some(Self { syntax })
1799         } else {
1800             None
1801         }
1802     }
1803     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1804 }
1805 impl AstNode for Use {
1806     fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
1807     fn cast(syntax: SyntaxNode) -> Option<Self> {
1808         if Self::can_cast(syntax.kind()) {
1809             Some(Self { syntax })
1810         } else {
1811             None
1812         }
1813     }
1814     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1815 }
1816 impl AstNode for Visibility {
1817     fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
1818     fn cast(syntax: SyntaxNode) -> Option<Self> {
1819         if Self::can_cast(syntax.kind()) {
1820             Some(Self { syntax })
1821         } else {
1822             None
1823         }
1824     }
1825     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1826 }
1827 impl AstNode for ItemList {
1828     fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
1829     fn cast(syntax: SyntaxNode) -> Option<Self> {
1830         if Self::can_cast(syntax.kind()) {
1831             Some(Self { syntax })
1832         } else {
1833             None
1834         }
1835     }
1836     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1837 }
1838 impl AstNode for Rename {
1839     fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
1840     fn cast(syntax: SyntaxNode) -> Option<Self> {
1841         if Self::can_cast(syntax.kind()) {
1842             Some(Self { syntax })
1843         } else {
1844             None
1845         }
1846     }
1847     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1848 }
1849 impl AstNode for UseTree {
1850     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
1851     fn cast(syntax: SyntaxNode) -> Option<Self> {
1852         if Self::can_cast(syntax.kind()) {
1853             Some(Self { syntax })
1854         } else {
1855             None
1856         }
1857     }
1858     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1859 }
1860 impl AstNode for UseTreeList {
1861     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
1862     fn cast(syntax: SyntaxNode) -> Option<Self> {
1863         if Self::can_cast(syntax.kind()) {
1864             Some(Self { syntax })
1865         } else {
1866             None
1867         }
1868     }
1869     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1870 }
1871 impl AstNode for Abi {
1872     fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
1873     fn cast(syntax: SyntaxNode) -> Option<Self> {
1874         if Self::can_cast(syntax.kind()) {
1875             Some(Self { syntax })
1876         } else {
1877             None
1878         }
1879     }
1880     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1881 }
1882 impl AstNode for GenericParamList {
1883     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
1884     fn cast(syntax: SyntaxNode) -> Option<Self> {
1885         if Self::can_cast(syntax.kind()) {
1886             Some(Self { syntax })
1887         } else {
1888             None
1889         }
1890     }
1891     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1892 }
1893 impl AstNode for WhereClause {
1894     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
1895     fn cast(syntax: SyntaxNode) -> Option<Self> {
1896         if Self::can_cast(syntax.kind()) {
1897             Some(Self { syntax })
1898         } else {
1899             None
1900         }
1901     }
1902     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1903 }
1904 impl AstNode for BlockExpr {
1905     fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
1906     fn cast(syntax: SyntaxNode) -> Option<Self> {
1907         if Self::can_cast(syntax.kind()) {
1908             Some(Self { syntax })
1909         } else {
1910             None
1911         }
1912     }
1913     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1914 }
1915 impl AstNode for SelfParam {
1916     fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
1917     fn cast(syntax: SyntaxNode) -> Option<Self> {
1918         if Self::can_cast(syntax.kind()) {
1919             Some(Self { syntax })
1920         } else {
1921             None
1922         }
1923     }
1924     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1925 }
1926 impl AstNode for Param {
1927     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
1928     fn cast(syntax: SyntaxNode) -> Option<Self> {
1929         if Self::can_cast(syntax.kind()) {
1930             Some(Self { syntax })
1931         } else {
1932             None
1933         }
1934     }
1935     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1936 }
1937 impl AstNode for RecordFieldList {
1938     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
1939     fn cast(syntax: SyntaxNode) -> Option<Self> {
1940         if Self::can_cast(syntax.kind()) {
1941             Some(Self { syntax })
1942         } else {
1943             None
1944         }
1945     }
1946     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1947 }
1948 impl AstNode for TupleFieldList {
1949     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
1950     fn cast(syntax: SyntaxNode) -> Option<Self> {
1951         if Self::can_cast(syntax.kind()) {
1952             Some(Self { syntax })
1953         } else {
1954             None
1955         }
1956     }
1957     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1958 }
1959 impl AstNode for RecordField {
1960     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
1961     fn cast(syntax: SyntaxNode) -> Option<Self> {
1962         if Self::can_cast(syntax.kind()) {
1963             Some(Self { syntax })
1964         } else {
1965             None
1966         }
1967     }
1968     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1969 }
1970 impl AstNode for TupleField {
1971     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
1972     fn cast(syntax: SyntaxNode) -> Option<Self> {
1973         if Self::can_cast(syntax.kind()) {
1974             Some(Self { syntax })
1975         } else {
1976             None
1977         }
1978     }
1979     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1980 }
1981 impl AstNode for VariantList {
1982     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
1983     fn cast(syntax: SyntaxNode) -> Option<Self> {
1984         if Self::can_cast(syntax.kind()) {
1985             Some(Self { syntax })
1986         } else {
1987             None
1988         }
1989     }
1990     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1991 }
1992 impl AstNode for Variant {
1993     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
1994     fn cast(syntax: SyntaxNode) -> Option<Self> {
1995         if Self::can_cast(syntax.kind()) {
1996             Some(Self { syntax })
1997         } else {
1998             None
1999         }
2000     }
2001     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2002 }
2003 impl AstNode for AssocItemList {
2004     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
2005     fn cast(syntax: SyntaxNode) -> Option<Self> {
2006         if Self::can_cast(syntax.kind()) {
2007             Some(Self { syntax })
2008         } else {
2009             None
2010         }
2011     }
2012     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2013 }
2014 impl AstNode for ExternItemList {
2015     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
2016     fn cast(syntax: SyntaxNode) -> Option<Self> {
2017         if Self::can_cast(syntax.kind()) {
2018             Some(Self { syntax })
2019         } else {
2020             None
2021         }
2022     }
2023     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2024 }
2025 impl AstNode for ConstParam {
2026     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
2027     fn cast(syntax: SyntaxNode) -> Option<Self> {
2028         if Self::can_cast(syntax.kind()) {
2029             Some(Self { syntax })
2030         } else {
2031             None
2032         }
2033     }
2034     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2035 }
2036 impl AstNode for LifetimeParam {
2037     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
2038     fn cast(syntax: SyntaxNode) -> Option<Self> {
2039         if Self::can_cast(syntax.kind()) {
2040             Some(Self { syntax })
2041         } else {
2042             None
2043         }
2044     }
2045     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2046 }
2047 impl AstNode for TypeParam {
2048     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
2049     fn cast(syntax: SyntaxNode) -> Option<Self> {
2050         if Self::can_cast(syntax.kind()) {
2051             Some(Self { syntax })
2052         } else {
2053             None
2054         }
2055     }
2056     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2057 }
2058 impl AstNode for WherePred {
2059     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
2060     fn cast(syntax: SyntaxNode) -> Option<Self> {
2061         if Self::can_cast(syntax.kind()) {
2062             Some(Self { syntax })
2063         } else {
2064             None
2065         }
2066     }
2067     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2068 }
2069 impl AstNode for Literal {
2070     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
2071     fn cast(syntax: SyntaxNode) -> Option<Self> {
2072         if Self::can_cast(syntax.kind()) {
2073             Some(Self { syntax })
2074         } else {
2075             None
2076         }
2077     }
2078     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2079 }
2080 impl AstNode for ExprStmt {
2081     fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
2082     fn cast(syntax: SyntaxNode) -> Option<Self> {
2083         if Self::can_cast(syntax.kind()) {
2084             Some(Self { syntax })
2085         } else {
2086             None
2087         }
2088     }
2089     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2090 }
2091 impl AstNode for LetStmt {
2092     fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
2093     fn cast(syntax: SyntaxNode) -> Option<Self> {
2094         if Self::can_cast(syntax.kind()) {
2095             Some(Self { syntax })
2096         } else {
2097             None
2098         }
2099     }
2100     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2101 }
2102 impl AstNode for ArrayExpr {
2103     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
2104     fn cast(syntax: SyntaxNode) -> Option<Self> {
2105         if Self::can_cast(syntax.kind()) {
2106             Some(Self { syntax })
2107         } else {
2108             None
2109         }
2110     }
2111     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2112 }
2113 impl AstNode for AwaitExpr {
2114     fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
2115     fn cast(syntax: SyntaxNode) -> Option<Self> {
2116         if Self::can_cast(syntax.kind()) {
2117             Some(Self { syntax })
2118         } else {
2119             None
2120         }
2121     }
2122     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2123 }
2124 impl AstNode for BinExpr {
2125     fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
2126     fn cast(syntax: SyntaxNode) -> Option<Self> {
2127         if Self::can_cast(syntax.kind()) {
2128             Some(Self { syntax })
2129         } else {
2130             None
2131         }
2132     }
2133     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2134 }
2135 impl AstNode for BoxExpr {
2136     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR }
2137     fn cast(syntax: SyntaxNode) -> Option<Self> {
2138         if Self::can_cast(syntax.kind()) {
2139             Some(Self { syntax })
2140         } else {
2141             None
2142         }
2143     }
2144     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2145 }
2146 impl AstNode for BreakExpr {
2147     fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
2148     fn cast(syntax: SyntaxNode) -> Option<Self> {
2149         if Self::can_cast(syntax.kind()) {
2150             Some(Self { syntax })
2151         } else {
2152             None
2153         }
2154     }
2155     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2156 }
2157 impl AstNode for CallExpr {
2158     fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
2159     fn cast(syntax: SyntaxNode) -> Option<Self> {
2160         if Self::can_cast(syntax.kind()) {
2161             Some(Self { syntax })
2162         } else {
2163             None
2164         }
2165     }
2166     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2167 }
2168 impl AstNode for CastExpr {
2169     fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
2170     fn cast(syntax: SyntaxNode) -> Option<Self> {
2171         if Self::can_cast(syntax.kind()) {
2172             Some(Self { syntax })
2173         } else {
2174             None
2175         }
2176     }
2177     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2178 }
2179 impl AstNode for ClosureExpr {
2180     fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
2181     fn cast(syntax: SyntaxNode) -> Option<Self> {
2182         if Self::can_cast(syntax.kind()) {
2183             Some(Self { syntax })
2184         } else {
2185             None
2186         }
2187     }
2188     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2189 }
2190 impl AstNode for ContinueExpr {
2191     fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
2192     fn cast(syntax: SyntaxNode) -> Option<Self> {
2193         if Self::can_cast(syntax.kind()) {
2194             Some(Self { syntax })
2195         } else {
2196             None
2197         }
2198     }
2199     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2200 }
2201 impl AstNode for EffectExpr {
2202     fn can_cast(kind: SyntaxKind) -> bool { kind == EFFECT_EXPR }
2203     fn cast(syntax: SyntaxNode) -> Option<Self> {
2204         if Self::can_cast(syntax.kind()) {
2205             Some(Self { syntax })
2206         } else {
2207             None
2208         }
2209     }
2210     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2211 }
2212 impl AstNode for FieldExpr {
2213     fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
2214     fn cast(syntax: SyntaxNode) -> Option<Self> {
2215         if Self::can_cast(syntax.kind()) {
2216             Some(Self { syntax })
2217         } else {
2218             None
2219         }
2220     }
2221     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2222 }
2223 impl AstNode for ForExpr {
2224     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
2225     fn cast(syntax: SyntaxNode) -> Option<Self> {
2226         if Self::can_cast(syntax.kind()) {
2227             Some(Self { syntax })
2228         } else {
2229             None
2230         }
2231     }
2232     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2233 }
2234 impl AstNode for IfExpr {
2235     fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
2236     fn cast(syntax: SyntaxNode) -> Option<Self> {
2237         if Self::can_cast(syntax.kind()) {
2238             Some(Self { syntax })
2239         } else {
2240             None
2241         }
2242     }
2243     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2244 }
2245 impl AstNode for IndexExpr {
2246     fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
2247     fn cast(syntax: SyntaxNode) -> Option<Self> {
2248         if Self::can_cast(syntax.kind()) {
2249             Some(Self { syntax })
2250         } else {
2251             None
2252         }
2253     }
2254     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2255 }
2256 impl AstNode for LoopExpr {
2257     fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
2258     fn cast(syntax: SyntaxNode) -> Option<Self> {
2259         if Self::can_cast(syntax.kind()) {
2260             Some(Self { syntax })
2261         } else {
2262             None
2263         }
2264     }
2265     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2266 }
2267 impl AstNode for MatchExpr {
2268     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
2269     fn cast(syntax: SyntaxNode) -> Option<Self> {
2270         if Self::can_cast(syntax.kind()) {
2271             Some(Self { syntax })
2272         } else {
2273             None
2274         }
2275     }
2276     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2277 }
2278 impl AstNode for MethodCallExpr {
2279     fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
2280     fn cast(syntax: SyntaxNode) -> Option<Self> {
2281         if Self::can_cast(syntax.kind()) {
2282             Some(Self { syntax })
2283         } else {
2284             None
2285         }
2286     }
2287     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2288 }
2289 impl AstNode for ParenExpr {
2290     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
2291     fn cast(syntax: SyntaxNode) -> Option<Self> {
2292         if Self::can_cast(syntax.kind()) {
2293             Some(Self { syntax })
2294         } else {
2295             None
2296         }
2297     }
2298     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2299 }
2300 impl AstNode for PathExpr {
2301     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
2302     fn cast(syntax: SyntaxNode) -> Option<Self> {
2303         if Self::can_cast(syntax.kind()) {
2304             Some(Self { syntax })
2305         } else {
2306             None
2307         }
2308     }
2309     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2310 }
2311 impl AstNode for PrefixExpr {
2312     fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
2313     fn cast(syntax: SyntaxNode) -> Option<Self> {
2314         if Self::can_cast(syntax.kind()) {
2315             Some(Self { syntax })
2316         } else {
2317             None
2318         }
2319     }
2320     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2321 }
2322 impl AstNode for RangeExpr {
2323     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
2324     fn cast(syntax: SyntaxNode) -> Option<Self> {
2325         if Self::can_cast(syntax.kind()) {
2326             Some(Self { syntax })
2327         } else {
2328             None
2329         }
2330     }
2331     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2332 }
2333 impl AstNode for RecordExpr {
2334     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
2335     fn cast(syntax: SyntaxNode) -> Option<Self> {
2336         if Self::can_cast(syntax.kind()) {
2337             Some(Self { syntax })
2338         } else {
2339             None
2340         }
2341     }
2342     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2343 }
2344 impl AstNode for RefExpr {
2345     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
2346     fn cast(syntax: SyntaxNode) -> Option<Self> {
2347         if Self::can_cast(syntax.kind()) {
2348             Some(Self { syntax })
2349         } else {
2350             None
2351         }
2352     }
2353     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2354 }
2355 impl AstNode for ReturnExpr {
2356     fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
2357     fn cast(syntax: SyntaxNode) -> Option<Self> {
2358         if Self::can_cast(syntax.kind()) {
2359             Some(Self { syntax })
2360         } else {
2361             None
2362         }
2363     }
2364     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2365 }
2366 impl AstNode for TryExpr {
2367     fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
2368     fn cast(syntax: SyntaxNode) -> Option<Self> {
2369         if Self::can_cast(syntax.kind()) {
2370             Some(Self { syntax })
2371         } else {
2372             None
2373         }
2374     }
2375     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2376 }
2377 impl AstNode for TupleExpr {
2378     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
2379     fn cast(syntax: SyntaxNode) -> Option<Self> {
2380         if Self::can_cast(syntax.kind()) {
2381             Some(Self { syntax })
2382         } else {
2383             None
2384         }
2385     }
2386     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2387 }
2388 impl AstNode for WhileExpr {
2389     fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
2390     fn cast(syntax: SyntaxNode) -> Option<Self> {
2391         if Self::can_cast(syntax.kind()) {
2392             Some(Self { syntax })
2393         } else {
2394             None
2395         }
2396     }
2397     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2398 }
2399 impl AstNode for YieldExpr {
2400     fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR }
2401     fn cast(syntax: SyntaxNode) -> Option<Self> {
2402         if Self::can_cast(syntax.kind()) {
2403             Some(Self { syntax })
2404         } else {
2405             None
2406         }
2407     }
2408     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2409 }
2410 impl AstNode for Label {
2411     fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
2412     fn cast(syntax: SyntaxNode) -> Option<Self> {
2413         if Self::can_cast(syntax.kind()) {
2414             Some(Self { syntax })
2415         } else {
2416             None
2417         }
2418     }
2419     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2420 }
2421 impl AstNode for RecordExprFieldList {
2422     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
2423     fn cast(syntax: SyntaxNode) -> Option<Self> {
2424         if Self::can_cast(syntax.kind()) {
2425             Some(Self { syntax })
2426         } else {
2427             None
2428         }
2429     }
2430     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2431 }
2432 impl AstNode for RecordExprField {
2433     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
2434     fn cast(syntax: SyntaxNode) -> Option<Self> {
2435         if Self::can_cast(syntax.kind()) {
2436             Some(Self { syntax })
2437         } else {
2438             None
2439         }
2440     }
2441     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2442 }
2443 impl AstNode for ArgList {
2444     fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
2445     fn cast(syntax: SyntaxNode) -> Option<Self> {
2446         if Self::can_cast(syntax.kind()) {
2447             Some(Self { syntax })
2448         } else {
2449             None
2450         }
2451     }
2452     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2453 }
2454 impl AstNode for Condition {
2455     fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION }
2456     fn cast(syntax: SyntaxNode) -> Option<Self> {
2457         if Self::can_cast(syntax.kind()) {
2458             Some(Self { syntax })
2459         } else {
2460             None
2461         }
2462     }
2463     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2464 }
2465 impl AstNode for MatchArmList {
2466     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
2467     fn cast(syntax: SyntaxNode) -> Option<Self> {
2468         if Self::can_cast(syntax.kind()) {
2469             Some(Self { syntax })
2470         } else {
2471             None
2472         }
2473     }
2474     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2475 }
2476 impl AstNode for MatchArm {
2477     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
2478     fn cast(syntax: SyntaxNode) -> Option<Self> {
2479         if Self::can_cast(syntax.kind()) {
2480             Some(Self { syntax })
2481         } else {
2482             None
2483         }
2484     }
2485     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2486 }
2487 impl AstNode for MatchGuard {
2488     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
2489     fn cast(syntax: SyntaxNode) -> Option<Self> {
2490         if Self::can_cast(syntax.kind()) {
2491             Some(Self { syntax })
2492         } else {
2493             None
2494         }
2495     }
2496     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2497 }
2498 impl AstNode for ArrayType {
2499     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
2500     fn cast(syntax: SyntaxNode) -> Option<Self> {
2501         if Self::can_cast(syntax.kind()) {
2502             Some(Self { syntax })
2503         } else {
2504             None
2505         }
2506     }
2507     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2508 }
2509 impl AstNode for DynTraitType {
2510     fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
2511     fn cast(syntax: SyntaxNode) -> Option<Self> {
2512         if Self::can_cast(syntax.kind()) {
2513             Some(Self { syntax })
2514         } else {
2515             None
2516         }
2517     }
2518     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2519 }
2520 impl AstNode for FnPtrType {
2521     fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
2522     fn cast(syntax: SyntaxNode) -> Option<Self> {
2523         if Self::can_cast(syntax.kind()) {
2524             Some(Self { syntax })
2525         } else {
2526             None
2527         }
2528     }
2529     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2530 }
2531 impl AstNode for ForType {
2532     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
2533     fn cast(syntax: SyntaxNode) -> Option<Self> {
2534         if Self::can_cast(syntax.kind()) {
2535             Some(Self { syntax })
2536         } else {
2537             None
2538         }
2539     }
2540     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2541 }
2542 impl AstNode for ImplTraitType {
2543     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
2544     fn cast(syntax: SyntaxNode) -> Option<Self> {
2545         if Self::can_cast(syntax.kind()) {
2546             Some(Self { syntax })
2547         } else {
2548             None
2549         }
2550     }
2551     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2552 }
2553 impl AstNode for InferType {
2554     fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
2555     fn cast(syntax: SyntaxNode) -> Option<Self> {
2556         if Self::can_cast(syntax.kind()) {
2557             Some(Self { syntax })
2558         } else {
2559             None
2560         }
2561     }
2562     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2563 }
2564 impl AstNode for NeverType {
2565     fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
2566     fn cast(syntax: SyntaxNode) -> Option<Self> {
2567         if Self::can_cast(syntax.kind()) {
2568             Some(Self { syntax })
2569         } else {
2570             None
2571         }
2572     }
2573     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2574 }
2575 impl AstNode for ParenType {
2576     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
2577     fn cast(syntax: SyntaxNode) -> Option<Self> {
2578         if Self::can_cast(syntax.kind()) {
2579             Some(Self { syntax })
2580         } else {
2581             None
2582         }
2583     }
2584     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2585 }
2586 impl AstNode for PtrType {
2587     fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
2588     fn cast(syntax: SyntaxNode) -> Option<Self> {
2589         if Self::can_cast(syntax.kind()) {
2590             Some(Self { syntax })
2591         } else {
2592             None
2593         }
2594     }
2595     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2596 }
2597 impl AstNode for RefType {
2598     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
2599     fn cast(syntax: SyntaxNode) -> Option<Self> {
2600         if Self::can_cast(syntax.kind()) {
2601             Some(Self { syntax })
2602         } else {
2603             None
2604         }
2605     }
2606     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2607 }
2608 impl AstNode for SliceType {
2609     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
2610     fn cast(syntax: SyntaxNode) -> Option<Self> {
2611         if Self::can_cast(syntax.kind()) {
2612             Some(Self { syntax })
2613         } else {
2614             None
2615         }
2616     }
2617     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2618 }
2619 impl AstNode for TupleType {
2620     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
2621     fn cast(syntax: SyntaxNode) -> Option<Self> {
2622         if Self::can_cast(syntax.kind()) {
2623             Some(Self { syntax })
2624         } else {
2625             None
2626         }
2627     }
2628     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2629 }
2630 impl AstNode for TypeBound {
2631     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
2632     fn cast(syntax: SyntaxNode) -> Option<Self> {
2633         if Self::can_cast(syntax.kind()) {
2634             Some(Self { syntax })
2635         } else {
2636             None
2637         }
2638     }
2639     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2640 }
2641 impl AstNode for IdentPat {
2642     fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
2643     fn cast(syntax: SyntaxNode) -> Option<Self> {
2644         if Self::can_cast(syntax.kind()) {
2645             Some(Self { syntax })
2646         } else {
2647             None
2648         }
2649     }
2650     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2651 }
2652 impl AstNode for BoxPat {
2653     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
2654     fn cast(syntax: SyntaxNode) -> Option<Self> {
2655         if Self::can_cast(syntax.kind()) {
2656             Some(Self { syntax })
2657         } else {
2658             None
2659         }
2660     }
2661     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2662 }
2663 impl AstNode for RestPat {
2664     fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
2665     fn cast(syntax: SyntaxNode) -> Option<Self> {
2666         if Self::can_cast(syntax.kind()) {
2667             Some(Self { syntax })
2668         } else {
2669             None
2670         }
2671     }
2672     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2673 }
2674 impl AstNode for LiteralPat {
2675     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
2676     fn cast(syntax: SyntaxNode) -> Option<Self> {
2677         if Self::can_cast(syntax.kind()) {
2678             Some(Self { syntax })
2679         } else {
2680             None
2681         }
2682     }
2683     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2684 }
2685 impl AstNode for MacroPat {
2686     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
2687     fn cast(syntax: SyntaxNode) -> Option<Self> {
2688         if Self::can_cast(syntax.kind()) {
2689             Some(Self { syntax })
2690         } else {
2691             None
2692         }
2693     }
2694     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2695 }
2696 impl AstNode for OrPat {
2697     fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
2698     fn cast(syntax: SyntaxNode) -> Option<Self> {
2699         if Self::can_cast(syntax.kind()) {
2700             Some(Self { syntax })
2701         } else {
2702             None
2703         }
2704     }
2705     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2706 }
2707 impl AstNode for ParenPat {
2708     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
2709     fn cast(syntax: SyntaxNode) -> Option<Self> {
2710         if Self::can_cast(syntax.kind()) {
2711             Some(Self { syntax })
2712         } else {
2713             None
2714         }
2715     }
2716     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2717 }
2718 impl AstNode for PathPat {
2719     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
2720     fn cast(syntax: SyntaxNode) -> Option<Self> {
2721         if Self::can_cast(syntax.kind()) {
2722             Some(Self { syntax })
2723         } else {
2724             None
2725         }
2726     }
2727     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2728 }
2729 impl AstNode for WildcardPat {
2730     fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
2731     fn cast(syntax: SyntaxNode) -> Option<Self> {
2732         if Self::can_cast(syntax.kind()) {
2733             Some(Self { syntax })
2734         } else {
2735             None
2736         }
2737     }
2738     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2739 }
2740 impl AstNode for RangePat {
2741     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
2742     fn cast(syntax: SyntaxNode) -> Option<Self> {
2743         if Self::can_cast(syntax.kind()) {
2744             Some(Self { syntax })
2745         } else {
2746             None
2747         }
2748     }
2749     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2750 }
2751 impl AstNode for RecordPat {
2752     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
2753     fn cast(syntax: SyntaxNode) -> Option<Self> {
2754         if Self::can_cast(syntax.kind()) {
2755             Some(Self { syntax })
2756         } else {
2757             None
2758         }
2759     }
2760     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2761 }
2762 impl AstNode for RefPat {
2763     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
2764     fn cast(syntax: SyntaxNode) -> Option<Self> {
2765         if Self::can_cast(syntax.kind()) {
2766             Some(Self { syntax })
2767         } else {
2768             None
2769         }
2770     }
2771     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2772 }
2773 impl AstNode for SlicePat {
2774     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
2775     fn cast(syntax: SyntaxNode) -> Option<Self> {
2776         if Self::can_cast(syntax.kind()) {
2777             Some(Self { syntax })
2778         } else {
2779             None
2780         }
2781     }
2782     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2783 }
2784 impl AstNode for TuplePat {
2785     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
2786     fn cast(syntax: SyntaxNode) -> Option<Self> {
2787         if Self::can_cast(syntax.kind()) {
2788             Some(Self { syntax })
2789         } else {
2790             None
2791         }
2792     }
2793     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2794 }
2795 impl AstNode for TupleStructPat {
2796     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
2797     fn cast(syntax: SyntaxNode) -> Option<Self> {
2798         if Self::can_cast(syntax.kind()) {
2799             Some(Self { syntax })
2800         } else {
2801             None
2802         }
2803     }
2804     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2805 }
2806 impl AstNode for ConstBlockPat {
2807     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
2808     fn cast(syntax: SyntaxNode) -> Option<Self> {
2809         if Self::can_cast(syntax.kind()) {
2810             Some(Self { syntax })
2811         } else {
2812             None
2813         }
2814     }
2815     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2816 }
2817 impl AstNode for RecordPatFieldList {
2818     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
2819     fn cast(syntax: SyntaxNode) -> Option<Self> {
2820         if Self::can_cast(syntax.kind()) {
2821             Some(Self { syntax })
2822         } else {
2823             None
2824         }
2825     }
2826     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2827 }
2828 impl AstNode for RecordPatField {
2829     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
2830     fn cast(syntax: SyntaxNode) -> Option<Self> {
2831         if Self::can_cast(syntax.kind()) {
2832             Some(Self { syntax })
2833         } else {
2834             None
2835         }
2836     }
2837     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2838 }
2839 impl From<TypeArg> for GenericArg {
2840     fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
2841 }
2842 impl From<AssocTypeArg> for GenericArg {
2843     fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
2844 }
2845 impl From<LifetimeArg> for GenericArg {
2846     fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
2847 }
2848 impl From<ConstArg> for GenericArg {
2849     fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
2850 }
2851 impl AstNode for GenericArg {
2852     fn can_cast(kind: SyntaxKind) -> bool {
2853         match kind {
2854             TYPE_ARG | ASSOC_TYPE_ARG | LIFETIME_ARG | CONST_ARG => true,
2855             _ => false,
2856         }
2857     }
2858     fn cast(syntax: SyntaxNode) -> Option<Self> {
2859         let res = match syntax.kind() {
2860             TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
2861             ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
2862             LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
2863             CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
2864             _ => return None,
2865         };
2866         Some(res)
2867     }
2868     fn syntax(&self) -> &SyntaxNode {
2869         match self {
2870             GenericArg::TypeArg(it) => &it.syntax,
2871             GenericArg::AssocTypeArg(it) => &it.syntax,
2872             GenericArg::LifetimeArg(it) => &it.syntax,
2873             GenericArg::ConstArg(it) => &it.syntax,
2874         }
2875     }
2876 }
2877 impl From<ArrayType> for Type {
2878     fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
2879 }
2880 impl From<DynTraitType> for Type {
2881     fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
2882 }
2883 impl From<FnPtrType> for Type {
2884     fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
2885 }
2886 impl From<ForType> for Type {
2887     fn from(node: ForType) -> Type { Type::ForType(node) }
2888 }
2889 impl From<ImplTraitType> for Type {
2890     fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
2891 }
2892 impl From<InferType> for Type {
2893     fn from(node: InferType) -> Type { Type::InferType(node) }
2894 }
2895 impl From<NeverType> for Type {
2896     fn from(node: NeverType) -> Type { Type::NeverType(node) }
2897 }
2898 impl From<ParenType> for Type {
2899     fn from(node: ParenType) -> Type { Type::ParenType(node) }
2900 }
2901 impl From<PathType> for Type {
2902     fn from(node: PathType) -> Type { Type::PathType(node) }
2903 }
2904 impl From<PtrType> for Type {
2905     fn from(node: PtrType) -> Type { Type::PtrType(node) }
2906 }
2907 impl From<RefType> for Type {
2908     fn from(node: RefType) -> Type { Type::RefType(node) }
2909 }
2910 impl From<SliceType> for Type {
2911     fn from(node: SliceType) -> Type { Type::SliceType(node) }
2912 }
2913 impl From<TupleType> for Type {
2914     fn from(node: TupleType) -> Type { Type::TupleType(node) }
2915 }
2916 impl AstNode for Type {
2917     fn can_cast(kind: SyntaxKind) -> bool {
2918         match kind {
2919             ARRAY_TYPE | DYN_TRAIT_TYPE | FN_PTR_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE | INFER_TYPE
2920             | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE | SLICE_TYPE
2921             | TUPLE_TYPE => true,
2922             _ => false,
2923         }
2924     }
2925     fn cast(syntax: SyntaxNode) -> Option<Self> {
2926         let res = match syntax.kind() {
2927             ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
2928             DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
2929             FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
2930             FOR_TYPE => Type::ForType(ForType { syntax }),
2931             IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
2932             INFER_TYPE => Type::InferType(InferType { syntax }),
2933             NEVER_TYPE => Type::NeverType(NeverType { syntax }),
2934             PAREN_TYPE => Type::ParenType(ParenType { syntax }),
2935             PATH_TYPE => Type::PathType(PathType { syntax }),
2936             PTR_TYPE => Type::PtrType(PtrType { syntax }),
2937             REF_TYPE => Type::RefType(RefType { syntax }),
2938             SLICE_TYPE => Type::SliceType(SliceType { syntax }),
2939             TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
2940             _ => return None,
2941         };
2942         Some(res)
2943     }
2944     fn syntax(&self) -> &SyntaxNode {
2945         match self {
2946             Type::ArrayType(it) => &it.syntax,
2947             Type::DynTraitType(it) => &it.syntax,
2948             Type::FnPtrType(it) => &it.syntax,
2949             Type::ForType(it) => &it.syntax,
2950             Type::ImplTraitType(it) => &it.syntax,
2951             Type::InferType(it) => &it.syntax,
2952             Type::NeverType(it) => &it.syntax,
2953             Type::ParenType(it) => &it.syntax,
2954             Type::PathType(it) => &it.syntax,
2955             Type::PtrType(it) => &it.syntax,
2956             Type::RefType(it) => &it.syntax,
2957             Type::SliceType(it) => &it.syntax,
2958             Type::TupleType(it) => &it.syntax,
2959         }
2960     }
2961 }
2962 impl From<ArrayExpr> for Expr {
2963     fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
2964 }
2965 impl From<AwaitExpr> for Expr {
2966     fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
2967 }
2968 impl From<BinExpr> for Expr {
2969     fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
2970 }
2971 impl From<BlockExpr> for Expr {
2972     fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
2973 }
2974 impl From<BoxExpr> for Expr {
2975     fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
2976 }
2977 impl From<BreakExpr> for Expr {
2978     fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
2979 }
2980 impl From<CallExpr> for Expr {
2981     fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
2982 }
2983 impl From<CastExpr> for Expr {
2984     fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
2985 }
2986 impl From<ClosureExpr> for Expr {
2987     fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
2988 }
2989 impl From<ContinueExpr> for Expr {
2990     fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
2991 }
2992 impl From<EffectExpr> for Expr {
2993     fn from(node: EffectExpr) -> Expr { Expr::EffectExpr(node) }
2994 }
2995 impl From<FieldExpr> for Expr {
2996     fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
2997 }
2998 impl From<ForExpr> for Expr {
2999     fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
3000 }
3001 impl From<IfExpr> for Expr {
3002     fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
3003 }
3004 impl From<IndexExpr> for Expr {
3005     fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
3006 }
3007 impl From<Literal> for Expr {
3008     fn from(node: Literal) -> Expr { Expr::Literal(node) }
3009 }
3010 impl From<LoopExpr> for Expr {
3011     fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
3012 }
3013 impl From<MacroCall> for Expr {
3014     fn from(node: MacroCall) -> Expr { Expr::MacroCall(node) }
3015 }
3016 impl From<MatchExpr> for Expr {
3017     fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
3018 }
3019 impl From<MethodCallExpr> for Expr {
3020     fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
3021 }
3022 impl From<ParenExpr> for Expr {
3023     fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
3024 }
3025 impl From<PathExpr> for Expr {
3026     fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
3027 }
3028 impl From<PrefixExpr> for Expr {
3029     fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
3030 }
3031 impl From<RangeExpr> for Expr {
3032     fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
3033 }
3034 impl From<RecordExpr> for Expr {
3035     fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
3036 }
3037 impl From<RefExpr> for Expr {
3038     fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
3039 }
3040 impl From<ReturnExpr> for Expr {
3041     fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
3042 }
3043 impl From<TryExpr> for Expr {
3044     fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
3045 }
3046 impl From<TupleExpr> for Expr {
3047     fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
3048 }
3049 impl From<WhileExpr> for Expr {
3050     fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
3051 }
3052 impl From<YieldExpr> for Expr {
3053     fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) }
3054 }
3055 impl AstNode for Expr {
3056     fn can_cast(kind: SyntaxKind) -> bool {
3057         match kind {
3058             ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR
3059             | CAST_EXPR | CLOSURE_EXPR | CONTINUE_EXPR | EFFECT_EXPR | FIELD_EXPR | FOR_EXPR
3060             | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR
3061             | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
3062             | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR
3063             | YIELD_EXPR => true,
3064             _ => false,
3065         }
3066     }
3067     fn cast(syntax: SyntaxNode) -> Option<Self> {
3068         let res = match syntax.kind() {
3069             ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
3070             AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
3071             BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
3072             BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
3073             BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
3074             BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
3075             CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
3076             CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
3077             CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
3078             CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
3079             EFFECT_EXPR => Expr::EffectExpr(EffectExpr { syntax }),
3080             FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
3081             FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
3082             IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
3083             INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
3084             LITERAL => Expr::Literal(Literal { syntax }),
3085             LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
3086             MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
3087             MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
3088             METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
3089             PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
3090             PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
3091             PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
3092             RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
3093             RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
3094             REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
3095             RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
3096             TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
3097             TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
3098             WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
3099             YIELD_EXPR => Expr::YieldExpr(YieldExpr { syntax }),
3100             _ => return None,
3101         };
3102         Some(res)
3103     }
3104     fn syntax(&self) -> &SyntaxNode {
3105         match self {
3106             Expr::ArrayExpr(it) => &it.syntax,
3107             Expr::AwaitExpr(it) => &it.syntax,
3108             Expr::BinExpr(it) => &it.syntax,
3109             Expr::BlockExpr(it) => &it.syntax,
3110             Expr::BoxExpr(it) => &it.syntax,
3111             Expr::BreakExpr(it) => &it.syntax,
3112             Expr::CallExpr(it) => &it.syntax,
3113             Expr::CastExpr(it) => &it.syntax,
3114             Expr::ClosureExpr(it) => &it.syntax,
3115             Expr::ContinueExpr(it) => &it.syntax,
3116             Expr::EffectExpr(it) => &it.syntax,
3117             Expr::FieldExpr(it) => &it.syntax,
3118             Expr::ForExpr(it) => &it.syntax,
3119             Expr::IfExpr(it) => &it.syntax,
3120             Expr::IndexExpr(it) => &it.syntax,
3121             Expr::Literal(it) => &it.syntax,
3122             Expr::LoopExpr(it) => &it.syntax,
3123             Expr::MacroCall(it) => &it.syntax,
3124             Expr::MatchExpr(it) => &it.syntax,
3125             Expr::MethodCallExpr(it) => &it.syntax,
3126             Expr::ParenExpr(it) => &it.syntax,
3127             Expr::PathExpr(it) => &it.syntax,
3128             Expr::PrefixExpr(it) => &it.syntax,
3129             Expr::RangeExpr(it) => &it.syntax,
3130             Expr::RecordExpr(it) => &it.syntax,
3131             Expr::RefExpr(it) => &it.syntax,
3132             Expr::ReturnExpr(it) => &it.syntax,
3133             Expr::TryExpr(it) => &it.syntax,
3134             Expr::TupleExpr(it) => &it.syntax,
3135             Expr::WhileExpr(it) => &it.syntax,
3136             Expr::YieldExpr(it) => &it.syntax,
3137         }
3138     }
3139 }
3140 impl From<Const> for Item {
3141     fn from(node: Const) -> Item { Item::Const(node) }
3142 }
3143 impl From<Enum> for Item {
3144     fn from(node: Enum) -> Item { Item::Enum(node) }
3145 }
3146 impl From<ExternBlock> for Item {
3147     fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
3148 }
3149 impl From<ExternCrate> for Item {
3150     fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
3151 }
3152 impl From<Fn> for Item {
3153     fn from(node: Fn) -> Item { Item::Fn(node) }
3154 }
3155 impl From<Impl> for Item {
3156     fn from(node: Impl) -> Item { Item::Impl(node) }
3157 }
3158 impl From<MacroCall> for Item {
3159     fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
3160 }
3161 impl From<MacroRules> for Item {
3162     fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
3163 }
3164 impl From<MacroDef> for Item {
3165     fn from(node: MacroDef) -> Item { Item::MacroDef(node) }
3166 }
3167 impl From<Module> for Item {
3168     fn from(node: Module) -> Item { Item::Module(node) }
3169 }
3170 impl From<Static> for Item {
3171     fn from(node: Static) -> Item { Item::Static(node) }
3172 }
3173 impl From<Struct> for Item {
3174     fn from(node: Struct) -> Item { Item::Struct(node) }
3175 }
3176 impl From<Trait> for Item {
3177     fn from(node: Trait) -> Item { Item::Trait(node) }
3178 }
3179 impl From<TypeAlias> for Item {
3180     fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
3181 }
3182 impl From<Union> for Item {
3183     fn from(node: Union) -> Item { Item::Union(node) }
3184 }
3185 impl From<Use> for Item {
3186     fn from(node: Use) -> Item { Item::Use(node) }
3187 }
3188 impl AstNode for Item {
3189     fn can_cast(kind: SyntaxKind) -> bool {
3190         match kind {
3191             CONST | ENUM | EXTERN_BLOCK | EXTERN_CRATE | FN | IMPL | MACRO_CALL | MACRO_RULES
3192             | MACRO_DEF | MODULE | STATIC | STRUCT | TRAIT | TYPE_ALIAS | UNION | USE => true,
3193             _ => false,
3194         }
3195     }
3196     fn cast(syntax: SyntaxNode) -> Option<Self> {
3197         let res = match syntax.kind() {
3198             CONST => Item::Const(Const { syntax }),
3199             ENUM => Item::Enum(Enum { syntax }),
3200             EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
3201             EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
3202             FN => Item::Fn(Fn { syntax }),
3203             IMPL => Item::Impl(Impl { syntax }),
3204             MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
3205             MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
3206             MACRO_DEF => Item::MacroDef(MacroDef { syntax }),
3207             MODULE => Item::Module(Module { syntax }),
3208             STATIC => Item::Static(Static { syntax }),
3209             STRUCT => Item::Struct(Struct { syntax }),
3210             TRAIT => Item::Trait(Trait { syntax }),
3211             TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
3212             UNION => Item::Union(Union { syntax }),
3213             USE => Item::Use(Use { syntax }),
3214             _ => return None,
3215         };
3216         Some(res)
3217     }
3218     fn syntax(&self) -> &SyntaxNode {
3219         match self {
3220             Item::Const(it) => &it.syntax,
3221             Item::Enum(it) => &it.syntax,
3222             Item::ExternBlock(it) => &it.syntax,
3223             Item::ExternCrate(it) => &it.syntax,
3224             Item::Fn(it) => &it.syntax,
3225             Item::Impl(it) => &it.syntax,
3226             Item::MacroCall(it) => &it.syntax,
3227             Item::MacroRules(it) => &it.syntax,
3228             Item::MacroDef(it) => &it.syntax,
3229             Item::Module(it) => &it.syntax,
3230             Item::Static(it) => &it.syntax,
3231             Item::Struct(it) => &it.syntax,
3232             Item::Trait(it) => &it.syntax,
3233             Item::TypeAlias(it) => &it.syntax,
3234             Item::Union(it) => &it.syntax,
3235             Item::Use(it) => &it.syntax,
3236         }
3237     }
3238 }
3239 impl From<ExprStmt> for Stmt {
3240     fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
3241 }
3242 impl From<Item> for Stmt {
3243     fn from(node: Item) -> Stmt { Stmt::Item(node) }
3244 }
3245 impl From<LetStmt> for Stmt {
3246     fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
3247 }
3248 impl From<IdentPat> for Pat {
3249     fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
3250 }
3251 impl From<BoxPat> for Pat {
3252     fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
3253 }
3254 impl From<RestPat> for Pat {
3255     fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
3256 }
3257 impl From<LiteralPat> for Pat {
3258     fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
3259 }
3260 impl From<MacroPat> for Pat {
3261     fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
3262 }
3263 impl From<OrPat> for Pat {
3264     fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
3265 }
3266 impl From<ParenPat> for Pat {
3267     fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
3268 }
3269 impl From<PathPat> for Pat {
3270     fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
3271 }
3272 impl From<WildcardPat> for Pat {
3273     fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
3274 }
3275 impl From<RangePat> for Pat {
3276     fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
3277 }
3278 impl From<RecordPat> for Pat {
3279     fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
3280 }
3281 impl From<RefPat> for Pat {
3282     fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
3283 }
3284 impl From<SlicePat> for Pat {
3285     fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
3286 }
3287 impl From<TuplePat> for Pat {
3288     fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
3289 }
3290 impl From<TupleStructPat> for Pat {
3291     fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
3292 }
3293 impl From<ConstBlockPat> for Pat {
3294     fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
3295 }
3296 impl AstNode for Pat {
3297     fn can_cast(kind: SyntaxKind) -> bool {
3298         match kind {
3299             IDENT_PAT | BOX_PAT | REST_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT
3300             | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT
3301             | TUPLE_PAT | TUPLE_STRUCT_PAT | CONST_BLOCK_PAT => true,
3302             _ => false,
3303         }
3304     }
3305     fn cast(syntax: SyntaxNode) -> Option<Self> {
3306         let res = match syntax.kind() {
3307             IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
3308             BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
3309             REST_PAT => Pat::RestPat(RestPat { syntax }),
3310             LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
3311             MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
3312             OR_PAT => Pat::OrPat(OrPat { syntax }),
3313             PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
3314             PATH_PAT => Pat::PathPat(PathPat { syntax }),
3315             WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
3316             RANGE_PAT => Pat::RangePat(RangePat { syntax }),
3317             RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
3318             REF_PAT => Pat::RefPat(RefPat { syntax }),
3319             SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
3320             TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
3321             TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
3322             CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
3323             _ => return None,
3324         };
3325         Some(res)
3326     }
3327     fn syntax(&self) -> &SyntaxNode {
3328         match self {
3329             Pat::IdentPat(it) => &it.syntax,
3330             Pat::BoxPat(it) => &it.syntax,
3331             Pat::RestPat(it) => &it.syntax,
3332             Pat::LiteralPat(it) => &it.syntax,
3333             Pat::MacroPat(it) => &it.syntax,
3334             Pat::OrPat(it) => &it.syntax,
3335             Pat::ParenPat(it) => &it.syntax,
3336             Pat::PathPat(it) => &it.syntax,
3337             Pat::WildcardPat(it) => &it.syntax,
3338             Pat::RangePat(it) => &it.syntax,
3339             Pat::RecordPat(it) => &it.syntax,
3340             Pat::RefPat(it) => &it.syntax,
3341             Pat::SlicePat(it) => &it.syntax,
3342             Pat::TuplePat(it) => &it.syntax,
3343             Pat::TupleStructPat(it) => &it.syntax,
3344             Pat::ConstBlockPat(it) => &it.syntax,
3345         }
3346     }
3347 }
3348 impl From<RecordFieldList> for FieldList {
3349     fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
3350 }
3351 impl From<TupleFieldList> for FieldList {
3352     fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
3353 }
3354 impl AstNode for FieldList {
3355     fn can_cast(kind: SyntaxKind) -> bool {
3356         match kind {
3357             RECORD_FIELD_LIST | TUPLE_FIELD_LIST => true,
3358             _ => false,
3359         }
3360     }
3361     fn cast(syntax: SyntaxNode) -> Option<Self> {
3362         let res = match syntax.kind() {
3363             RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
3364             TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
3365             _ => return None,
3366         };
3367         Some(res)
3368     }
3369     fn syntax(&self) -> &SyntaxNode {
3370         match self {
3371             FieldList::RecordFieldList(it) => &it.syntax,
3372             FieldList::TupleFieldList(it) => &it.syntax,
3373         }
3374     }
3375 }
3376 impl From<Enum> for AdtDef {
3377     fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
3378 }
3379 impl From<Struct> for AdtDef {
3380     fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
3381 }
3382 impl From<Union> for AdtDef {
3383     fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
3384 }
3385 impl AstNode for AdtDef {
3386     fn can_cast(kind: SyntaxKind) -> bool {
3387         match kind {
3388             ENUM | STRUCT | UNION => true,
3389             _ => false,
3390         }
3391     }
3392     fn cast(syntax: SyntaxNode) -> Option<Self> {
3393         let res = match syntax.kind() {
3394             ENUM => AdtDef::Enum(Enum { syntax }),
3395             STRUCT => AdtDef::Struct(Struct { syntax }),
3396             UNION => AdtDef::Union(Union { syntax }),
3397             _ => return None,
3398         };
3399         Some(res)
3400     }
3401     fn syntax(&self) -> &SyntaxNode {
3402         match self {
3403             AdtDef::Enum(it) => &it.syntax,
3404             AdtDef::Struct(it) => &it.syntax,
3405             AdtDef::Union(it) => &it.syntax,
3406         }
3407     }
3408 }
3409 impl From<Const> for AssocItem {
3410     fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
3411 }
3412 impl From<Fn> for AssocItem {
3413     fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
3414 }
3415 impl From<MacroCall> for AssocItem {
3416     fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
3417 }
3418 impl From<TypeAlias> for AssocItem {
3419     fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
3420 }
3421 impl AstNode for AssocItem {
3422     fn can_cast(kind: SyntaxKind) -> bool {
3423         match kind {
3424             CONST | FN | MACRO_CALL | TYPE_ALIAS => true,
3425             _ => false,
3426         }
3427     }
3428     fn cast(syntax: SyntaxNode) -> Option<Self> {
3429         let res = match syntax.kind() {
3430             CONST => AssocItem::Const(Const { syntax }),
3431             FN => AssocItem::Fn(Fn { syntax }),
3432             MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
3433             TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
3434             _ => return None,
3435         };
3436         Some(res)
3437     }
3438     fn syntax(&self) -> &SyntaxNode {
3439         match self {
3440             AssocItem::Const(it) => &it.syntax,
3441             AssocItem::Fn(it) => &it.syntax,
3442             AssocItem::MacroCall(it) => &it.syntax,
3443             AssocItem::TypeAlias(it) => &it.syntax,
3444         }
3445     }
3446 }
3447 impl From<Fn> for ExternItem {
3448     fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
3449 }
3450 impl From<MacroCall> for ExternItem {
3451     fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
3452 }
3453 impl From<Static> for ExternItem {
3454     fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
3455 }
3456 impl From<TypeAlias> for ExternItem {
3457     fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) }
3458 }
3459 impl AstNode for ExternItem {
3460     fn can_cast(kind: SyntaxKind) -> bool {
3461         match kind {
3462             FN | MACRO_CALL | STATIC | TYPE_ALIAS => true,
3463             _ => false,
3464         }
3465     }
3466     fn cast(syntax: SyntaxNode) -> Option<Self> {
3467         let res = match syntax.kind() {
3468             FN => ExternItem::Fn(Fn { syntax }),
3469             MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
3470             STATIC => ExternItem::Static(Static { syntax }),
3471             TYPE_ALIAS => ExternItem::TypeAlias(TypeAlias { syntax }),
3472             _ => return None,
3473         };
3474         Some(res)
3475     }
3476     fn syntax(&self) -> &SyntaxNode {
3477         match self {
3478             ExternItem::Fn(it) => &it.syntax,
3479             ExternItem::MacroCall(it) => &it.syntax,
3480             ExternItem::Static(it) => &it.syntax,
3481             ExternItem::TypeAlias(it) => &it.syntax,
3482         }
3483     }
3484 }
3485 impl From<ConstParam> for GenericParam {
3486     fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3487 }
3488 impl From<LifetimeParam> for GenericParam {
3489     fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
3490 }
3491 impl From<TypeParam> for GenericParam {
3492     fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
3493 }
3494 impl AstNode for GenericParam {
3495     fn can_cast(kind: SyntaxKind) -> bool {
3496         match kind {
3497             CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM => true,
3498             _ => false,
3499         }
3500     }
3501     fn cast(syntax: SyntaxNode) -> Option<Self> {
3502         let res = match syntax.kind() {
3503             CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
3504             LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
3505             TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
3506             _ => return None,
3507         };
3508         Some(res)
3509     }
3510     fn syntax(&self) -> &SyntaxNode {
3511         match self {
3512             GenericParam::ConstParam(it) => &it.syntax,
3513             GenericParam::LifetimeParam(it) => &it.syntax,
3514             GenericParam::TypeParam(it) => &it.syntax,
3515         }
3516     }
3517 }
3518 impl std::fmt::Display for GenericArg {
3519     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3520         std::fmt::Display::fmt(self.syntax(), f)
3521     }
3522 }
3523 impl std::fmt::Display for Type {
3524     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3525         std::fmt::Display::fmt(self.syntax(), f)
3526     }
3527 }
3528 impl std::fmt::Display for Expr {
3529     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3530         std::fmt::Display::fmt(self.syntax(), f)
3531     }
3532 }
3533 impl std::fmt::Display for Item {
3534     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3535         std::fmt::Display::fmt(self.syntax(), f)
3536     }
3537 }
3538 impl std::fmt::Display for Stmt {
3539     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3540         std::fmt::Display::fmt(self.syntax(), f)
3541     }
3542 }
3543 impl std::fmt::Display for Pat {
3544     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3545         std::fmt::Display::fmt(self.syntax(), f)
3546     }
3547 }
3548 impl std::fmt::Display for FieldList {
3549     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3550         std::fmt::Display::fmt(self.syntax(), f)
3551     }
3552 }
3553 impl std::fmt::Display for AdtDef {
3554     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3555         std::fmt::Display::fmt(self.syntax(), f)
3556     }
3557 }
3558 impl std::fmt::Display for AssocItem {
3559     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3560         std::fmt::Display::fmt(self.syntax(), f)
3561     }
3562 }
3563 impl std::fmt::Display for ExternItem {
3564     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3565         std::fmt::Display::fmt(self.syntax(), f)
3566     }
3567 }
3568 impl std::fmt::Display for GenericParam {
3569     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3570         std::fmt::Display::fmt(self.syntax(), f)
3571     }
3572 }
3573 impl std::fmt::Display for Name {
3574     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3575         std::fmt::Display::fmt(self.syntax(), f)
3576     }
3577 }
3578 impl std::fmt::Display for NameRef {
3579     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3580         std::fmt::Display::fmt(self.syntax(), f)
3581     }
3582 }
3583 impl std::fmt::Display for Lifetime {
3584     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3585         std::fmt::Display::fmt(self.syntax(), f)
3586     }
3587 }
3588 impl std::fmt::Display for Path {
3589     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3590         std::fmt::Display::fmt(self.syntax(), f)
3591     }
3592 }
3593 impl std::fmt::Display for PathSegment {
3594     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3595         std::fmt::Display::fmt(self.syntax(), f)
3596     }
3597 }
3598 impl std::fmt::Display for GenericArgList {
3599     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3600         std::fmt::Display::fmt(self.syntax(), f)
3601     }
3602 }
3603 impl std::fmt::Display for ParamList {
3604     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3605         std::fmt::Display::fmt(self.syntax(), f)
3606     }
3607 }
3608 impl std::fmt::Display for RetType {
3609     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3610         std::fmt::Display::fmt(self.syntax(), f)
3611     }
3612 }
3613 impl std::fmt::Display for PathType {
3614     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3615         std::fmt::Display::fmt(self.syntax(), f)
3616     }
3617 }
3618 impl std::fmt::Display for TypeArg {
3619     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3620         std::fmt::Display::fmt(self.syntax(), f)
3621     }
3622 }
3623 impl std::fmt::Display for AssocTypeArg {
3624     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3625         std::fmt::Display::fmt(self.syntax(), f)
3626     }
3627 }
3628 impl std::fmt::Display for LifetimeArg {
3629     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3630         std::fmt::Display::fmt(self.syntax(), f)
3631     }
3632 }
3633 impl std::fmt::Display for ConstArg {
3634     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3635         std::fmt::Display::fmt(self.syntax(), f)
3636     }
3637 }
3638 impl std::fmt::Display for TypeBoundList {
3639     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3640         std::fmt::Display::fmt(self.syntax(), f)
3641     }
3642 }
3643 impl std::fmt::Display for MacroCall {
3644     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3645         std::fmt::Display::fmt(self.syntax(), f)
3646     }
3647 }
3648 impl std::fmt::Display for Attr {
3649     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3650         std::fmt::Display::fmt(self.syntax(), f)
3651     }
3652 }
3653 impl std::fmt::Display for TokenTree {
3654     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3655         std::fmt::Display::fmt(self.syntax(), f)
3656     }
3657 }
3658 impl std::fmt::Display for MacroItems {
3659     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3660         std::fmt::Display::fmt(self.syntax(), f)
3661     }
3662 }
3663 impl std::fmt::Display for MacroStmts {
3664     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3665         std::fmt::Display::fmt(self.syntax(), f)
3666     }
3667 }
3668 impl std::fmt::Display for SourceFile {
3669     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3670         std::fmt::Display::fmt(self.syntax(), f)
3671     }
3672 }
3673 impl std::fmt::Display for Const {
3674     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3675         std::fmt::Display::fmt(self.syntax(), f)
3676     }
3677 }
3678 impl std::fmt::Display for Enum {
3679     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3680         std::fmt::Display::fmt(self.syntax(), f)
3681     }
3682 }
3683 impl std::fmt::Display for ExternBlock {
3684     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3685         std::fmt::Display::fmt(self.syntax(), f)
3686     }
3687 }
3688 impl std::fmt::Display for ExternCrate {
3689     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3690         std::fmt::Display::fmt(self.syntax(), f)
3691     }
3692 }
3693 impl std::fmt::Display for Fn {
3694     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3695         std::fmt::Display::fmt(self.syntax(), f)
3696     }
3697 }
3698 impl std::fmt::Display for Impl {
3699     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3700         std::fmt::Display::fmt(self.syntax(), f)
3701     }
3702 }
3703 impl std::fmt::Display for MacroRules {
3704     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3705         std::fmt::Display::fmt(self.syntax(), f)
3706     }
3707 }
3708 impl std::fmt::Display for MacroDef {
3709     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3710         std::fmt::Display::fmt(self.syntax(), f)
3711     }
3712 }
3713 impl std::fmt::Display for Module {
3714     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3715         std::fmt::Display::fmt(self.syntax(), f)
3716     }
3717 }
3718 impl std::fmt::Display for Static {
3719     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3720         std::fmt::Display::fmt(self.syntax(), f)
3721     }
3722 }
3723 impl std::fmt::Display for Struct {
3724     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3725         std::fmt::Display::fmt(self.syntax(), f)
3726     }
3727 }
3728 impl std::fmt::Display for Trait {
3729     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3730         std::fmt::Display::fmt(self.syntax(), f)
3731     }
3732 }
3733 impl std::fmt::Display for TypeAlias {
3734     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3735         std::fmt::Display::fmt(self.syntax(), f)
3736     }
3737 }
3738 impl std::fmt::Display for Union {
3739     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3740         std::fmt::Display::fmt(self.syntax(), f)
3741     }
3742 }
3743 impl std::fmt::Display for Use {
3744     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3745         std::fmt::Display::fmt(self.syntax(), f)
3746     }
3747 }
3748 impl std::fmt::Display for Visibility {
3749     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3750         std::fmt::Display::fmt(self.syntax(), f)
3751     }
3752 }
3753 impl std::fmt::Display for ItemList {
3754     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3755         std::fmt::Display::fmt(self.syntax(), f)
3756     }
3757 }
3758 impl std::fmt::Display for Rename {
3759     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3760         std::fmt::Display::fmt(self.syntax(), f)
3761     }
3762 }
3763 impl std::fmt::Display for UseTree {
3764     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3765         std::fmt::Display::fmt(self.syntax(), f)
3766     }
3767 }
3768 impl std::fmt::Display for UseTreeList {
3769     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3770         std::fmt::Display::fmt(self.syntax(), f)
3771     }
3772 }
3773 impl std::fmt::Display for Abi {
3774     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3775         std::fmt::Display::fmt(self.syntax(), f)
3776     }
3777 }
3778 impl std::fmt::Display for GenericParamList {
3779     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3780         std::fmt::Display::fmt(self.syntax(), f)
3781     }
3782 }
3783 impl std::fmt::Display for WhereClause {
3784     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785         std::fmt::Display::fmt(self.syntax(), f)
3786     }
3787 }
3788 impl std::fmt::Display for BlockExpr {
3789     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790         std::fmt::Display::fmt(self.syntax(), f)
3791     }
3792 }
3793 impl std::fmt::Display for SelfParam {
3794     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3795         std::fmt::Display::fmt(self.syntax(), f)
3796     }
3797 }
3798 impl std::fmt::Display for Param {
3799     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3800         std::fmt::Display::fmt(self.syntax(), f)
3801     }
3802 }
3803 impl std::fmt::Display for RecordFieldList {
3804     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3805         std::fmt::Display::fmt(self.syntax(), f)
3806     }
3807 }
3808 impl std::fmt::Display for TupleFieldList {
3809     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3810         std::fmt::Display::fmt(self.syntax(), f)
3811     }
3812 }
3813 impl std::fmt::Display for RecordField {
3814     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3815         std::fmt::Display::fmt(self.syntax(), f)
3816     }
3817 }
3818 impl std::fmt::Display for TupleField {
3819     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3820         std::fmt::Display::fmt(self.syntax(), f)
3821     }
3822 }
3823 impl std::fmt::Display for VariantList {
3824     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3825         std::fmt::Display::fmt(self.syntax(), f)
3826     }
3827 }
3828 impl std::fmt::Display for Variant {
3829     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3830         std::fmt::Display::fmt(self.syntax(), f)
3831     }
3832 }
3833 impl std::fmt::Display for AssocItemList {
3834     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3835         std::fmt::Display::fmt(self.syntax(), f)
3836     }
3837 }
3838 impl std::fmt::Display for ExternItemList {
3839     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3840         std::fmt::Display::fmt(self.syntax(), f)
3841     }
3842 }
3843 impl std::fmt::Display for ConstParam {
3844     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3845         std::fmt::Display::fmt(self.syntax(), f)
3846     }
3847 }
3848 impl std::fmt::Display for LifetimeParam {
3849     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3850         std::fmt::Display::fmt(self.syntax(), f)
3851     }
3852 }
3853 impl std::fmt::Display for TypeParam {
3854     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3855         std::fmt::Display::fmt(self.syntax(), f)
3856     }
3857 }
3858 impl std::fmt::Display for WherePred {
3859     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3860         std::fmt::Display::fmt(self.syntax(), f)
3861     }
3862 }
3863 impl std::fmt::Display for Literal {
3864     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3865         std::fmt::Display::fmt(self.syntax(), f)
3866     }
3867 }
3868 impl std::fmt::Display for ExprStmt {
3869     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3870         std::fmt::Display::fmt(self.syntax(), f)
3871     }
3872 }
3873 impl std::fmt::Display for LetStmt {
3874     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3875         std::fmt::Display::fmt(self.syntax(), f)
3876     }
3877 }
3878 impl std::fmt::Display for ArrayExpr {
3879     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3880         std::fmt::Display::fmt(self.syntax(), f)
3881     }
3882 }
3883 impl std::fmt::Display for AwaitExpr {
3884     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3885         std::fmt::Display::fmt(self.syntax(), f)
3886     }
3887 }
3888 impl std::fmt::Display for BinExpr {
3889     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3890         std::fmt::Display::fmt(self.syntax(), f)
3891     }
3892 }
3893 impl std::fmt::Display for BoxExpr {
3894     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3895         std::fmt::Display::fmt(self.syntax(), f)
3896     }
3897 }
3898 impl std::fmt::Display for BreakExpr {
3899     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3900         std::fmt::Display::fmt(self.syntax(), f)
3901     }
3902 }
3903 impl std::fmt::Display for CallExpr {
3904     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3905         std::fmt::Display::fmt(self.syntax(), f)
3906     }
3907 }
3908 impl std::fmt::Display for CastExpr {
3909     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3910         std::fmt::Display::fmt(self.syntax(), f)
3911     }
3912 }
3913 impl std::fmt::Display for ClosureExpr {
3914     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3915         std::fmt::Display::fmt(self.syntax(), f)
3916     }
3917 }
3918 impl std::fmt::Display for ContinueExpr {
3919     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3920         std::fmt::Display::fmt(self.syntax(), f)
3921     }
3922 }
3923 impl std::fmt::Display for EffectExpr {
3924     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3925         std::fmt::Display::fmt(self.syntax(), f)
3926     }
3927 }
3928 impl std::fmt::Display for FieldExpr {
3929     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3930         std::fmt::Display::fmt(self.syntax(), f)
3931     }
3932 }
3933 impl std::fmt::Display for ForExpr {
3934     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3935         std::fmt::Display::fmt(self.syntax(), f)
3936     }
3937 }
3938 impl std::fmt::Display for IfExpr {
3939     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3940         std::fmt::Display::fmt(self.syntax(), f)
3941     }
3942 }
3943 impl std::fmt::Display for IndexExpr {
3944     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3945         std::fmt::Display::fmt(self.syntax(), f)
3946     }
3947 }
3948 impl std::fmt::Display for LoopExpr {
3949     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3950         std::fmt::Display::fmt(self.syntax(), f)
3951     }
3952 }
3953 impl std::fmt::Display for MatchExpr {
3954     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3955         std::fmt::Display::fmt(self.syntax(), f)
3956     }
3957 }
3958 impl std::fmt::Display for MethodCallExpr {
3959     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3960         std::fmt::Display::fmt(self.syntax(), f)
3961     }
3962 }
3963 impl std::fmt::Display for ParenExpr {
3964     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3965         std::fmt::Display::fmt(self.syntax(), f)
3966     }
3967 }
3968 impl std::fmt::Display for PathExpr {
3969     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3970         std::fmt::Display::fmt(self.syntax(), f)
3971     }
3972 }
3973 impl std::fmt::Display for PrefixExpr {
3974     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3975         std::fmt::Display::fmt(self.syntax(), f)
3976     }
3977 }
3978 impl std::fmt::Display for RangeExpr {
3979     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3980         std::fmt::Display::fmt(self.syntax(), f)
3981     }
3982 }
3983 impl std::fmt::Display for RecordExpr {
3984     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3985         std::fmt::Display::fmt(self.syntax(), f)
3986     }
3987 }
3988 impl std::fmt::Display for RefExpr {
3989     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3990         std::fmt::Display::fmt(self.syntax(), f)
3991     }
3992 }
3993 impl std::fmt::Display for ReturnExpr {
3994     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3995         std::fmt::Display::fmt(self.syntax(), f)
3996     }
3997 }
3998 impl std::fmt::Display for TryExpr {
3999     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4000         std::fmt::Display::fmt(self.syntax(), f)
4001     }
4002 }
4003 impl std::fmt::Display for TupleExpr {
4004     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4005         std::fmt::Display::fmt(self.syntax(), f)
4006     }
4007 }
4008 impl std::fmt::Display for WhileExpr {
4009     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4010         std::fmt::Display::fmt(self.syntax(), f)
4011     }
4012 }
4013 impl std::fmt::Display for YieldExpr {
4014     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4015         std::fmt::Display::fmt(self.syntax(), f)
4016     }
4017 }
4018 impl std::fmt::Display for Label {
4019     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4020         std::fmt::Display::fmt(self.syntax(), f)
4021     }
4022 }
4023 impl std::fmt::Display for RecordExprFieldList {
4024     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4025         std::fmt::Display::fmt(self.syntax(), f)
4026     }
4027 }
4028 impl std::fmt::Display for RecordExprField {
4029     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4030         std::fmt::Display::fmt(self.syntax(), f)
4031     }
4032 }
4033 impl std::fmt::Display for ArgList {
4034     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4035         std::fmt::Display::fmt(self.syntax(), f)
4036     }
4037 }
4038 impl std::fmt::Display for Condition {
4039     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4040         std::fmt::Display::fmt(self.syntax(), f)
4041     }
4042 }
4043 impl std::fmt::Display for MatchArmList {
4044     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4045         std::fmt::Display::fmt(self.syntax(), f)
4046     }
4047 }
4048 impl std::fmt::Display for MatchArm {
4049     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4050         std::fmt::Display::fmt(self.syntax(), f)
4051     }
4052 }
4053 impl std::fmt::Display for MatchGuard {
4054     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4055         std::fmt::Display::fmt(self.syntax(), f)
4056     }
4057 }
4058 impl std::fmt::Display for ArrayType {
4059     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4060         std::fmt::Display::fmt(self.syntax(), f)
4061     }
4062 }
4063 impl std::fmt::Display for DynTraitType {
4064     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4065         std::fmt::Display::fmt(self.syntax(), f)
4066     }
4067 }
4068 impl std::fmt::Display for FnPtrType {
4069     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4070         std::fmt::Display::fmt(self.syntax(), f)
4071     }
4072 }
4073 impl std::fmt::Display for ForType {
4074     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4075         std::fmt::Display::fmt(self.syntax(), f)
4076     }
4077 }
4078 impl std::fmt::Display for ImplTraitType {
4079     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4080         std::fmt::Display::fmt(self.syntax(), f)
4081     }
4082 }
4083 impl std::fmt::Display for InferType {
4084     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4085         std::fmt::Display::fmt(self.syntax(), f)
4086     }
4087 }
4088 impl std::fmt::Display for NeverType {
4089     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090         std::fmt::Display::fmt(self.syntax(), f)
4091     }
4092 }
4093 impl std::fmt::Display for ParenType {
4094     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4095         std::fmt::Display::fmt(self.syntax(), f)
4096     }
4097 }
4098 impl std::fmt::Display for PtrType {
4099     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4100         std::fmt::Display::fmt(self.syntax(), f)
4101     }
4102 }
4103 impl std::fmt::Display for RefType {
4104     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4105         std::fmt::Display::fmt(self.syntax(), f)
4106     }
4107 }
4108 impl std::fmt::Display for SliceType {
4109     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4110         std::fmt::Display::fmt(self.syntax(), f)
4111     }
4112 }
4113 impl std::fmt::Display for TupleType {
4114     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4115         std::fmt::Display::fmt(self.syntax(), f)
4116     }
4117 }
4118 impl std::fmt::Display for TypeBound {
4119     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4120         std::fmt::Display::fmt(self.syntax(), f)
4121     }
4122 }
4123 impl std::fmt::Display for IdentPat {
4124     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4125         std::fmt::Display::fmt(self.syntax(), f)
4126     }
4127 }
4128 impl std::fmt::Display for BoxPat {
4129     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4130         std::fmt::Display::fmt(self.syntax(), f)
4131     }
4132 }
4133 impl std::fmt::Display for RestPat {
4134     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4135         std::fmt::Display::fmt(self.syntax(), f)
4136     }
4137 }
4138 impl std::fmt::Display for LiteralPat {
4139     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4140         std::fmt::Display::fmt(self.syntax(), f)
4141     }
4142 }
4143 impl std::fmt::Display for MacroPat {
4144     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4145         std::fmt::Display::fmt(self.syntax(), f)
4146     }
4147 }
4148 impl std::fmt::Display for OrPat {
4149     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4150         std::fmt::Display::fmt(self.syntax(), f)
4151     }
4152 }
4153 impl std::fmt::Display for ParenPat {
4154     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4155         std::fmt::Display::fmt(self.syntax(), f)
4156     }
4157 }
4158 impl std::fmt::Display for PathPat {
4159     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4160         std::fmt::Display::fmt(self.syntax(), f)
4161     }
4162 }
4163 impl std::fmt::Display for WildcardPat {
4164     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4165         std::fmt::Display::fmt(self.syntax(), f)
4166     }
4167 }
4168 impl std::fmt::Display for RangePat {
4169     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4170         std::fmt::Display::fmt(self.syntax(), f)
4171     }
4172 }
4173 impl std::fmt::Display for RecordPat {
4174     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4175         std::fmt::Display::fmt(self.syntax(), f)
4176     }
4177 }
4178 impl std::fmt::Display for RefPat {
4179     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4180         std::fmt::Display::fmt(self.syntax(), f)
4181     }
4182 }
4183 impl std::fmt::Display for SlicePat {
4184     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185         std::fmt::Display::fmt(self.syntax(), f)
4186     }
4187 }
4188 impl std::fmt::Display for TuplePat {
4189     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4190         std::fmt::Display::fmt(self.syntax(), f)
4191     }
4192 }
4193 impl std::fmt::Display for TupleStructPat {
4194     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4195         std::fmt::Display::fmt(self.syntax(), f)
4196     }
4197 }
4198 impl std::fmt::Display for ConstBlockPat {
4199     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4200         std::fmt::Display::fmt(self.syntax(), f)
4201     }
4202 }
4203 impl std::fmt::Display for RecordPatFieldList {
4204     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4205         std::fmt::Display::fmt(self.syntax(), f)
4206     }
4207 }
4208 impl std::fmt::Display for RecordPatField {
4209     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4210         std::fmt::Display::fmt(self.syntax(), f)
4211     }
4212 }