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