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

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