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 Label {
 935     pub(crate) syntax: SyntaxNode,
 936 }
 937 impl Label {
 938     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
 939     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 940 }
 941 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 942 pub struct RecordExprFieldList {
 943     pub(crate) syntax: SyntaxNode,
 944 }
 945 impl ast::AttrsOwner for RecordExprFieldList {}
 946 impl RecordExprFieldList {
 947     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 948     pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
 949     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
 950     pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
 951     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 952 }
 953 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 954 pub struct RecordExprField {
 955     pub(crate) syntax: SyntaxNode,
 956 }
 957 impl ast::AttrsOwner for RecordExprField {}
 958 impl RecordExprField {
 959     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 960     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
 961     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 962 }
 963 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 964 pub struct ArgList {
 965     pub(crate) syntax: SyntaxNode,
 966 }
 967 impl ArgList {
 968     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
 969     pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
 970     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 971 }
 972 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 973 pub struct Condition {
 974     pub(crate) syntax: SyntaxNode,
 975 }
 976 impl Condition {
 977     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
 978     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 979     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 980     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 981 }
 982 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 983 pub struct MatchArmList {
 984     pub(crate) syntax: SyntaxNode,
 985 }
 986 impl ast::AttrsOwner for MatchArmList {}
 987 impl MatchArmList {
 988     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
 989     pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
 990     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 991 }
 992 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 993 pub struct MatchArm {
 994     pub(crate) syntax: SyntaxNode,
 995 }
 996 impl ast::AttrsOwner for MatchArm {}
 997 impl MatchArm {
 998     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 999     pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
1000     pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
1001     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1002     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1003 }
1004 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1005 pub struct MatchGuard {
1006     pub(crate) syntax: SyntaxNode,
1007 }
1008 impl MatchGuard {
1009     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
1010     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1011 }
1012 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1013 pub struct ArrayType {
1014     pub(crate) syntax: SyntaxNode,
1015 }
1016 impl ArrayType {
1017     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1018     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1019     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1020     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1021     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1022 }
1023 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1024 pub struct DynTraitType {
1025     pub(crate) syntax: SyntaxNode,
1026 }
1027 impl DynTraitType {
1028     pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
1029     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1030 }
1031 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1032 pub struct FnPtrType {
1033     pub(crate) syntax: SyntaxNode,
1034 }
1035 impl FnPtrType {
1036     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1037     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
1038     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1039     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
1040     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
1041     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
1042     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
1043 }
1044 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1045 pub struct ForType {
1046     pub(crate) syntax: SyntaxNode,
1047 }
1048 impl ForType {
1049     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
1050     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
1051     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1052 }
1053 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1054 pub struct ImplTraitType {
1055     pub(crate) syntax: SyntaxNode,
1056 }
1057 impl ImplTraitType {
1058     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
1059     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1060 }
1061 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1062 pub struct InferType {
1063     pub(crate) syntax: SyntaxNode,
1064 }
1065 impl InferType {
1066     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1067 }
1068 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1069 pub struct NeverType {
1070     pub(crate) syntax: SyntaxNode,
1071 }
1072 impl NeverType {
1073     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1074 }
1075 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1076 pub struct ParenType {
1077     pub(crate) syntax: SyntaxNode,
1078 }
1079 impl ParenType {
1080     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1081     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1082     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1083 }
1084 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1085 pub struct PtrType {
1086     pub(crate) syntax: SyntaxNode,
1087 }
1088 impl PtrType {
1089     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
1090     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1091     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1092     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1093 }
1094 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1095 pub struct RefType {
1096     pub(crate) syntax: SyntaxNode,
1097 }
1098 impl RefType {
1099     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1100     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1101     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1102     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1103 }
1104 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1105 pub struct SliceType {
1106     pub(crate) syntax: SyntaxNode,
1107 }
1108 impl SliceType {
1109     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1110     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1111     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1112 }
1113 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1114 pub struct TupleType {
1115     pub(crate) syntax: SyntaxNode,
1116 }
1117 impl TupleType {
1118     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1119     pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
1120     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1121 }
1122 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1123 pub struct TypeBound {
1124     pub(crate) syntax: SyntaxNode,
1125 }
1126 impl TypeBound {
1127     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1128     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1129     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1130 }
1131 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1132 pub struct IdentPat {
1133     pub(crate) syntax: SyntaxNode,
1134 }
1135 impl ast::AttrsOwner for IdentPat {}
1136 impl ast::NameOwner for IdentPat {}
1137 impl IdentPat {
1138     pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
1139     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1140     pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
1141     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1142 }
1143 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1144 pub struct BoxPat {
1145     pub(crate) syntax: SyntaxNode,
1146 }
1147 impl BoxPat {
1148     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
1149     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1150 }
1151 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1152 pub struct RestPat {
1153     pub(crate) syntax: SyntaxNode,
1154 }
1155 impl RestPat {
1156     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1157 }
1158 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1159 pub struct LiteralPat {
1160     pub(crate) syntax: SyntaxNode,
1161 }
1162 impl LiteralPat {
1163     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1164 }
1165 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1166 pub struct MacroPat {
1167     pub(crate) syntax: SyntaxNode,
1168 }
1169 impl MacroPat {
1170     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1171 }
1172 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1173 pub struct OrPat {
1174     pub(crate) syntax: SyntaxNode,
1175 }
1176 impl OrPat {
1177     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1178 }
1179 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1180 pub struct ParenPat {
1181     pub(crate) syntax: SyntaxNode,
1182 }
1183 impl ParenPat {
1184     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1185     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1186     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1187 }
1188 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1189 pub struct PathPat {
1190     pub(crate) syntax: SyntaxNode,
1191 }
1192 impl PathPat {
1193     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1194 }
1195 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1196 pub struct WildcardPat {
1197     pub(crate) syntax: SyntaxNode,
1198 }
1199 impl WildcardPat {
1200     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1201 }
1202 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1203 pub struct RangePat {
1204     pub(crate) syntax: SyntaxNode,
1205 }
1206 impl RangePat {}
1207 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1208 pub struct RecordPat {
1209     pub(crate) syntax: SyntaxNode,
1210 }
1211 impl RecordPat {
1212     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1213     pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
1214         support::child(&self.syntax)
1215     }
1216 }
1217 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1218 pub struct RefPat {
1219     pub(crate) syntax: SyntaxNode,
1220 }
1221 impl RefPat {
1222     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1223     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1224     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1225 }
1226 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1227 pub struct SlicePat {
1228     pub(crate) syntax: SyntaxNode,
1229 }
1230 impl SlicePat {
1231     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1232     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1233     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1234 }
1235 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1236 pub struct TuplePat {
1237     pub(crate) syntax: SyntaxNode,
1238 }
1239 impl TuplePat {
1240     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1241     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1242     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1243 }
1244 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1245 pub struct TupleStructPat {
1246     pub(crate) syntax: SyntaxNode,
1247 }
1248 impl TupleStructPat {
1249     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1250     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1251     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1252     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1253 }
1254 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1255 pub struct ConstBlockPat {
1256     pub(crate) syntax: SyntaxNode,
1257 }
1258 impl ConstBlockPat {
1259     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1260     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
1261 }
1262 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1263 pub struct RecordPatFieldList {
1264     pub(crate) syntax: SyntaxNode,
1265 }
1266 impl RecordPatFieldList {
1267     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1268     pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
1269     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1270     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1271 }
1272 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1273 pub struct RecordPatField {
1274     pub(crate) syntax: SyntaxNode,
1275 }
1276 impl ast::AttrsOwner for RecordPatField {}
1277 impl RecordPatField {
1278     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1279     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1280     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1281 }
1282 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1283 pub enum GenericArg {
1284     TypeArg(TypeArg),
1285     AssocTypeArg(AssocTypeArg),
1286     LifetimeArg(LifetimeArg),
1287     ConstArg(ConstArg),
1288 }
1289 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1290 pub enum Type {
1291     ArrayType(ArrayType),
1292     DynTraitType(DynTraitType),
1293     FnPtrType(FnPtrType),
1294     ForType(ForType),
1295     ImplTraitType(ImplTraitType),
1296     InferType(InferType),
1297     NeverType(NeverType),
1298     ParenType(ParenType),
1299     PathType(PathType),
1300     PtrType(PtrType),
1301     RefType(RefType),
1302     SliceType(SliceType),
1303     TupleType(TupleType),
1304 }
1305 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1306 pub enum Expr {
1307     ArrayExpr(ArrayExpr),
1308     AwaitExpr(AwaitExpr),
1309     BinExpr(BinExpr),
1310     BlockExpr(BlockExpr),
1311     BoxExpr(BoxExpr),
1312     BreakExpr(BreakExpr),
1313     CallExpr(CallExpr),
1314     CastExpr(CastExpr),
1315     ClosureExpr(ClosureExpr),
1316     ContinueExpr(ContinueExpr),
1317     EffectExpr(EffectExpr),
1318     FieldExpr(FieldExpr),
1319     ForExpr(ForExpr),
1320     IfExpr(IfExpr),
1321     IndexExpr(IndexExpr),
1322     Literal(Literal),
1323     LoopExpr(LoopExpr),
1324     MacroCall(MacroCall),
1325     MatchExpr(MatchExpr),
1326     MethodCallExpr(MethodCallExpr),
1327     ParenExpr(ParenExpr),
1328     PathExpr(PathExpr),
1329     PrefixExpr(PrefixExpr),
1330     RangeExpr(RangeExpr),
1331     RecordExpr(RecordExpr),
1332     RefExpr(RefExpr),
1333     ReturnExpr(ReturnExpr),
1334     TryExpr(TryExpr),
1335     TupleExpr(TupleExpr),
1336     WhileExpr(WhileExpr),
1337 }
1338 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1339 pub enum Item {
1340     Const(Const),
1341     Enum(Enum),
1342     ExternBlock(ExternBlock),
1343     ExternCrate(ExternCrate),
1344     Fn(Fn),
1345     Impl(Impl),
1346     MacroCall(MacroCall),
1347     MacroRules(MacroRules),
1348     MacroDef(MacroDef),
1349     Module(Module),
1350     Static(Static),
1351     Struct(Struct),
1352     Trait(Trait),
1353     TypeAlias(TypeAlias),
1354     Union(Union),
1355     Use(Use),
1356 }
1357 impl ast::AttrsOwner for Item {}
1358 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1359 pub enum Stmt {
1360     ExprStmt(ExprStmt),
1361     Item(Item),
1362     LetStmt(LetStmt),
1363 }
1364 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1365 pub enum Pat {
1366     IdentPat(IdentPat),
1367     BoxPat(BoxPat),
1368     RestPat(RestPat),
1369     LiteralPat(LiteralPat),
1370     MacroPat(MacroPat),
1371     OrPat(OrPat),
1372     ParenPat(ParenPat),
1373     PathPat(PathPat),
1374     WildcardPat(WildcardPat),
1375     RangePat(RangePat),
1376     RecordPat(RecordPat),
1377     RefPat(RefPat),
1378     SlicePat(SlicePat),
1379     TuplePat(TuplePat),
1380     TupleStructPat(TupleStructPat),
1381     ConstBlockPat(ConstBlockPat),
1382 }
1383 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1384 pub enum FieldList {
1385     RecordFieldList(RecordFieldList),
1386     TupleFieldList(TupleFieldList),
1387 }
1388 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1389 pub enum AdtDef {
1390     Enum(Enum),
1391     Struct(Struct),
1392     Union(Union),
1393 }
1394 impl ast::AttrsOwner for AdtDef {}
1395 impl ast::GenericParamsOwner for AdtDef {}
1396 impl ast::NameOwner for AdtDef {}
1397 impl ast::VisibilityOwner for AdtDef {}
1398 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1399 pub enum AssocItem {
1400     Const(Const),
1401     Fn(Fn),
1402     MacroCall(MacroCall),
1403     TypeAlias(TypeAlias),
1404 }
1405 impl ast::AttrsOwner for AssocItem {}
1406 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1407 pub enum ExternItem {
1408     Fn(Fn),
1409     MacroCall(MacroCall),
1410     Static(Static),
1411     TypeAlias(TypeAlias),
1412 }
1413 impl ast::AttrsOwner for ExternItem {}
1414 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1415 pub enum GenericParam {
1416     ConstParam(ConstParam),
1417     LifetimeParam(LifetimeParam),
1418     TypeParam(TypeParam),
1419 }
1420 impl ast::AttrsOwner for GenericParam {}
1421 impl AstNode for Name {
1422     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
1423     fn cast(syntax: SyntaxNode) -> Option<Self> {
1424         if Self::can_cast(syntax.kind()) {
1425             Some(Self { syntax })
1426         } else {
1427             None
1428         }
1429     }
1430     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1431 }
1432 impl AstNode for NameRef {
1433     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
1434     fn cast(syntax: SyntaxNode) -> Option<Self> {
1435         if Self::can_cast(syntax.kind()) {
1436             Some(Self { syntax })
1437         } else {
1438             None
1439         }
1440     }
1441     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1442 }
1443 impl AstNode for Lifetime {
1444     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME }
1445     fn cast(syntax: SyntaxNode) -> Option<Self> {
1446         if Self::can_cast(syntax.kind()) {
1447             Some(Self { syntax })
1448         } else {
1449             None
1450         }
1451     }
1452     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1453 }
1454 impl AstNode for Path {
1455     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
1456     fn cast(syntax: SyntaxNode) -> Option<Self> {
1457         if Self::can_cast(syntax.kind()) {
1458             Some(Self { syntax })
1459         } else {
1460             None
1461         }
1462     }
1463     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1464 }
1465 impl AstNode for PathSegment {
1466     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
1467     fn cast(syntax: SyntaxNode) -> Option<Self> {
1468         if Self::can_cast(syntax.kind()) {
1469             Some(Self { syntax })
1470         } else {
1471             None
1472         }
1473     }
1474     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1475 }
1476 impl AstNode for GenericArgList {
1477     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
1478     fn cast(syntax: SyntaxNode) -> Option<Self> {
1479         if Self::can_cast(syntax.kind()) {
1480             Some(Self { syntax })
1481         } else {
1482             None
1483         }
1484     }
1485     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1486 }
1487 impl AstNode for ParamList {
1488     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
1489     fn cast(syntax: SyntaxNode) -> Option<Self> {
1490         if Self::can_cast(syntax.kind()) {
1491             Some(Self { syntax })
1492         } else {
1493             None
1494         }
1495     }
1496     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1497 }
1498 impl AstNode for RetType {
1499     fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
1500     fn cast(syntax: SyntaxNode) -> Option<Self> {
1501         if Self::can_cast(syntax.kind()) {
1502             Some(Self { syntax })
1503         } else {
1504             None
1505         }
1506     }
1507     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1508 }
1509 impl AstNode for PathType {
1510     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
1511     fn cast(syntax: SyntaxNode) -> Option<Self> {
1512         if Self::can_cast(syntax.kind()) {
1513             Some(Self { syntax })
1514         } else {
1515             None
1516         }
1517     }
1518     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1519 }
1520 impl AstNode for TypeArg {
1521     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
1522     fn cast(syntax: SyntaxNode) -> Option<Self> {
1523         if Self::can_cast(syntax.kind()) {
1524             Some(Self { syntax })
1525         } else {
1526             None
1527         }
1528     }
1529     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1530 }
1531 impl AstNode for AssocTypeArg {
1532     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
1533     fn cast(syntax: SyntaxNode) -> Option<Self> {
1534         if Self::can_cast(syntax.kind()) {
1535             Some(Self { syntax })
1536         } else {
1537             None
1538         }
1539     }
1540     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1541 }
1542 impl AstNode for LifetimeArg {
1543     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
1544     fn cast(syntax: SyntaxNode) -> Option<Self> {
1545         if Self::can_cast(syntax.kind()) {
1546             Some(Self { syntax })
1547         } else {
1548             None
1549         }
1550     }
1551     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1552 }
1553 impl AstNode for ConstArg {
1554     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
1555     fn cast(syntax: SyntaxNode) -> Option<Self> {
1556         if Self::can_cast(syntax.kind()) {
1557             Some(Self { syntax })
1558         } else {
1559             None
1560         }
1561     }
1562     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1563 }
1564 impl AstNode for TypeBoundList {
1565     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
1566     fn cast(syntax: SyntaxNode) -> Option<Self> {
1567         if Self::can_cast(syntax.kind()) {
1568             Some(Self { syntax })
1569         } else {
1570             None
1571         }
1572     }
1573     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1574 }
1575 impl AstNode for MacroCall {
1576     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
1577     fn cast(syntax: SyntaxNode) -> Option<Self> {
1578         if Self::can_cast(syntax.kind()) {
1579             Some(Self { syntax })
1580         } else {
1581             None
1582         }
1583     }
1584     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1585 }
1586 impl AstNode for Attr {
1587     fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
1588     fn cast(syntax: SyntaxNode) -> Option<Self> {
1589         if Self::can_cast(syntax.kind()) {
1590             Some(Self { syntax })
1591         } else {
1592             None
1593         }
1594     }
1595     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1596 }
1597 impl AstNode for TokenTree {
1598     fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
1599     fn cast(syntax: SyntaxNode) -> Option<Self> {
1600         if Self::can_cast(syntax.kind()) {
1601             Some(Self { syntax })
1602         } else {
1603             None
1604         }
1605     }
1606     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1607 }
1608 impl AstNode for MacroItems {
1609     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
1610     fn cast(syntax: SyntaxNode) -> Option<Self> {
1611         if Self::can_cast(syntax.kind()) {
1612             Some(Self { syntax })
1613         } else {
1614             None
1615         }
1616     }
1617     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1618 }
1619 impl AstNode for MacroStmts {
1620     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
1621     fn cast(syntax: SyntaxNode) -> Option<Self> {
1622         if Self::can_cast(syntax.kind()) {
1623             Some(Self { syntax })
1624         } else {
1625             None
1626         }
1627     }
1628     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1629 }
1630 impl AstNode for SourceFile {
1631     fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
1632     fn cast(syntax: SyntaxNode) -> Option<Self> {
1633         if Self::can_cast(syntax.kind()) {
1634             Some(Self { syntax })
1635         } else {
1636             None
1637         }
1638     }
1639     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1640 }
1641 impl AstNode for Const {
1642     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
1643     fn cast(syntax: SyntaxNode) -> Option<Self> {
1644         if Self::can_cast(syntax.kind()) {
1645             Some(Self { syntax })
1646         } else {
1647             None
1648         }
1649     }
1650     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1651 }
1652 impl AstNode for Enum {
1653     fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
1654     fn cast(syntax: SyntaxNode) -> Option<Self> {
1655         if Self::can_cast(syntax.kind()) {
1656             Some(Self { syntax })
1657         } else {
1658             None
1659         }
1660     }
1661     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1662 }
1663 impl AstNode for ExternBlock {
1664     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
1665     fn cast(syntax: SyntaxNode) -> Option<Self> {
1666         if Self::can_cast(syntax.kind()) {
1667             Some(Self { syntax })
1668         } else {
1669             None
1670         }
1671     }
1672     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1673 }
1674 impl AstNode for ExternCrate {
1675     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
1676     fn cast(syntax: SyntaxNode) -> Option<Self> {
1677         if Self::can_cast(syntax.kind()) {
1678             Some(Self { syntax })
1679         } else {
1680             None
1681         }
1682     }
1683     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1684 }
1685 impl AstNode for Fn {
1686     fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
1687     fn cast(syntax: SyntaxNode) -> Option<Self> {
1688         if Self::can_cast(syntax.kind()) {
1689             Some(Self { syntax })
1690         } else {
1691             None
1692         }
1693     }
1694     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1695 }
1696 impl AstNode for Impl {
1697     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
1698     fn cast(syntax: SyntaxNode) -> Option<Self> {
1699         if Self::can_cast(syntax.kind()) {
1700             Some(Self { syntax })
1701         } else {
1702             None
1703         }
1704     }
1705     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1706 }
1707 impl AstNode for MacroRules {
1708     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
1709     fn cast(syntax: SyntaxNode) -> Option<Self> {
1710         if Self::can_cast(syntax.kind()) {
1711             Some(Self { syntax })
1712         } else {
1713             None
1714         }
1715     }
1716     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1717 }
1718 impl AstNode for MacroDef {
1719     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
1720     fn cast(syntax: SyntaxNode) -> Option<Self> {
1721         if Self::can_cast(syntax.kind()) {
1722             Some(Self { syntax })
1723         } else {
1724             None
1725         }
1726     }
1727     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1728 }
1729 impl AstNode for Module {
1730     fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
1731     fn cast(syntax: SyntaxNode) -> Option<Self> {
1732         if Self::can_cast(syntax.kind()) {
1733             Some(Self { syntax })
1734         } else {
1735             None
1736         }
1737     }
1738     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1739 }
1740 impl AstNode for Static {
1741     fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
1742     fn cast(syntax: SyntaxNode) -> Option<Self> {
1743         if Self::can_cast(syntax.kind()) {
1744             Some(Self { syntax })
1745         } else {
1746             None
1747         }
1748     }
1749     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1750 }
1751 impl AstNode for Struct {
1752     fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
1753     fn cast(syntax: SyntaxNode) -> Option<Self> {
1754         if Self::can_cast(syntax.kind()) {
1755             Some(Self { syntax })
1756         } else {
1757             None
1758         }
1759     }
1760     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1761 }
1762 impl AstNode for Trait {
1763     fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
1764     fn cast(syntax: SyntaxNode) -> Option<Self> {
1765         if Self::can_cast(syntax.kind()) {
1766             Some(Self { syntax })
1767         } else {
1768             None
1769         }
1770     }
1771     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1772 }
1773 impl AstNode for TypeAlias {
1774     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
1775     fn cast(syntax: SyntaxNode) -> Option<Self> {
1776         if Self::can_cast(syntax.kind()) {
1777             Some(Self { syntax })
1778         } else {
1779             None
1780         }
1781     }
1782     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1783 }
1784 impl AstNode for Union {
1785     fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
1786     fn cast(syntax: SyntaxNode) -> Option<Self> {
1787         if Self::can_cast(syntax.kind()) {
1788             Some(Self { syntax })
1789         } else {
1790             None
1791         }
1792     }
1793     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1794 }
1795 impl AstNode for Use {
1796     fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
1797     fn cast(syntax: SyntaxNode) -> Option<Self> {
1798         if Self::can_cast(syntax.kind()) {
1799             Some(Self { syntax })
1800         } else {
1801             None
1802         }
1803     }
1804     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1805 }
1806 impl AstNode for Visibility {
1807     fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
1808     fn cast(syntax: SyntaxNode) -> Option<Self> {
1809         if Self::can_cast(syntax.kind()) {
1810             Some(Self { syntax })
1811         } else {
1812             None
1813         }
1814     }
1815     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1816 }
1817 impl AstNode for ItemList {
1818     fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
1819     fn cast(syntax: SyntaxNode) -> Option<Self> {
1820         if Self::can_cast(syntax.kind()) {
1821             Some(Self { syntax })
1822         } else {
1823             None
1824         }
1825     }
1826     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1827 }
1828 impl AstNode for Rename {
1829     fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
1830     fn cast(syntax: SyntaxNode) -> Option<Self> {
1831         if Self::can_cast(syntax.kind()) {
1832             Some(Self { syntax })
1833         } else {
1834             None
1835         }
1836     }
1837     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1838 }
1839 impl AstNode for UseTree {
1840     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
1841     fn cast(syntax: SyntaxNode) -> Option<Self> {
1842         if Self::can_cast(syntax.kind()) {
1843             Some(Self { syntax })
1844         } else {
1845             None
1846         }
1847     }
1848     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1849 }
1850 impl AstNode for UseTreeList {
1851     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
1852     fn cast(syntax: SyntaxNode) -> Option<Self> {
1853         if Self::can_cast(syntax.kind()) {
1854             Some(Self { syntax })
1855         } else {
1856             None
1857         }
1858     }
1859     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1860 }
1861 impl AstNode for Abi {
1862     fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
1863     fn cast(syntax: SyntaxNode) -> Option<Self> {
1864         if Self::can_cast(syntax.kind()) {
1865             Some(Self { syntax })
1866         } else {
1867             None
1868         }
1869     }
1870     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1871 }
1872 impl AstNode for GenericParamList {
1873     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
1874     fn cast(syntax: SyntaxNode) -> Option<Self> {
1875         if Self::can_cast(syntax.kind()) {
1876             Some(Self { syntax })
1877         } else {
1878             None
1879         }
1880     }
1881     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1882 }
1883 impl AstNode for WhereClause {
1884     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
1885     fn cast(syntax: SyntaxNode) -> Option<Self> {
1886         if Self::can_cast(syntax.kind()) {
1887             Some(Self { syntax })
1888         } else {
1889             None
1890         }
1891     }
1892     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1893 }
1894 impl AstNode for BlockExpr {
1895     fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
1896     fn cast(syntax: SyntaxNode) -> Option<Self> {
1897         if Self::can_cast(syntax.kind()) {
1898             Some(Self { syntax })
1899         } else {
1900             None
1901         }
1902     }
1903     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1904 }
1905 impl AstNode for SelfParam {
1906     fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
1907     fn cast(syntax: SyntaxNode) -> Option<Self> {
1908         if Self::can_cast(syntax.kind()) {
1909             Some(Self { syntax })
1910         } else {
1911             None
1912         }
1913     }
1914     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1915 }
1916 impl AstNode for Param {
1917     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
1918     fn cast(syntax: SyntaxNode) -> Option<Self> {
1919         if Self::can_cast(syntax.kind()) {
1920             Some(Self { syntax })
1921         } else {
1922             None
1923         }
1924     }
1925     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1926 }
1927 impl AstNode for RecordFieldList {
1928     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
1929     fn cast(syntax: SyntaxNode) -> Option<Self> {
1930         if Self::can_cast(syntax.kind()) {
1931             Some(Self { syntax })
1932         } else {
1933             None
1934         }
1935     }
1936     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1937 }
1938 impl AstNode for TupleFieldList {
1939     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
1940     fn cast(syntax: SyntaxNode) -> Option<Self> {
1941         if Self::can_cast(syntax.kind()) {
1942             Some(Self { syntax })
1943         } else {
1944             None
1945         }
1946     }
1947     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1948 }
1949 impl AstNode for RecordField {
1950     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
1951     fn cast(syntax: SyntaxNode) -> Option<Self> {
1952         if Self::can_cast(syntax.kind()) {
1953             Some(Self { syntax })
1954         } else {
1955             None
1956         }
1957     }
1958     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1959 }
1960 impl AstNode for TupleField {
1961     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
1962     fn cast(syntax: SyntaxNode) -> Option<Self> {
1963         if Self::can_cast(syntax.kind()) {
1964             Some(Self { syntax })
1965         } else {
1966             None
1967         }
1968     }
1969     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1970 }
1971 impl AstNode for VariantList {
1972     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
1973     fn cast(syntax: SyntaxNode) -> Option<Self> {
1974         if Self::can_cast(syntax.kind()) {
1975             Some(Self { syntax })
1976         } else {
1977             None
1978         }
1979     }
1980     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1981 }
1982 impl AstNode for Variant {
1983     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
1984     fn cast(syntax: SyntaxNode) -> Option<Self> {
1985         if Self::can_cast(syntax.kind()) {
1986             Some(Self { syntax })
1987         } else {
1988             None
1989         }
1990     }
1991     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1992 }
1993 impl AstNode for AssocItemList {
1994     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
1995     fn cast(syntax: SyntaxNode) -> Option<Self> {
1996         if Self::can_cast(syntax.kind()) {
1997             Some(Self { syntax })
1998         } else {
1999             None
2000         }
2001     }
2002     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2003 }
2004 impl AstNode for ExternItemList {
2005     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
2006     fn cast(syntax: SyntaxNode) -> Option<Self> {
2007         if Self::can_cast(syntax.kind()) {
2008             Some(Self { syntax })
2009         } else {
2010             None
2011         }
2012     }
2013     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2014 }
2015 impl AstNode for ConstParam {
2016     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
2017     fn cast(syntax: SyntaxNode) -> Option<Self> {
2018         if Self::can_cast(syntax.kind()) {
2019             Some(Self { syntax })
2020         } else {
2021             None
2022         }
2023     }
2024     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2025 }
2026 impl AstNode for LifetimeParam {
2027     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
2028     fn cast(syntax: SyntaxNode) -> Option<Self> {
2029         if Self::can_cast(syntax.kind()) {
2030             Some(Self { syntax })
2031         } else {
2032             None
2033         }
2034     }
2035     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2036 }
2037 impl AstNode for TypeParam {
2038     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
2039     fn cast(syntax: SyntaxNode) -> Option<Self> {
2040         if Self::can_cast(syntax.kind()) {
2041             Some(Self { syntax })
2042         } else {
2043             None
2044         }
2045     }
2046     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2047 }
2048 impl AstNode for WherePred {
2049     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
2050     fn cast(syntax: SyntaxNode) -> Option<Self> {
2051         if Self::can_cast(syntax.kind()) {
2052             Some(Self { syntax })
2053         } else {
2054             None
2055         }
2056     }
2057     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2058 }
2059 impl AstNode for Literal {
2060     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
2061     fn cast(syntax: SyntaxNode) -> Option<Self> {
2062         if Self::can_cast(syntax.kind()) {
2063             Some(Self { syntax })
2064         } else {
2065             None
2066         }
2067     }
2068     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2069 }
2070 impl AstNode for ExprStmt {
2071     fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
2072     fn cast(syntax: SyntaxNode) -> Option<Self> {
2073         if Self::can_cast(syntax.kind()) {
2074             Some(Self { syntax })
2075         } else {
2076             None
2077         }
2078     }
2079     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2080 }
2081 impl AstNode for LetStmt {
2082     fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
2083     fn cast(syntax: SyntaxNode) -> Option<Self> {
2084         if Self::can_cast(syntax.kind()) {
2085             Some(Self { syntax })
2086         } else {
2087             None
2088         }
2089     }
2090     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2091 }
2092 impl AstNode for ArrayExpr {
2093     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
2094     fn cast(syntax: SyntaxNode) -> Option<Self> {
2095         if Self::can_cast(syntax.kind()) {
2096             Some(Self { syntax })
2097         } else {
2098             None
2099         }
2100     }
2101     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2102 }
2103 impl AstNode for AwaitExpr {
2104     fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
2105     fn cast(syntax: SyntaxNode) -> Option<Self> {
2106         if Self::can_cast(syntax.kind()) {
2107             Some(Self { syntax })
2108         } else {
2109             None
2110         }
2111     }
2112     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2113 }
2114 impl AstNode for BinExpr {
2115     fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
2116     fn cast(syntax: SyntaxNode) -> Option<Self> {
2117         if Self::can_cast(syntax.kind()) {
2118             Some(Self { syntax })
2119         } else {
2120             None
2121         }
2122     }
2123     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2124 }
2125 impl AstNode for BoxExpr {
2126     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR }
2127     fn cast(syntax: SyntaxNode) -> Option<Self> {
2128         if Self::can_cast(syntax.kind()) {
2129             Some(Self { syntax })
2130         } else {
2131             None
2132         }
2133     }
2134     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2135 }
2136 impl AstNode for BreakExpr {
2137     fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
2138     fn cast(syntax: SyntaxNode) -> Option<Self> {
2139         if Self::can_cast(syntax.kind()) {
2140             Some(Self { syntax })
2141         } else {
2142             None
2143         }
2144     }
2145     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2146 }
2147 impl AstNode for CallExpr {
2148     fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
2149     fn cast(syntax: SyntaxNode) -> Option<Self> {
2150         if Self::can_cast(syntax.kind()) {
2151             Some(Self { syntax })
2152         } else {
2153             None
2154         }
2155     }
2156     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2157 }
2158 impl AstNode for CastExpr {
2159     fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
2160     fn cast(syntax: SyntaxNode) -> Option<Self> {
2161         if Self::can_cast(syntax.kind()) {
2162             Some(Self { syntax })
2163         } else {
2164             None
2165         }
2166     }
2167     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2168 }
2169 impl AstNode for ClosureExpr {
2170     fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
2171     fn cast(syntax: SyntaxNode) -> Option<Self> {
2172         if Self::can_cast(syntax.kind()) {
2173             Some(Self { syntax })
2174         } else {
2175             None
2176         }
2177     }
2178     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2179 }
2180 impl AstNode for ContinueExpr {
2181     fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
2182     fn cast(syntax: SyntaxNode) -> Option<Self> {
2183         if Self::can_cast(syntax.kind()) {
2184             Some(Self { syntax })
2185         } else {
2186             None
2187         }
2188     }
2189     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2190 }
2191 impl AstNode for EffectExpr {
2192     fn can_cast(kind: SyntaxKind) -> bool { kind == EFFECT_EXPR }
2193     fn cast(syntax: SyntaxNode) -> Option<Self> {
2194         if Self::can_cast(syntax.kind()) {
2195             Some(Self { syntax })
2196         } else {
2197             None
2198         }
2199     }
2200     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2201 }
2202 impl AstNode for FieldExpr {
2203     fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
2204     fn cast(syntax: SyntaxNode) -> Option<Self> {
2205         if Self::can_cast(syntax.kind()) {
2206             Some(Self { syntax })
2207         } else {
2208             None
2209         }
2210     }
2211     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2212 }
2213 impl AstNode for ForExpr {
2214     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
2215     fn cast(syntax: SyntaxNode) -> Option<Self> {
2216         if Self::can_cast(syntax.kind()) {
2217             Some(Self { syntax })
2218         } else {
2219             None
2220         }
2221     }
2222     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2223 }
2224 impl AstNode for IfExpr {
2225     fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
2226     fn cast(syntax: SyntaxNode) -> Option<Self> {
2227         if Self::can_cast(syntax.kind()) {
2228             Some(Self { syntax })
2229         } else {
2230             None
2231         }
2232     }
2233     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2234 }
2235 impl AstNode for IndexExpr {
2236     fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
2237     fn cast(syntax: SyntaxNode) -> Option<Self> {
2238         if Self::can_cast(syntax.kind()) {
2239             Some(Self { syntax })
2240         } else {
2241             None
2242         }
2243     }
2244     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2245 }
2246 impl AstNode for LoopExpr {
2247     fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
2248     fn cast(syntax: SyntaxNode) -> Option<Self> {
2249         if Self::can_cast(syntax.kind()) {
2250             Some(Self { syntax })
2251         } else {
2252             None
2253         }
2254     }
2255     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2256 }
2257 impl AstNode for MatchExpr {
2258     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
2259     fn cast(syntax: SyntaxNode) -> Option<Self> {
2260         if Self::can_cast(syntax.kind()) {
2261             Some(Self { syntax })
2262         } else {
2263             None
2264         }
2265     }
2266     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2267 }
2268 impl AstNode for MethodCallExpr {
2269     fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
2270     fn cast(syntax: SyntaxNode) -> Option<Self> {
2271         if Self::can_cast(syntax.kind()) {
2272             Some(Self { syntax })
2273         } else {
2274             None
2275         }
2276     }
2277     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2278 }
2279 impl AstNode for ParenExpr {
2280     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
2281     fn cast(syntax: SyntaxNode) -> Option<Self> {
2282         if Self::can_cast(syntax.kind()) {
2283             Some(Self { syntax })
2284         } else {
2285             None
2286         }
2287     }
2288     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2289 }
2290 impl AstNode for PathExpr {
2291     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
2292     fn cast(syntax: SyntaxNode) -> Option<Self> {
2293         if Self::can_cast(syntax.kind()) {
2294             Some(Self { syntax })
2295         } else {
2296             None
2297         }
2298     }
2299     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2300 }
2301 impl AstNode for PrefixExpr {
2302     fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
2303     fn cast(syntax: SyntaxNode) -> Option<Self> {
2304         if Self::can_cast(syntax.kind()) {
2305             Some(Self { syntax })
2306         } else {
2307             None
2308         }
2309     }
2310     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2311 }
2312 impl AstNode for RangeExpr {
2313     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
2314     fn cast(syntax: SyntaxNode) -> Option<Self> {
2315         if Self::can_cast(syntax.kind()) {
2316             Some(Self { syntax })
2317         } else {
2318             None
2319         }
2320     }
2321     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2322 }
2323 impl AstNode for RecordExpr {
2324     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
2325     fn cast(syntax: SyntaxNode) -> Option<Self> {
2326         if Self::can_cast(syntax.kind()) {
2327             Some(Self { syntax })
2328         } else {
2329             None
2330         }
2331     }
2332     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2333 }
2334 impl AstNode for RefExpr {
2335     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
2336     fn cast(syntax: SyntaxNode) -> Option<Self> {
2337         if Self::can_cast(syntax.kind()) {
2338             Some(Self { syntax })
2339         } else {
2340             None
2341         }
2342     }
2343     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2344 }
2345 impl AstNode for ReturnExpr {
2346     fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
2347     fn cast(syntax: SyntaxNode) -> Option<Self> {
2348         if Self::can_cast(syntax.kind()) {
2349             Some(Self { syntax })
2350         } else {
2351             None
2352         }
2353     }
2354     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2355 }
2356 impl AstNode for TryExpr {
2357     fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
2358     fn cast(syntax: SyntaxNode) -> Option<Self> {
2359         if Self::can_cast(syntax.kind()) {
2360             Some(Self { syntax })
2361         } else {
2362             None
2363         }
2364     }
2365     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2366 }
2367 impl AstNode for TupleExpr {
2368     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
2369     fn cast(syntax: SyntaxNode) -> Option<Self> {
2370         if Self::can_cast(syntax.kind()) {
2371             Some(Self { syntax })
2372         } else {
2373             None
2374         }
2375     }
2376     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2377 }
2378 impl AstNode for WhileExpr {
2379     fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
2380     fn cast(syntax: SyntaxNode) -> Option<Self> {
2381         if Self::can_cast(syntax.kind()) {
2382             Some(Self { syntax })
2383         } else {
2384             None
2385         }
2386     }
2387     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2388 }
2389 impl AstNode for Label {
2390     fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
2391     fn cast(syntax: SyntaxNode) -> Option<Self> {
2392         if Self::can_cast(syntax.kind()) {
2393             Some(Self { syntax })
2394         } else {
2395             None
2396         }
2397     }
2398     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2399 }
2400 impl AstNode for RecordExprFieldList {
2401     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
2402     fn cast(syntax: SyntaxNode) -> Option<Self> {
2403         if Self::can_cast(syntax.kind()) {
2404             Some(Self { syntax })
2405         } else {
2406             None
2407         }
2408     }
2409     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2410 }
2411 impl AstNode for RecordExprField {
2412     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
2413     fn cast(syntax: SyntaxNode) -> Option<Self> {
2414         if Self::can_cast(syntax.kind()) {
2415             Some(Self { syntax })
2416         } else {
2417             None
2418         }
2419     }
2420     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2421 }
2422 impl AstNode for ArgList {
2423     fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
2424     fn cast(syntax: SyntaxNode) -> Option<Self> {
2425         if Self::can_cast(syntax.kind()) {
2426             Some(Self { syntax })
2427         } else {
2428             None
2429         }
2430     }
2431     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2432 }
2433 impl AstNode for Condition {
2434     fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION }
2435     fn cast(syntax: SyntaxNode) -> Option<Self> {
2436         if Self::can_cast(syntax.kind()) {
2437             Some(Self { syntax })
2438         } else {
2439             None
2440         }
2441     }
2442     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2443 }
2444 impl AstNode for MatchArmList {
2445     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
2446     fn cast(syntax: SyntaxNode) -> Option<Self> {
2447         if Self::can_cast(syntax.kind()) {
2448             Some(Self { syntax })
2449         } else {
2450             None
2451         }
2452     }
2453     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2454 }
2455 impl AstNode for MatchArm {
2456     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
2457     fn cast(syntax: SyntaxNode) -> Option<Self> {
2458         if Self::can_cast(syntax.kind()) {
2459             Some(Self { syntax })
2460         } else {
2461             None
2462         }
2463     }
2464     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2465 }
2466 impl AstNode for MatchGuard {
2467     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
2468     fn cast(syntax: SyntaxNode) -> Option<Self> {
2469         if Self::can_cast(syntax.kind()) {
2470             Some(Self { syntax })
2471         } else {
2472             None
2473         }
2474     }
2475     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2476 }
2477 impl AstNode for ArrayType {
2478     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
2479     fn cast(syntax: SyntaxNode) -> Option<Self> {
2480         if Self::can_cast(syntax.kind()) {
2481             Some(Self { syntax })
2482         } else {
2483             None
2484         }
2485     }
2486     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2487 }
2488 impl AstNode for DynTraitType {
2489     fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
2490     fn cast(syntax: SyntaxNode) -> Option<Self> {
2491         if Self::can_cast(syntax.kind()) {
2492             Some(Self { syntax })
2493         } else {
2494             None
2495         }
2496     }
2497     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2498 }
2499 impl AstNode for FnPtrType {
2500     fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
2501     fn cast(syntax: SyntaxNode) -> Option<Self> {
2502         if Self::can_cast(syntax.kind()) {
2503             Some(Self { syntax })
2504         } else {
2505             None
2506         }
2507     }
2508     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2509 }
2510 impl AstNode for ForType {
2511     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
2512     fn cast(syntax: SyntaxNode) -> Option<Self> {
2513         if Self::can_cast(syntax.kind()) {
2514             Some(Self { syntax })
2515         } else {
2516             None
2517         }
2518     }
2519     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2520 }
2521 impl AstNode for ImplTraitType {
2522     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
2523     fn cast(syntax: SyntaxNode) -> Option<Self> {
2524         if Self::can_cast(syntax.kind()) {
2525             Some(Self { syntax })
2526         } else {
2527             None
2528         }
2529     }
2530     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2531 }
2532 impl AstNode for InferType {
2533     fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
2534     fn cast(syntax: SyntaxNode) -> Option<Self> {
2535         if Self::can_cast(syntax.kind()) {
2536             Some(Self { syntax })
2537         } else {
2538             None
2539         }
2540     }
2541     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2542 }
2543 impl AstNode for NeverType {
2544     fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
2545     fn cast(syntax: SyntaxNode) -> Option<Self> {
2546         if Self::can_cast(syntax.kind()) {
2547             Some(Self { syntax })
2548         } else {
2549             None
2550         }
2551     }
2552     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2553 }
2554 impl AstNode for ParenType {
2555     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
2556     fn cast(syntax: SyntaxNode) -> Option<Self> {
2557         if Self::can_cast(syntax.kind()) {
2558             Some(Self { syntax })
2559         } else {
2560             None
2561         }
2562     }
2563     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2564 }
2565 impl AstNode for PtrType {
2566     fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
2567     fn cast(syntax: SyntaxNode) -> Option<Self> {
2568         if Self::can_cast(syntax.kind()) {
2569             Some(Self { syntax })
2570         } else {
2571             None
2572         }
2573     }
2574     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2575 }
2576 impl AstNode for RefType {
2577     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
2578     fn cast(syntax: SyntaxNode) -> Option<Self> {
2579         if Self::can_cast(syntax.kind()) {
2580             Some(Self { syntax })
2581         } else {
2582             None
2583         }
2584     }
2585     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2586 }
2587 impl AstNode for SliceType {
2588     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
2589     fn cast(syntax: SyntaxNode) -> Option<Self> {
2590         if Self::can_cast(syntax.kind()) {
2591             Some(Self { syntax })
2592         } else {
2593             None
2594         }
2595     }
2596     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2597 }
2598 impl AstNode for TupleType {
2599     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
2600     fn cast(syntax: SyntaxNode) -> Option<Self> {
2601         if Self::can_cast(syntax.kind()) {
2602             Some(Self { syntax })
2603         } else {
2604             None
2605         }
2606     }
2607     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2608 }
2609 impl AstNode for TypeBound {
2610     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
2611     fn cast(syntax: SyntaxNode) -> Option<Self> {
2612         if Self::can_cast(syntax.kind()) {
2613             Some(Self { syntax })
2614         } else {
2615             None
2616         }
2617     }
2618     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2619 }
2620 impl AstNode for IdentPat {
2621     fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
2622     fn cast(syntax: SyntaxNode) -> Option<Self> {
2623         if Self::can_cast(syntax.kind()) {
2624             Some(Self { syntax })
2625         } else {
2626             None
2627         }
2628     }
2629     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2630 }
2631 impl AstNode for BoxPat {
2632     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
2633     fn cast(syntax: SyntaxNode) -> Option<Self> {
2634         if Self::can_cast(syntax.kind()) {
2635             Some(Self { syntax })
2636         } else {
2637             None
2638         }
2639     }
2640     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2641 }
2642 impl AstNode for RestPat {
2643     fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
2644     fn cast(syntax: SyntaxNode) -> Option<Self> {
2645         if Self::can_cast(syntax.kind()) {
2646             Some(Self { syntax })
2647         } else {
2648             None
2649         }
2650     }
2651     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2652 }
2653 impl AstNode for LiteralPat {
2654     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
2655     fn cast(syntax: SyntaxNode) -> Option<Self> {
2656         if Self::can_cast(syntax.kind()) {
2657             Some(Self { syntax })
2658         } else {
2659             None
2660         }
2661     }
2662     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2663 }
2664 impl AstNode for MacroPat {
2665     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
2666     fn cast(syntax: SyntaxNode) -> Option<Self> {
2667         if Self::can_cast(syntax.kind()) {
2668             Some(Self { syntax })
2669         } else {
2670             None
2671         }
2672     }
2673     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2674 }
2675 impl AstNode for OrPat {
2676     fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
2677     fn cast(syntax: SyntaxNode) -> Option<Self> {
2678         if Self::can_cast(syntax.kind()) {
2679             Some(Self { syntax })
2680         } else {
2681             None
2682         }
2683     }
2684     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2685 }
2686 impl AstNode for ParenPat {
2687     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
2688     fn cast(syntax: SyntaxNode) -> Option<Self> {
2689         if Self::can_cast(syntax.kind()) {
2690             Some(Self { syntax })
2691         } else {
2692             None
2693         }
2694     }
2695     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2696 }
2697 impl AstNode for PathPat {
2698     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
2699     fn cast(syntax: SyntaxNode) -> Option<Self> {
2700         if Self::can_cast(syntax.kind()) {
2701             Some(Self { syntax })
2702         } else {
2703             None
2704         }
2705     }
2706     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2707 }
2708 impl AstNode for WildcardPat {
2709     fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
2710     fn cast(syntax: SyntaxNode) -> Option<Self> {
2711         if Self::can_cast(syntax.kind()) {
2712             Some(Self { syntax })
2713         } else {
2714             None
2715         }
2716     }
2717     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2718 }
2719 impl AstNode for RangePat {
2720     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
2721     fn cast(syntax: SyntaxNode) -> Option<Self> {
2722         if Self::can_cast(syntax.kind()) {
2723             Some(Self { syntax })
2724         } else {
2725             None
2726         }
2727     }
2728     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2729 }
2730 impl AstNode for RecordPat {
2731     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
2732     fn cast(syntax: SyntaxNode) -> Option<Self> {
2733         if Self::can_cast(syntax.kind()) {
2734             Some(Self { syntax })
2735         } else {
2736             None
2737         }
2738     }
2739     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2740 }
2741 impl AstNode for RefPat {
2742     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
2743     fn cast(syntax: SyntaxNode) -> Option<Self> {
2744         if Self::can_cast(syntax.kind()) {
2745             Some(Self { syntax })
2746         } else {
2747             None
2748         }
2749     }
2750     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2751 }
2752 impl AstNode for SlicePat {
2753     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
2754     fn cast(syntax: SyntaxNode) -> Option<Self> {
2755         if Self::can_cast(syntax.kind()) {
2756             Some(Self { syntax })
2757         } else {
2758             None
2759         }
2760     }
2761     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2762 }
2763 impl AstNode for TuplePat {
2764     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
2765     fn cast(syntax: SyntaxNode) -> Option<Self> {
2766         if Self::can_cast(syntax.kind()) {
2767             Some(Self { syntax })
2768         } else {
2769             None
2770         }
2771     }
2772     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2773 }
2774 impl AstNode for TupleStructPat {
2775     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
2776     fn cast(syntax: SyntaxNode) -> Option<Self> {
2777         if Self::can_cast(syntax.kind()) {
2778             Some(Self { syntax })
2779         } else {
2780             None
2781         }
2782     }
2783     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2784 }
2785 impl AstNode for ConstBlockPat {
2786     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
2787     fn cast(syntax: SyntaxNode) -> Option<Self> {
2788         if Self::can_cast(syntax.kind()) {
2789             Some(Self { syntax })
2790         } else {
2791             None
2792         }
2793     }
2794     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2795 }
2796 impl AstNode for RecordPatFieldList {
2797     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
2798     fn cast(syntax: SyntaxNode) -> Option<Self> {
2799         if Self::can_cast(syntax.kind()) {
2800             Some(Self { syntax })
2801         } else {
2802             None
2803         }
2804     }
2805     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2806 }
2807 impl AstNode for RecordPatField {
2808     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
2809     fn cast(syntax: SyntaxNode) -> Option<Self> {
2810         if Self::can_cast(syntax.kind()) {
2811             Some(Self { syntax })
2812         } else {
2813             None
2814         }
2815     }
2816     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2817 }
2818 impl From<TypeArg> for GenericArg {
2819     fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
2820 }
2821 impl From<AssocTypeArg> for GenericArg {
2822     fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
2823 }
2824 impl From<LifetimeArg> for GenericArg {
2825     fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
2826 }
2827 impl From<ConstArg> for GenericArg {
2828     fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
2829 }
2830 impl AstNode for GenericArg {
2831     fn can_cast(kind: SyntaxKind) -> bool {
2832         match kind {
2833             TYPE_ARG | ASSOC_TYPE_ARG | LIFETIME_ARG | CONST_ARG => true,
2834             _ => false,
2835         }
2836     }
2837     fn cast(syntax: SyntaxNode) -> Option<Self> {
2838         let res = match syntax.kind() {
2839             TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
2840             ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
2841             LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
2842             CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
2843             _ => return None,
2844         };
2845         Some(res)
2846     }
2847     fn syntax(&self) -> &SyntaxNode {
2848         match self {
2849             GenericArg::TypeArg(it) => &it.syntax,
2850             GenericArg::AssocTypeArg(it) => &it.syntax,
2851             GenericArg::LifetimeArg(it) => &it.syntax,
2852             GenericArg::ConstArg(it) => &it.syntax,
2853         }
2854     }
2855 }
2856 impl From<ArrayType> for Type {
2857     fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
2858 }
2859 impl From<DynTraitType> for Type {
2860     fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
2861 }
2862 impl From<FnPtrType> for Type {
2863     fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
2864 }
2865 impl From<ForType> for Type {
2866     fn from(node: ForType) -> Type { Type::ForType(node) }
2867 }
2868 impl From<ImplTraitType> for Type {
2869     fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
2870 }
2871 impl From<InferType> for Type {
2872     fn from(node: InferType) -> Type { Type::InferType(node) }
2873 }
2874 impl From<NeverType> for Type {
2875     fn from(node: NeverType) -> Type { Type::NeverType(node) }
2876 }
2877 impl From<ParenType> for Type {
2878     fn from(node: ParenType) -> Type { Type::ParenType(node) }
2879 }
2880 impl From<PathType> for Type {
2881     fn from(node: PathType) -> Type { Type::PathType(node) }
2882 }
2883 impl From<PtrType> for Type {
2884     fn from(node: PtrType) -> Type { Type::PtrType(node) }
2885 }
2886 impl From<RefType> for Type {
2887     fn from(node: RefType) -> Type { Type::RefType(node) }
2888 }
2889 impl From<SliceType> for Type {
2890     fn from(node: SliceType) -> Type { Type::SliceType(node) }
2891 }
2892 impl From<TupleType> for Type {
2893     fn from(node: TupleType) -> Type { Type::TupleType(node) }
2894 }
2895 impl AstNode for Type {
2896     fn can_cast(kind: SyntaxKind) -> bool {
2897         match kind {
2898             ARRAY_TYPE | DYN_TRAIT_TYPE | FN_PTR_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE | INFER_TYPE
2899             | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE | SLICE_TYPE
2900             | TUPLE_TYPE => true,
2901             _ => false,
2902         }
2903     }
2904     fn cast(syntax: SyntaxNode) -> Option<Self> {
2905         let res = match syntax.kind() {
2906             ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
2907             DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
2908             FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
2909             FOR_TYPE => Type::ForType(ForType { syntax }),
2910             IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
2911             INFER_TYPE => Type::InferType(InferType { syntax }),
2912             NEVER_TYPE => Type::NeverType(NeverType { syntax }),
2913             PAREN_TYPE => Type::ParenType(ParenType { syntax }),
2914             PATH_TYPE => Type::PathType(PathType { syntax }),
2915             PTR_TYPE => Type::PtrType(PtrType { syntax }),
2916             REF_TYPE => Type::RefType(RefType { syntax }),
2917             SLICE_TYPE => Type::SliceType(SliceType { syntax }),
2918             TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
2919             _ => return None,
2920         };
2921         Some(res)
2922     }
2923     fn syntax(&self) -> &SyntaxNode {
2924         match self {
2925             Type::ArrayType(it) => &it.syntax,
2926             Type::DynTraitType(it) => &it.syntax,
2927             Type::FnPtrType(it) => &it.syntax,
2928             Type::ForType(it) => &it.syntax,
2929             Type::ImplTraitType(it) => &it.syntax,
2930             Type::InferType(it) => &it.syntax,
2931             Type::NeverType(it) => &it.syntax,
2932             Type::ParenType(it) => &it.syntax,
2933             Type::PathType(it) => &it.syntax,
2934             Type::PtrType(it) => &it.syntax,
2935             Type::RefType(it) => &it.syntax,
2936             Type::SliceType(it) => &it.syntax,
2937             Type::TupleType(it) => &it.syntax,
2938         }
2939     }
2940 }
2941 impl From<ArrayExpr> for Expr {
2942     fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
2943 }
2944 impl From<AwaitExpr> for Expr {
2945     fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
2946 }
2947 impl From<BinExpr> for Expr {
2948     fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
2949 }
2950 impl From<BlockExpr> for Expr {
2951     fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
2952 }
2953 impl From<BoxExpr> for Expr {
2954     fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
2955 }
2956 impl From<BreakExpr> for Expr {
2957     fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
2958 }
2959 impl From<CallExpr> for Expr {
2960     fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
2961 }
2962 impl From<CastExpr> for Expr {
2963     fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
2964 }
2965 impl From<ClosureExpr> for Expr {
2966     fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
2967 }
2968 impl From<ContinueExpr> for Expr {
2969     fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
2970 }
2971 impl From<EffectExpr> for Expr {
2972     fn from(node: EffectExpr) -> Expr { Expr::EffectExpr(node) }
2973 }
2974 impl From<FieldExpr> for Expr {
2975     fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
2976 }
2977 impl From<ForExpr> for Expr {
2978     fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
2979 }
2980 impl From<IfExpr> for Expr {
2981     fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
2982 }
2983 impl From<IndexExpr> for Expr {
2984     fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
2985 }
2986 impl From<Literal> for Expr {
2987     fn from(node: Literal) -> Expr { Expr::Literal(node) }
2988 }
2989 impl From<LoopExpr> for Expr {
2990     fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
2991 }
2992 impl From<MacroCall> for Expr {
2993     fn from(node: MacroCall) -> Expr { Expr::MacroCall(node) }
2994 }
2995 impl From<MatchExpr> for Expr {
2996     fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
2997 }
2998 impl From<MethodCallExpr> for Expr {
2999     fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
3000 }
3001 impl From<ParenExpr> for Expr {
3002     fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
3003 }
3004 impl From<PathExpr> for Expr {
3005     fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
3006 }
3007 impl From<PrefixExpr> for Expr {
3008     fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
3009 }
3010 impl From<RangeExpr> for Expr {
3011     fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
3012 }
3013 impl From<RecordExpr> for Expr {
3014     fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
3015 }
3016 impl From<RefExpr> for Expr {
3017     fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
3018 }
3019 impl From<ReturnExpr> for Expr {
3020     fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
3021 }
3022 impl From<TryExpr> for Expr {
3023     fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
3024 }
3025 impl From<TupleExpr> for Expr {
3026     fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
3027 }
3028 impl From<WhileExpr> for Expr {
3029     fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
3030 }
3031 impl AstNode for Expr {
3032     fn can_cast(kind: SyntaxKind) -> bool {
3033         match kind {
3034             ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR
3035             | CAST_EXPR | CLOSURE_EXPR | CONTINUE_EXPR | EFFECT_EXPR | FIELD_EXPR | FOR_EXPR
3036             | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR
3037             | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
3038             | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR => true,
3039             _ => false,
3040         }
3041     }
3042     fn cast(syntax: SyntaxNode) -> Option<Self> {
3043         let res = match syntax.kind() {
3044             ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
3045             AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
3046             BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
3047             BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
3048             BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
3049             BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
3050             CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
3051             CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
3052             CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
3053             CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
3054             EFFECT_EXPR => Expr::EffectExpr(EffectExpr { syntax }),
3055             FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
3056             FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
3057             IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
3058             INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
3059             LITERAL => Expr::Literal(Literal { syntax }),
3060             LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
3061             MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
3062             MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
3063             METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
3064             PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
3065             PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
3066             PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
3067             RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
3068             RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
3069             REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
3070             RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
3071             TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
3072             TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
3073             WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
3074             _ => return None,
3075         };
3076         Some(res)
3077     }
3078     fn syntax(&self) -> &SyntaxNode {
3079         match self {
3080             Expr::ArrayExpr(it) => &it.syntax,
3081             Expr::AwaitExpr(it) => &it.syntax,
3082             Expr::BinExpr(it) => &it.syntax,
3083             Expr::BlockExpr(it) => &it.syntax,
3084             Expr::BoxExpr(it) => &it.syntax,
3085             Expr::BreakExpr(it) => &it.syntax,
3086             Expr::CallExpr(it) => &it.syntax,
3087             Expr::CastExpr(it) => &it.syntax,
3088             Expr::ClosureExpr(it) => &it.syntax,
3089             Expr::ContinueExpr(it) => &it.syntax,
3090             Expr::EffectExpr(it) => &it.syntax,
3091             Expr::FieldExpr(it) => &it.syntax,
3092             Expr::ForExpr(it) => &it.syntax,
3093             Expr::IfExpr(it) => &it.syntax,
3094             Expr::IndexExpr(it) => &it.syntax,
3095             Expr::Literal(it) => &it.syntax,
3096             Expr::LoopExpr(it) => &it.syntax,
3097             Expr::MacroCall(it) => &it.syntax,
3098             Expr::MatchExpr(it) => &it.syntax,
3099             Expr::MethodCallExpr(it) => &it.syntax,
3100             Expr::ParenExpr(it) => &it.syntax,
3101             Expr::PathExpr(it) => &it.syntax,
3102             Expr::PrefixExpr(it) => &it.syntax,
3103             Expr::RangeExpr(it) => &it.syntax,
3104             Expr::RecordExpr(it) => &it.syntax,
3105             Expr::RefExpr(it) => &it.syntax,
3106             Expr::ReturnExpr(it) => &it.syntax,
3107             Expr::TryExpr(it) => &it.syntax,
3108             Expr::TupleExpr(it) => &it.syntax,
3109             Expr::WhileExpr(it) => &it.syntax,
3110         }
3111     }
3112 }
3113 impl From<Const> for Item {
3114     fn from(node: Const) -> Item { Item::Const(node) }
3115 }
3116 impl From<Enum> for Item {
3117     fn from(node: Enum) -> Item { Item::Enum(node) }
3118 }
3119 impl From<ExternBlock> for Item {
3120     fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
3121 }
3122 impl From<ExternCrate> for Item {
3123     fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
3124 }
3125 impl From<Fn> for Item {
3126     fn from(node: Fn) -> Item { Item::Fn(node) }
3127 }
3128 impl From<Impl> for Item {
3129     fn from(node: Impl) -> Item { Item::Impl(node) }
3130 }
3131 impl From<MacroCall> for Item {
3132     fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
3133 }
3134 impl From<MacroRules> for Item {
3135     fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
3136 }
3137 impl From<MacroDef> for Item {
3138     fn from(node: MacroDef) -> Item { Item::MacroDef(node) }
3139 }
3140 impl From<Module> for Item {
3141     fn from(node: Module) -> Item { Item::Module(node) }
3142 }
3143 impl From<Static> for Item {
3144     fn from(node: Static) -> Item { Item::Static(node) }
3145 }
3146 impl From<Struct> for Item {
3147     fn from(node: Struct) -> Item { Item::Struct(node) }
3148 }
3149 impl From<Trait> for Item {
3150     fn from(node: Trait) -> Item { Item::Trait(node) }
3151 }
3152 impl From<TypeAlias> for Item {
3153     fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
3154 }
3155 impl From<Union> for Item {
3156     fn from(node: Union) -> Item { Item::Union(node) }
3157 }
3158 impl From<Use> for Item {
3159     fn from(node: Use) -> Item { Item::Use(node) }
3160 }
3161 impl AstNode for Item {
3162     fn can_cast(kind: SyntaxKind) -> bool {
3163         match kind {
3164             CONST | ENUM | EXTERN_BLOCK | EXTERN_CRATE | FN | IMPL | MACRO_CALL | MACRO_RULES
3165             | MACRO_DEF | MODULE | STATIC | STRUCT | TRAIT | TYPE_ALIAS | UNION | USE => true,
3166             _ => false,
3167         }
3168     }
3169     fn cast(syntax: SyntaxNode) -> Option<Self> {
3170         let res = match syntax.kind() {
3171             CONST => Item::Const(Const { syntax }),
3172             ENUM => Item::Enum(Enum { syntax }),
3173             EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
3174             EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
3175             FN => Item::Fn(Fn { syntax }),
3176             IMPL => Item::Impl(Impl { syntax }),
3177             MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
3178             MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
3179             MACRO_DEF => Item::MacroDef(MacroDef { syntax }),
3180             MODULE => Item::Module(Module { syntax }),
3181             STATIC => Item::Static(Static { syntax }),
3182             STRUCT => Item::Struct(Struct { syntax }),
3183             TRAIT => Item::Trait(Trait { syntax }),
3184             TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
3185             UNION => Item::Union(Union { syntax }),
3186             USE => Item::Use(Use { syntax }),
3187             _ => return None,
3188         };
3189         Some(res)
3190     }
3191     fn syntax(&self) -> &SyntaxNode {
3192         match self {
3193             Item::Const(it) => &it.syntax,
3194             Item::Enum(it) => &it.syntax,
3195             Item::ExternBlock(it) => &it.syntax,
3196             Item::ExternCrate(it) => &it.syntax,
3197             Item::Fn(it) => &it.syntax,
3198             Item::Impl(it) => &it.syntax,
3199             Item::MacroCall(it) => &it.syntax,
3200             Item::MacroRules(it) => &it.syntax,
3201             Item::MacroDef(it) => &it.syntax,
3202             Item::Module(it) => &it.syntax,
3203             Item::Static(it) => &it.syntax,
3204             Item::Struct(it) => &it.syntax,
3205             Item::Trait(it) => &it.syntax,
3206             Item::TypeAlias(it) => &it.syntax,
3207             Item::Union(it) => &it.syntax,
3208             Item::Use(it) => &it.syntax,
3209         }
3210     }
3211 }
3212 impl From<ExprStmt> for Stmt {
3213     fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
3214 }
3215 impl From<Item> for Stmt {
3216     fn from(node: Item) -> Stmt { Stmt::Item(node) }
3217 }
3218 impl From<LetStmt> for Stmt {
3219     fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
3220 }
3221 impl From<IdentPat> for Pat {
3222     fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
3223 }
3224 impl From<BoxPat> for Pat {
3225     fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
3226 }
3227 impl From<RestPat> for Pat {
3228     fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
3229 }
3230 impl From<LiteralPat> for Pat {
3231     fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
3232 }
3233 impl From<MacroPat> for Pat {
3234     fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
3235 }
3236 impl From<OrPat> for Pat {
3237     fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
3238 }
3239 impl From<ParenPat> for Pat {
3240     fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
3241 }
3242 impl From<PathPat> for Pat {
3243     fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
3244 }
3245 impl From<WildcardPat> for Pat {
3246     fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
3247 }
3248 impl From<RangePat> for Pat {
3249     fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
3250 }
3251 impl From<RecordPat> for Pat {
3252     fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
3253 }
3254 impl From<RefPat> for Pat {
3255     fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
3256 }
3257 impl From<SlicePat> for Pat {
3258     fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
3259 }
3260 impl From<TuplePat> for Pat {
3261     fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
3262 }
3263 impl From<TupleStructPat> for Pat {
3264     fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
3265 }
3266 impl From<ConstBlockPat> for Pat {
3267     fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
3268 }
3269 impl AstNode for Pat {
3270     fn can_cast(kind: SyntaxKind) -> bool {
3271         match kind {
3272             IDENT_PAT | BOX_PAT | REST_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT
3273             | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT
3274             | TUPLE_PAT | TUPLE_STRUCT_PAT | CONST_BLOCK_PAT => true,
3275             _ => false,
3276         }
3277     }
3278     fn cast(syntax: SyntaxNode) -> Option<Self> {
3279         let res = match syntax.kind() {
3280             IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
3281             BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
3282             REST_PAT => Pat::RestPat(RestPat { syntax }),
3283             LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
3284             MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
3285             OR_PAT => Pat::OrPat(OrPat { syntax }),
3286             PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
3287             PATH_PAT => Pat::PathPat(PathPat { syntax }),
3288             WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
3289             RANGE_PAT => Pat::RangePat(RangePat { syntax }),
3290             RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
3291             REF_PAT => Pat::RefPat(RefPat { syntax }),
3292             SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
3293             TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
3294             TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
3295             CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
3296             _ => return None,
3297         };
3298         Some(res)
3299     }
3300     fn syntax(&self) -> &SyntaxNode {
3301         match self {
3302             Pat::IdentPat(it) => &it.syntax,
3303             Pat::BoxPat(it) => &it.syntax,
3304             Pat::RestPat(it) => &it.syntax,
3305             Pat::LiteralPat(it) => &it.syntax,
3306             Pat::MacroPat(it) => &it.syntax,
3307             Pat::OrPat(it) => &it.syntax,
3308             Pat::ParenPat(it) => &it.syntax,
3309             Pat::PathPat(it) => &it.syntax,
3310             Pat::WildcardPat(it) => &it.syntax,
3311             Pat::RangePat(it) => &it.syntax,
3312             Pat::RecordPat(it) => &it.syntax,
3313             Pat::RefPat(it) => &it.syntax,
3314             Pat::SlicePat(it) => &it.syntax,
3315             Pat::TuplePat(it) => &it.syntax,
3316             Pat::TupleStructPat(it) => &it.syntax,
3317             Pat::ConstBlockPat(it) => &it.syntax,
3318         }
3319     }
3320 }
3321 impl From<RecordFieldList> for FieldList {
3322     fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
3323 }
3324 impl From<TupleFieldList> for FieldList {
3325     fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
3326 }
3327 impl AstNode for FieldList {
3328     fn can_cast(kind: SyntaxKind) -> bool {
3329         match kind {
3330             RECORD_FIELD_LIST | TUPLE_FIELD_LIST => true,
3331             _ => false,
3332         }
3333     }
3334     fn cast(syntax: SyntaxNode) -> Option<Self> {
3335         let res = match syntax.kind() {
3336             RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
3337             TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
3338             _ => return None,
3339         };
3340         Some(res)
3341     }
3342     fn syntax(&self) -> &SyntaxNode {
3343         match self {
3344             FieldList::RecordFieldList(it) => &it.syntax,
3345             FieldList::TupleFieldList(it) => &it.syntax,
3346         }
3347     }
3348 }
3349 impl From<Enum> for AdtDef {
3350     fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
3351 }
3352 impl From<Struct> for AdtDef {
3353     fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
3354 }
3355 impl From<Union> for AdtDef {
3356     fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
3357 }
3358 impl AstNode for AdtDef {
3359     fn can_cast(kind: SyntaxKind) -> bool {
3360         match kind {
3361             ENUM | STRUCT | UNION => true,
3362             _ => false,
3363         }
3364     }
3365     fn cast(syntax: SyntaxNode) -> Option<Self> {
3366         let res = match syntax.kind() {
3367             ENUM => AdtDef::Enum(Enum { syntax }),
3368             STRUCT => AdtDef::Struct(Struct { syntax }),
3369             UNION => AdtDef::Union(Union { syntax }),
3370             _ => return None,
3371         };
3372         Some(res)
3373     }
3374     fn syntax(&self) -> &SyntaxNode {
3375         match self {
3376             AdtDef::Enum(it) => &it.syntax,
3377             AdtDef::Struct(it) => &it.syntax,
3378             AdtDef::Union(it) => &it.syntax,
3379         }
3380     }
3381 }
3382 impl From<Const> for AssocItem {
3383     fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
3384 }
3385 impl From<Fn> for AssocItem {
3386     fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
3387 }
3388 impl From<MacroCall> for AssocItem {
3389     fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
3390 }
3391 impl From<TypeAlias> for AssocItem {
3392     fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
3393 }
3394 impl AstNode for AssocItem {
3395     fn can_cast(kind: SyntaxKind) -> bool {
3396         match kind {
3397             CONST | FN | MACRO_CALL | TYPE_ALIAS => true,
3398             _ => false,
3399         }
3400     }
3401     fn cast(syntax: SyntaxNode) -> Option<Self> {
3402         let res = match syntax.kind() {
3403             CONST => AssocItem::Const(Const { syntax }),
3404             FN => AssocItem::Fn(Fn { syntax }),
3405             MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
3406             TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
3407             _ => return None,
3408         };
3409         Some(res)
3410     }
3411     fn syntax(&self) -> &SyntaxNode {
3412         match self {
3413             AssocItem::Const(it) => &it.syntax,
3414             AssocItem::Fn(it) => &it.syntax,
3415             AssocItem::MacroCall(it) => &it.syntax,
3416             AssocItem::TypeAlias(it) => &it.syntax,
3417         }
3418     }
3419 }
3420 impl From<Fn> for ExternItem {
3421     fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
3422 }
3423 impl From<MacroCall> for ExternItem {
3424     fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
3425 }
3426 impl From<Static> for ExternItem {
3427     fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
3428 }
3429 impl From<TypeAlias> for ExternItem {
3430     fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) }
3431 }
3432 impl AstNode for ExternItem {
3433     fn can_cast(kind: SyntaxKind) -> bool {
3434         match kind {
3435             FN | MACRO_CALL | STATIC | TYPE_ALIAS => true,
3436             _ => false,
3437         }
3438     }
3439     fn cast(syntax: SyntaxNode) -> Option<Self> {
3440         let res = match syntax.kind() {
3441             FN => ExternItem::Fn(Fn { syntax }),
3442             MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
3443             STATIC => ExternItem::Static(Static { syntax }),
3444             TYPE_ALIAS => ExternItem::TypeAlias(TypeAlias { syntax }),
3445             _ => return None,
3446         };
3447         Some(res)
3448     }
3449     fn syntax(&self) -> &SyntaxNode {
3450         match self {
3451             ExternItem::Fn(it) => &it.syntax,
3452             ExternItem::MacroCall(it) => &it.syntax,
3453             ExternItem::Static(it) => &it.syntax,
3454             ExternItem::TypeAlias(it) => &it.syntax,
3455         }
3456     }
3457 }
3458 impl From<ConstParam> for GenericParam {
3459     fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3460 }
3461 impl From<LifetimeParam> for GenericParam {
3462     fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
3463 }
3464 impl From<TypeParam> for GenericParam {
3465     fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
3466 }
3467 impl AstNode for GenericParam {
3468     fn can_cast(kind: SyntaxKind) -> bool {
3469         match kind {
3470             CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM => true,
3471             _ => false,
3472         }
3473     }
3474     fn cast(syntax: SyntaxNode) -> Option<Self> {
3475         let res = match syntax.kind() {
3476             CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
3477             LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
3478             TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
3479             _ => return None,
3480         };
3481         Some(res)
3482     }
3483     fn syntax(&self) -> &SyntaxNode {
3484         match self {
3485             GenericParam::ConstParam(it) => &it.syntax,
3486             GenericParam::LifetimeParam(it) => &it.syntax,
3487             GenericParam::TypeParam(it) => &it.syntax,
3488         }
3489     }
3490 }
3491 impl std::fmt::Display for GenericArg {
3492     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3493         std::fmt::Display::fmt(self.syntax(), f)
3494     }
3495 }
3496 impl std::fmt::Display for Type {
3497     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3498         std::fmt::Display::fmt(self.syntax(), f)
3499     }
3500 }
3501 impl std::fmt::Display for Expr {
3502     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3503         std::fmt::Display::fmt(self.syntax(), f)
3504     }
3505 }
3506 impl std::fmt::Display for Item {
3507     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3508         std::fmt::Display::fmt(self.syntax(), f)
3509     }
3510 }
3511 impl std::fmt::Display for Stmt {
3512     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3513         std::fmt::Display::fmt(self.syntax(), f)
3514     }
3515 }
3516 impl std::fmt::Display for Pat {
3517     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3518         std::fmt::Display::fmt(self.syntax(), f)
3519     }
3520 }
3521 impl std::fmt::Display for FieldList {
3522     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3523         std::fmt::Display::fmt(self.syntax(), f)
3524     }
3525 }
3526 impl std::fmt::Display for AdtDef {
3527     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3528         std::fmt::Display::fmt(self.syntax(), f)
3529     }
3530 }
3531 impl std::fmt::Display for AssocItem {
3532     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3533         std::fmt::Display::fmt(self.syntax(), f)
3534     }
3535 }
3536 impl std::fmt::Display for ExternItem {
3537     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3538         std::fmt::Display::fmt(self.syntax(), f)
3539     }
3540 }
3541 impl std::fmt::Display for GenericParam {
3542     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3543         std::fmt::Display::fmt(self.syntax(), f)
3544     }
3545 }
3546 impl std::fmt::Display for Name {
3547     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3548         std::fmt::Display::fmt(self.syntax(), f)
3549     }
3550 }
3551 impl std::fmt::Display for NameRef {
3552     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3553         std::fmt::Display::fmt(self.syntax(), f)
3554     }
3555 }
3556 impl std::fmt::Display for Lifetime {
3557     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3558         std::fmt::Display::fmt(self.syntax(), f)
3559     }
3560 }
3561 impl std::fmt::Display for Path {
3562     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3563         std::fmt::Display::fmt(self.syntax(), f)
3564     }
3565 }
3566 impl std::fmt::Display for PathSegment {
3567     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3568         std::fmt::Display::fmt(self.syntax(), f)
3569     }
3570 }
3571 impl std::fmt::Display for GenericArgList {
3572     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3573         std::fmt::Display::fmt(self.syntax(), f)
3574     }
3575 }
3576 impl std::fmt::Display for ParamList {
3577     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3578         std::fmt::Display::fmt(self.syntax(), f)
3579     }
3580 }
3581 impl std::fmt::Display for RetType {
3582     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3583         std::fmt::Display::fmt(self.syntax(), f)
3584     }
3585 }
3586 impl std::fmt::Display for PathType {
3587     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3588         std::fmt::Display::fmt(self.syntax(), f)
3589     }
3590 }
3591 impl std::fmt::Display for TypeArg {
3592     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3593         std::fmt::Display::fmt(self.syntax(), f)
3594     }
3595 }
3596 impl std::fmt::Display for AssocTypeArg {
3597     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3598         std::fmt::Display::fmt(self.syntax(), f)
3599     }
3600 }
3601 impl std::fmt::Display for LifetimeArg {
3602     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3603         std::fmt::Display::fmt(self.syntax(), f)
3604     }
3605 }
3606 impl std::fmt::Display for ConstArg {
3607     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3608         std::fmt::Display::fmt(self.syntax(), f)
3609     }
3610 }
3611 impl std::fmt::Display for TypeBoundList {
3612     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3613         std::fmt::Display::fmt(self.syntax(), f)
3614     }
3615 }
3616 impl std::fmt::Display for MacroCall {
3617     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3618         std::fmt::Display::fmt(self.syntax(), f)
3619     }
3620 }
3621 impl std::fmt::Display for Attr {
3622     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3623         std::fmt::Display::fmt(self.syntax(), f)
3624     }
3625 }
3626 impl std::fmt::Display for TokenTree {
3627     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3628         std::fmt::Display::fmt(self.syntax(), f)
3629     }
3630 }
3631 impl std::fmt::Display for MacroItems {
3632     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3633         std::fmt::Display::fmt(self.syntax(), f)
3634     }
3635 }
3636 impl std::fmt::Display for MacroStmts {
3637     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3638         std::fmt::Display::fmt(self.syntax(), f)
3639     }
3640 }
3641 impl std::fmt::Display for SourceFile {
3642     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643         std::fmt::Display::fmt(self.syntax(), f)
3644     }
3645 }
3646 impl std::fmt::Display for Const {
3647     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3648         std::fmt::Display::fmt(self.syntax(), f)
3649     }
3650 }
3651 impl std::fmt::Display for Enum {
3652     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3653         std::fmt::Display::fmt(self.syntax(), f)
3654     }
3655 }
3656 impl std::fmt::Display for ExternBlock {
3657     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3658         std::fmt::Display::fmt(self.syntax(), f)
3659     }
3660 }
3661 impl std::fmt::Display for ExternCrate {
3662     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3663         std::fmt::Display::fmt(self.syntax(), f)
3664     }
3665 }
3666 impl std::fmt::Display for Fn {
3667     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3668         std::fmt::Display::fmt(self.syntax(), f)
3669     }
3670 }
3671 impl std::fmt::Display for Impl {
3672     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3673         std::fmt::Display::fmt(self.syntax(), f)
3674     }
3675 }
3676 impl std::fmt::Display for MacroRules {
3677     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3678         std::fmt::Display::fmt(self.syntax(), f)
3679     }
3680 }
3681 impl std::fmt::Display for MacroDef {
3682     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3683         std::fmt::Display::fmt(self.syntax(), f)
3684     }
3685 }
3686 impl std::fmt::Display for Module {
3687     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3688         std::fmt::Display::fmt(self.syntax(), f)
3689     }
3690 }
3691 impl std::fmt::Display for Static {
3692     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3693         std::fmt::Display::fmt(self.syntax(), f)
3694     }
3695 }
3696 impl std::fmt::Display for Struct {
3697     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3698         std::fmt::Display::fmt(self.syntax(), f)
3699     }
3700 }
3701 impl std::fmt::Display for Trait {
3702     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3703         std::fmt::Display::fmt(self.syntax(), f)
3704     }
3705 }
3706 impl std::fmt::Display for TypeAlias {
3707     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3708         std::fmt::Display::fmt(self.syntax(), f)
3709     }
3710 }
3711 impl std::fmt::Display for Union {
3712     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3713         std::fmt::Display::fmt(self.syntax(), f)
3714     }
3715 }
3716 impl std::fmt::Display for Use {
3717     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3718         std::fmt::Display::fmt(self.syntax(), f)
3719     }
3720 }
3721 impl std::fmt::Display for Visibility {
3722     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3723         std::fmt::Display::fmt(self.syntax(), f)
3724     }
3725 }
3726 impl std::fmt::Display for ItemList {
3727     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3728         std::fmt::Display::fmt(self.syntax(), f)
3729     }
3730 }
3731 impl std::fmt::Display for Rename {
3732     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3733         std::fmt::Display::fmt(self.syntax(), f)
3734     }
3735 }
3736 impl std::fmt::Display for UseTree {
3737     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3738         std::fmt::Display::fmt(self.syntax(), f)
3739     }
3740 }
3741 impl std::fmt::Display for UseTreeList {
3742     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3743         std::fmt::Display::fmt(self.syntax(), f)
3744     }
3745 }
3746 impl std::fmt::Display for Abi {
3747     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3748         std::fmt::Display::fmt(self.syntax(), f)
3749     }
3750 }
3751 impl std::fmt::Display for GenericParamList {
3752     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3753         std::fmt::Display::fmt(self.syntax(), f)
3754     }
3755 }
3756 impl std::fmt::Display for WhereClause {
3757     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3758         std::fmt::Display::fmt(self.syntax(), f)
3759     }
3760 }
3761 impl std::fmt::Display for BlockExpr {
3762     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3763         std::fmt::Display::fmt(self.syntax(), f)
3764     }
3765 }
3766 impl std::fmt::Display for SelfParam {
3767     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3768         std::fmt::Display::fmt(self.syntax(), f)
3769     }
3770 }
3771 impl std::fmt::Display for Param {
3772     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3773         std::fmt::Display::fmt(self.syntax(), f)
3774     }
3775 }
3776 impl std::fmt::Display for RecordFieldList {
3777     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3778         std::fmt::Display::fmt(self.syntax(), f)
3779     }
3780 }
3781 impl std::fmt::Display for TupleFieldList {
3782     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3783         std::fmt::Display::fmt(self.syntax(), f)
3784     }
3785 }
3786 impl std::fmt::Display for RecordField {
3787     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3788         std::fmt::Display::fmt(self.syntax(), f)
3789     }
3790 }
3791 impl std::fmt::Display for TupleField {
3792     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3793         std::fmt::Display::fmt(self.syntax(), f)
3794     }
3795 }
3796 impl std::fmt::Display for VariantList {
3797     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3798         std::fmt::Display::fmt(self.syntax(), f)
3799     }
3800 }
3801 impl std::fmt::Display for Variant {
3802     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3803         std::fmt::Display::fmt(self.syntax(), f)
3804     }
3805 }
3806 impl std::fmt::Display for AssocItemList {
3807     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808         std::fmt::Display::fmt(self.syntax(), f)
3809     }
3810 }
3811 impl std::fmt::Display for ExternItemList {
3812     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3813         std::fmt::Display::fmt(self.syntax(), f)
3814     }
3815 }
3816 impl std::fmt::Display for ConstParam {
3817     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3818         std::fmt::Display::fmt(self.syntax(), f)
3819     }
3820 }
3821 impl std::fmt::Display for LifetimeParam {
3822     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3823         std::fmt::Display::fmt(self.syntax(), f)
3824     }
3825 }
3826 impl std::fmt::Display for TypeParam {
3827     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3828         std::fmt::Display::fmt(self.syntax(), f)
3829     }
3830 }
3831 impl std::fmt::Display for WherePred {
3832     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3833         std::fmt::Display::fmt(self.syntax(), f)
3834     }
3835 }
3836 impl std::fmt::Display for Literal {
3837     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3838         std::fmt::Display::fmt(self.syntax(), f)
3839     }
3840 }
3841 impl std::fmt::Display for ExprStmt {
3842     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3843         std::fmt::Display::fmt(self.syntax(), f)
3844     }
3845 }
3846 impl std::fmt::Display for LetStmt {
3847     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3848         std::fmt::Display::fmt(self.syntax(), f)
3849     }
3850 }
3851 impl std::fmt::Display for ArrayExpr {
3852     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3853         std::fmt::Display::fmt(self.syntax(), f)
3854     }
3855 }
3856 impl std::fmt::Display for AwaitExpr {
3857     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3858         std::fmt::Display::fmt(self.syntax(), f)
3859     }
3860 }
3861 impl std::fmt::Display for BinExpr {
3862     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3863         std::fmt::Display::fmt(self.syntax(), f)
3864     }
3865 }
3866 impl std::fmt::Display for BoxExpr {
3867     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3868         std::fmt::Display::fmt(self.syntax(), f)
3869     }
3870 }
3871 impl std::fmt::Display for BreakExpr {
3872     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3873         std::fmt::Display::fmt(self.syntax(), f)
3874     }
3875 }
3876 impl std::fmt::Display for CallExpr {
3877     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3878         std::fmt::Display::fmt(self.syntax(), f)
3879     }
3880 }
3881 impl std::fmt::Display for CastExpr {
3882     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3883         std::fmt::Display::fmt(self.syntax(), f)
3884     }
3885 }
3886 impl std::fmt::Display for ClosureExpr {
3887     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3888         std::fmt::Display::fmt(self.syntax(), f)
3889     }
3890 }
3891 impl std::fmt::Display for ContinueExpr {
3892     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3893         std::fmt::Display::fmt(self.syntax(), f)
3894     }
3895 }
3896 impl std::fmt::Display for EffectExpr {
3897     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3898         std::fmt::Display::fmt(self.syntax(), f)
3899     }
3900 }
3901 impl std::fmt::Display for FieldExpr {
3902     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3903         std::fmt::Display::fmt(self.syntax(), f)
3904     }
3905 }
3906 impl std::fmt::Display for ForExpr {
3907     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3908         std::fmt::Display::fmt(self.syntax(), f)
3909     }
3910 }
3911 impl std::fmt::Display for IfExpr {
3912     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3913         std::fmt::Display::fmt(self.syntax(), f)
3914     }
3915 }
3916 impl std::fmt::Display for IndexExpr {
3917     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918         std::fmt::Display::fmt(self.syntax(), f)
3919     }
3920 }
3921 impl std::fmt::Display for LoopExpr {
3922     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3923         std::fmt::Display::fmt(self.syntax(), f)
3924     }
3925 }
3926 impl std::fmt::Display for MatchExpr {
3927     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3928         std::fmt::Display::fmt(self.syntax(), f)
3929     }
3930 }
3931 impl std::fmt::Display for MethodCallExpr {
3932     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3933         std::fmt::Display::fmt(self.syntax(), f)
3934     }
3935 }
3936 impl std::fmt::Display for ParenExpr {
3937     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3938         std::fmt::Display::fmt(self.syntax(), f)
3939     }
3940 }
3941 impl std::fmt::Display for PathExpr {
3942     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3943         std::fmt::Display::fmt(self.syntax(), f)
3944     }
3945 }
3946 impl std::fmt::Display for PrefixExpr {
3947     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3948         std::fmt::Display::fmt(self.syntax(), f)
3949     }
3950 }
3951 impl std::fmt::Display for RangeExpr {
3952     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3953         std::fmt::Display::fmt(self.syntax(), f)
3954     }
3955 }
3956 impl std::fmt::Display for RecordExpr {
3957     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3958         std::fmt::Display::fmt(self.syntax(), f)
3959     }
3960 }
3961 impl std::fmt::Display for RefExpr {
3962     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3963         std::fmt::Display::fmt(self.syntax(), f)
3964     }
3965 }
3966 impl std::fmt::Display for ReturnExpr {
3967     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3968         std::fmt::Display::fmt(self.syntax(), f)
3969     }
3970 }
3971 impl std::fmt::Display for TryExpr {
3972     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3973         std::fmt::Display::fmt(self.syntax(), f)
3974     }
3975 }
3976 impl std::fmt::Display for TupleExpr {
3977     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3978         std::fmt::Display::fmt(self.syntax(), f)
3979     }
3980 }
3981 impl std::fmt::Display for WhileExpr {
3982     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3983         std::fmt::Display::fmt(self.syntax(), f)
3984     }
3985 }
3986 impl std::fmt::Display for Label {
3987     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988         std::fmt::Display::fmt(self.syntax(), f)
3989     }
3990 }
3991 impl std::fmt::Display for RecordExprFieldList {
3992     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3993         std::fmt::Display::fmt(self.syntax(), f)
3994     }
3995 }
3996 impl std::fmt::Display for RecordExprField {
3997     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3998         std::fmt::Display::fmt(self.syntax(), f)
3999     }
4000 }
4001 impl std::fmt::Display for ArgList {
4002     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4003         std::fmt::Display::fmt(self.syntax(), f)
4004     }
4005 }
4006 impl std::fmt::Display for Condition {
4007     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4008         std::fmt::Display::fmt(self.syntax(), f)
4009     }
4010 }
4011 impl std::fmt::Display for MatchArmList {
4012     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4013         std::fmt::Display::fmt(self.syntax(), f)
4014     }
4015 }
4016 impl std::fmt::Display for MatchArm {
4017     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4018         std::fmt::Display::fmt(self.syntax(), f)
4019     }
4020 }
4021 impl std::fmt::Display for MatchGuard {
4022     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4023         std::fmt::Display::fmt(self.syntax(), f)
4024     }
4025 }
4026 impl std::fmt::Display for ArrayType {
4027     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4028         std::fmt::Display::fmt(self.syntax(), f)
4029     }
4030 }
4031 impl std::fmt::Display for DynTraitType {
4032     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4033         std::fmt::Display::fmt(self.syntax(), f)
4034     }
4035 }
4036 impl std::fmt::Display for FnPtrType {
4037     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4038         std::fmt::Display::fmt(self.syntax(), f)
4039     }
4040 }
4041 impl std::fmt::Display for ForType {
4042     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4043         std::fmt::Display::fmt(self.syntax(), f)
4044     }
4045 }
4046 impl std::fmt::Display for ImplTraitType {
4047     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4048         std::fmt::Display::fmt(self.syntax(), f)
4049     }
4050 }
4051 impl std::fmt::Display for InferType {
4052     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4053         std::fmt::Display::fmt(self.syntax(), f)
4054     }
4055 }
4056 impl std::fmt::Display for NeverType {
4057     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4058         std::fmt::Display::fmt(self.syntax(), f)
4059     }
4060 }
4061 impl std::fmt::Display for ParenType {
4062     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4063         std::fmt::Display::fmt(self.syntax(), f)
4064     }
4065 }
4066 impl std::fmt::Display for PtrType {
4067     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4068         std::fmt::Display::fmt(self.syntax(), f)
4069     }
4070 }
4071 impl std::fmt::Display for RefType {
4072     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4073         std::fmt::Display::fmt(self.syntax(), f)
4074     }
4075 }
4076 impl std::fmt::Display for SliceType {
4077     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4078         std::fmt::Display::fmt(self.syntax(), f)
4079     }
4080 }
4081 impl std::fmt::Display for TupleType {
4082     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4083         std::fmt::Display::fmt(self.syntax(), f)
4084     }
4085 }
4086 impl std::fmt::Display for TypeBound {
4087     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4088         std::fmt::Display::fmt(self.syntax(), f)
4089     }
4090 }
4091 impl std::fmt::Display for IdentPat {
4092     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4093         std::fmt::Display::fmt(self.syntax(), f)
4094     }
4095 }
4096 impl std::fmt::Display for BoxPat {
4097     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4098         std::fmt::Display::fmt(self.syntax(), f)
4099     }
4100 }
4101 impl std::fmt::Display for RestPat {
4102     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4103         std::fmt::Display::fmt(self.syntax(), f)
4104     }
4105 }
4106 impl std::fmt::Display for LiteralPat {
4107     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4108         std::fmt::Display::fmt(self.syntax(), f)
4109     }
4110 }
4111 impl std::fmt::Display for MacroPat {
4112     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113         std::fmt::Display::fmt(self.syntax(), f)
4114     }
4115 }
4116 impl std::fmt::Display for OrPat {
4117     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4118         std::fmt::Display::fmt(self.syntax(), f)
4119     }
4120 }
4121 impl std::fmt::Display for ParenPat {
4122     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4123         std::fmt::Display::fmt(self.syntax(), f)
4124     }
4125 }
4126 impl std::fmt::Display for PathPat {
4127     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4128         std::fmt::Display::fmt(self.syntax(), f)
4129     }
4130 }
4131 impl std::fmt::Display for WildcardPat {
4132     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4133         std::fmt::Display::fmt(self.syntax(), f)
4134     }
4135 }
4136 impl std::fmt::Display for RangePat {
4137     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4138         std::fmt::Display::fmt(self.syntax(), f)
4139     }
4140 }
4141 impl std::fmt::Display for RecordPat {
4142     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4143         std::fmt::Display::fmt(self.syntax(), f)
4144     }
4145 }
4146 impl std::fmt::Display for RefPat {
4147     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4148         std::fmt::Display::fmt(self.syntax(), f)
4149     }
4150 }
4151 impl std::fmt::Display for SlicePat {
4152     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4153         std::fmt::Display::fmt(self.syntax(), f)
4154     }
4155 }
4156 impl std::fmt::Display for TuplePat {
4157     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4158         std::fmt::Display::fmt(self.syntax(), f)
4159     }
4160 }
4161 impl std::fmt::Display for TupleStructPat {
4162     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4163         std::fmt::Display::fmt(self.syntax(), f)
4164     }
4165 }
4166 impl std::fmt::Display for ConstBlockPat {
4167     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4168         std::fmt::Display::fmt(self.syntax(), f)
4169     }
4170 }
4171 impl std::fmt::Display for RecordPatFieldList {
4172     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4173         std::fmt::Display::fmt(self.syntax(), f)
4174     }
4175 }
4176 impl std::fmt::Display for RecordPatField {
4177     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4178         std::fmt::Display::fmt(self.syntax(), f)
4179     }
4180 }