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

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