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