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