Skip to main content

ra_ap_syntax/ast/generated/
nodes.rs

1//! Generated by `cargo xtask codegen grammar`, do not edit by hand.
2
3#![allow(non_snake_case)]
4use crate::{
5    SyntaxKind::{self, *},
6    SyntaxNode, SyntaxToken, T,
7    ast::{self, AstChildren, AstNode, support},
8};
9use std::{fmt, hash};
10pub struct Abi {
11    pub(crate) syntax: SyntaxNode,
12}
13impl Abi {
14    #[inline]
15    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
16    #[inline]
17    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
18}
19pub struct ArgList {
20    pub(crate) syntax: SyntaxNode,
21}
22impl ArgList {
23    #[inline]
24    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
25    #[inline]
26    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
27}
28pub struct ArrayExpr {
29    pub(crate) syntax: SyntaxNode,
30}
31impl ast::HasAttrs for ArrayExpr {}
32impl ArrayExpr {
33    #[inline]
34    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
35    #[inline]
36    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
37    #[inline]
38    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
39    #[inline]
40    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
41    #[inline]
42    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
43}
44pub struct ArrayType {
45    pub(crate) syntax: SyntaxNode,
46}
47impl ArrayType {
48    #[inline]
49    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
50    #[inline]
51    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
52    #[inline]
53    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
54    #[inline]
55    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
56    #[inline]
57    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
58}
59pub struct AsmClobberAbi {
60    pub(crate) syntax: SyntaxNode,
61}
62impl ast::HasAttrs for AsmClobberAbi {}
63impl AsmClobberAbi {
64    #[inline]
65    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
66    #[inline]
67    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
68    #[inline]
69    pub fn clobber_abi_token(&self) -> Option<SyntaxToken> {
70        support::token(&self.syntax, T![clobber_abi])
71    }
72    #[inline]
73    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
74}
75pub struct AsmConst {
76    pub(crate) syntax: SyntaxNode,
77}
78impl AsmConst {
79    #[inline]
80    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
81    #[inline]
82    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
83}
84pub struct AsmDirSpec {
85    pub(crate) syntax: SyntaxNode,
86}
87impl AsmDirSpec {
88    #[inline]
89    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
90    #[inline]
91    pub fn inlateout_token(&self) -> Option<SyntaxToken> {
92        support::token(&self.syntax, T![inlateout])
93    }
94    #[inline]
95    pub fn inout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![inout]) }
96    #[inline]
97    pub fn lateout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![lateout]) }
98    #[inline]
99    pub fn out_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![out]) }
100}
101pub struct AsmExpr {
102    pub(crate) syntax: SyntaxNode,
103}
104impl ast::HasAttrs for AsmExpr {}
105impl AsmExpr {
106    #[inline]
107    pub fn asm_pieces(&self) -> AstChildren<AsmPiece> { support::children(&self.syntax) }
108    #[inline]
109    pub fn template(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
110    #[inline]
111    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
112    #[inline]
113    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
114    #[inline]
115    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
116    #[inline]
117    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
118    #[inline]
119    pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) }
120    #[inline]
121    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
122    #[inline]
123    pub fn global_asm_token(&self) -> Option<SyntaxToken> {
124        support::token(&self.syntax, T![global_asm])
125    }
126    #[inline]
127    pub fn naked_asm_token(&self) -> Option<SyntaxToken> {
128        support::token(&self.syntax, T![naked_asm])
129    }
130}
131pub struct AsmLabel {
132    pub(crate) syntax: SyntaxNode,
133}
134impl AsmLabel {
135    #[inline]
136    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
137    #[inline]
138    pub fn label_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![label]) }
139}
140pub struct AsmOperandExpr {
141    pub(crate) syntax: SyntaxNode,
142}
143impl AsmOperandExpr {
144    #[inline]
145    pub fn in_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
146    #[inline]
147    pub fn out_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
148    #[inline]
149    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
150}
151pub struct AsmOperandNamed {
152    pub(crate) syntax: SyntaxNode,
153}
154impl ast::HasAttrs for AsmOperandNamed {}
155impl ast::HasName for AsmOperandNamed {}
156impl AsmOperandNamed {
157    #[inline]
158    pub fn asm_operand(&self) -> Option<AsmOperand> { support::child(&self.syntax) }
159    #[inline]
160    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
161}
162pub struct AsmOption {
163    pub(crate) syntax: SyntaxNode,
164}
165impl AsmOption {
166    #[inline]
167    pub fn att_syntax_token(&self) -> Option<SyntaxToken> {
168        support::token(&self.syntax, T![att_syntax])
169    }
170    #[inline]
171    pub fn may_unwind_token(&self) -> Option<SyntaxToken> {
172        support::token(&self.syntax, T![may_unwind])
173    }
174    #[inline]
175    pub fn nomem_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nomem]) }
176    #[inline]
177    pub fn noreturn_token(&self) -> Option<SyntaxToken> {
178        support::token(&self.syntax, T![noreturn])
179    }
180    #[inline]
181    pub fn nostack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nostack]) }
182    #[inline]
183    pub fn preserves_flags_token(&self) -> Option<SyntaxToken> {
184        support::token(&self.syntax, T![preserves_flags])
185    }
186    #[inline]
187    pub fn pure_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pure]) }
188    #[inline]
189    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
190    #[inline]
191    pub fn readonly_token(&self) -> Option<SyntaxToken> {
192        support::token(&self.syntax, T![readonly])
193    }
194}
195pub struct AsmOptions {
196    pub(crate) syntax: SyntaxNode,
197}
198impl ast::HasAttrs for AsmOptions {}
199impl AsmOptions {
200    #[inline]
201    pub fn asm_options(&self) -> AstChildren<AsmOption> { support::children(&self.syntax) }
202    #[inline]
203    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
204    #[inline]
205    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
206    #[inline]
207    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
208    #[inline]
209    pub fn options_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![options]) }
210}
211pub struct AsmRegOperand {
212    pub(crate) syntax: SyntaxNode,
213}
214impl AsmRegOperand {
215    #[inline]
216    pub fn asm_dir_spec(&self) -> Option<AsmDirSpec> { support::child(&self.syntax) }
217    #[inline]
218    pub fn asm_operand_expr(&self) -> Option<AsmOperandExpr> { support::child(&self.syntax) }
219    #[inline]
220    pub fn asm_reg_spec(&self) -> Option<AsmRegSpec> { support::child(&self.syntax) }
221    #[inline]
222    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
223    #[inline]
224    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
225}
226pub struct AsmRegSpec {
227    pub(crate) syntax: SyntaxNode,
228}
229impl AsmRegSpec {
230    #[inline]
231    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
232    #[inline]
233    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
234}
235pub struct AsmSym {
236    pub(crate) syntax: SyntaxNode,
237}
238impl AsmSym {
239    #[inline]
240    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
241    #[inline]
242    pub fn sym_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![sym]) }
243}
244pub struct AssocItemList {
245    pub(crate) syntax: SyntaxNode,
246}
247impl ast::HasAttrs for AssocItemList {}
248impl AssocItemList {
249    #[inline]
250    pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
251    #[inline]
252    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
253    #[inline]
254    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
255}
256pub struct AssocTypeArg {
257    pub(crate) syntax: SyntaxNode,
258}
259impl ast::HasGenericArgs for AssocTypeArg {}
260impl ast::HasTypeBounds for AssocTypeArg {}
261impl AssocTypeArg {
262    #[inline]
263    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
264    #[inline]
265    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
266    #[inline]
267    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
268    #[inline]
269    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
270    #[inline]
271    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }
272    #[inline]
273    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
274    #[inline]
275    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
276}
277pub struct Attr {
278    pub(crate) syntax: SyntaxNode,
279}
280impl Attr {
281    #[inline]
282    pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) }
283    #[inline]
284    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
285    #[inline]
286    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
287    #[inline]
288    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
289    #[inline]
290    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
291}
292pub struct AwaitExpr {
293    pub(crate) syntax: SyntaxNode,
294}
295impl ast::HasAttrs for AwaitExpr {}
296impl AwaitExpr {
297    #[inline]
298    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
299    #[inline]
300    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
301    #[inline]
302    pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
303}
304pub struct BecomeExpr {
305    pub(crate) syntax: SyntaxNode,
306}
307impl ast::HasAttrs for BecomeExpr {}
308impl BecomeExpr {
309    #[inline]
310    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
311    #[inline]
312    pub fn become_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![become]) }
313}
314pub struct BinExpr {
315    pub(crate) syntax: SyntaxNode,
316}
317impl ast::HasAttrs for BinExpr {}
318impl BinExpr {}
319pub struct BlockExpr {
320    pub(crate) syntax: SyntaxNode,
321}
322impl ast::HasAttrs for BlockExpr {}
323impl BlockExpr {
324    #[inline]
325    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
326    #[inline]
327    pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) }
328    #[inline]
329    pub fn try_block_modifier(&self) -> Option<TryBlockModifier> { support::child(&self.syntax) }
330    #[inline]
331    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
332    #[inline]
333    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
334    #[inline]
335    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
336    #[inline]
337    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
338    #[inline]
339    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
340}
341pub struct BoxPat {
342    pub(crate) syntax: SyntaxNode,
343}
344impl BoxPat {
345    #[inline]
346    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
347    #[inline]
348    pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
349}
350pub struct BreakExpr {
351    pub(crate) syntax: SyntaxNode,
352}
353impl ast::HasAttrs for BreakExpr {}
354impl BreakExpr {
355    #[inline]
356    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
357    #[inline]
358    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
359    #[inline]
360    pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
361}
362pub struct CallExpr {
363    pub(crate) syntax: SyntaxNode,
364}
365impl ast::HasArgList for CallExpr {}
366impl ast::HasAttrs for CallExpr {}
367impl CallExpr {
368    #[inline]
369    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
370}
371pub struct CastExpr {
372    pub(crate) syntax: SyntaxNode,
373}
374impl ast::HasAttrs for CastExpr {}
375impl CastExpr {
376    #[inline]
377    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
378    #[inline]
379    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
380    #[inline]
381    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
382}
383pub struct CfgAtom {
384    pub(crate) syntax: SyntaxNode,
385}
386impl CfgAtom {
387    #[inline]
388    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
389    #[inline]
390    pub fn false_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![false]) }
391    #[inline]
392    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
393    #[inline]
394    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }
395    #[inline]
396    pub fn true_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![true]) }
397}
398pub struct CfgAttrMeta {
399    pub(crate) syntax: SyntaxNode,
400}
401impl CfgAttrMeta {
402    #[inline]
403    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }
404    #[inline]
405    pub fn metas(&self) -> AstChildren<Meta> { support::children(&self.syntax) }
406    #[inline]
407    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
408    #[inline]
409    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
410    #[inline]
411    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
412    #[inline]
413    pub fn cfg_attr_token(&self) -> Option<SyntaxToken> {
414        support::token(&self.syntax, T![cfg_attr])
415    }
416}
417pub struct CfgComposite {
418    pub(crate) syntax: SyntaxNode,
419}
420impl CfgComposite {
421    #[inline]
422    pub fn cfg_predicates(&self) -> AstChildren<CfgPredicate> { support::children(&self.syntax) }
423    #[inline]
424    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
425    #[inline]
426    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
427    #[inline]
428    pub fn keyword(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
429}
430pub struct CfgMeta {
431    pub(crate) syntax: SyntaxNode,
432}
433impl CfgMeta {
434    #[inline]
435    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }
436    #[inline]
437    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
438    #[inline]
439    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
440    #[inline]
441    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
442    #[inline]
443    pub fn cfg_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![cfg]) }
444}
445pub struct ClosureExpr {
446    pub(crate) syntax: SyntaxNode,
447}
448impl ast::HasAttrs for ClosureExpr {}
449impl ClosureExpr {
450    #[inline]
451    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
452    #[inline]
453    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
454    #[inline]
455    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
456    #[inline]
457    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
458    #[inline]
459    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
460    #[inline]
461    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
462    #[inline]
463    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
464    #[inline]
465    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
466}
467pub struct Const {
468    pub(crate) syntax: SyntaxNode,
469}
470impl ast::HasAttrs for Const {}
471impl ast::HasDocComments for Const {}
472impl ast::HasGenericParams for Const {}
473impl ast::HasName for Const {}
474impl ast::HasVisibility for Const {}
475impl Const {
476    #[inline]
477    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
478    #[inline]
479    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
480    #[inline]
481    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
482    #[inline]
483    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
484    #[inline]
485    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
486    #[inline]
487    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
488    #[inline]
489    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
490    #[inline]
491    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
492}
493pub struct ConstArg {
494    pub(crate) syntax: SyntaxNode,
495}
496impl ConstArg {
497    #[inline]
498    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
499}
500pub struct ConstBlockPat {
501    pub(crate) syntax: SyntaxNode,
502}
503impl ConstBlockPat {
504    #[inline]
505    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
506    #[inline]
507    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
508}
509pub struct ConstParam {
510    pub(crate) syntax: SyntaxNode,
511}
512impl ast::HasAttrs for ConstParam {}
513impl ast::HasName for ConstParam {}
514impl ConstParam {
515    #[inline]
516    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }
517    #[inline]
518    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
519    #[inline]
520    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
521    #[inline]
522    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
523    #[inline]
524    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
525}
526pub struct ContinueExpr {
527    pub(crate) syntax: SyntaxNode,
528}
529impl ast::HasAttrs for ContinueExpr {}
530impl ContinueExpr {
531    #[inline]
532    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
533    #[inline]
534    pub fn continue_token(&self) -> Option<SyntaxToken> {
535        support::token(&self.syntax, T![continue])
536    }
537}
538pub struct DerefPat {
539    pub(crate) syntax: SyntaxNode,
540}
541impl DerefPat {
542    #[inline]
543    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
544    #[inline]
545    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
546    #[inline]
547    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
548    #[inline]
549    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
550    #[inline]
551    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
552    #[inline]
553    pub fn deref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![deref]) }
554}
555pub struct DynTraitType {
556    pub(crate) syntax: SyntaxNode,
557}
558impl DynTraitType {
559    #[inline]
560    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
561    #[inline]
562    pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
563}
564pub struct Enum {
565    pub(crate) syntax: SyntaxNode,
566}
567impl ast::HasAttrs for Enum {}
568impl ast::HasDocComments for Enum {}
569impl ast::HasGenericParams for Enum {}
570impl ast::HasName for Enum {}
571impl ast::HasVisibility for Enum {}
572impl Enum {
573    #[inline]
574    pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
575    #[inline]
576    pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
577}
578pub struct ExprStmt {
579    pub(crate) syntax: SyntaxNode,
580}
581impl ExprStmt {
582    #[inline]
583    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
584    #[inline]
585    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
586}
587pub struct ExternBlock {
588    pub(crate) syntax: SyntaxNode,
589}
590impl ast::HasAttrs for ExternBlock {}
591impl ast::HasDocComments for ExternBlock {}
592impl ExternBlock {
593    #[inline]
594    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
595    #[inline]
596    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
597    #[inline]
598    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
599}
600pub struct ExternCrate {
601    pub(crate) syntax: SyntaxNode,
602}
603impl ast::HasAttrs for ExternCrate {}
604impl ast::HasDocComments for ExternCrate {}
605impl ast::HasVisibility for ExternCrate {}
606impl ExternCrate {
607    #[inline]
608    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
609    #[inline]
610    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
611    #[inline]
612    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
613    #[inline]
614    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
615    #[inline]
616    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
617}
618pub struct ExternItemList {
619    pub(crate) syntax: SyntaxNode,
620}
621impl ast::HasAttrs for ExternItemList {}
622impl ExternItemList {
623    #[inline]
624    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
625    #[inline]
626    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
627    #[inline]
628    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
629}
630pub struct FieldExpr {
631    pub(crate) syntax: SyntaxNode,
632}
633impl ast::HasAttrs for FieldExpr {}
634impl FieldExpr {
635    #[inline]
636    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
637    #[inline]
638    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
639    #[inline]
640    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
641}
642pub struct Fn {
643    pub(crate) syntax: SyntaxNode,
644}
645impl ast::HasAttrs for Fn {}
646impl ast::HasDocComments for Fn {}
647impl ast::HasGenericParams for Fn {}
648impl ast::HasName for Fn {}
649impl ast::HasVisibility for Fn {}
650impl Fn {
651    #[inline]
652    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
653    #[inline]
654    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
655    #[inline]
656    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
657    #[inline]
658    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
659    #[inline]
660    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
661    #[inline]
662    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
663    #[inline]
664    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
665    #[inline]
666    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
667    #[inline]
668    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }
669    #[inline]
670    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }
671    #[inline]
672    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
673}
674pub struct FnPtrType {
675    pub(crate) syntax: SyntaxNode,
676}
677impl FnPtrType {
678    #[inline]
679    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
680    #[inline]
681    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
682    #[inline]
683    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
684    #[inline]
685    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
686    #[inline]
687    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
688    #[inline]
689    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
690    #[inline]
691    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
692}
693pub struct ForBinder {
694    pub(crate) syntax: SyntaxNode,
695}
696impl ForBinder {
697    #[inline]
698    pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
699    #[inline]
700    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
701}
702pub struct ForExpr {
703    pub(crate) syntax: SyntaxNode,
704}
705impl ast::HasAttrs for ForExpr {}
706impl ForExpr {
707    #[inline]
708    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
709    #[inline]
710    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
711    #[inline]
712    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
713}
714pub struct ForType {
715    pub(crate) syntax: SyntaxNode,
716}
717impl ForType {
718    #[inline]
719    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
720    #[inline]
721    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
722}
723pub struct FormatArgsArg {
724    pub(crate) syntax: SyntaxNode,
725}
726impl FormatArgsArg {
727    #[inline]
728    pub fn arg_name(&self) -> Option<FormatArgsArgName> { support::child(&self.syntax) }
729    #[inline]
730    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
731}
732pub struct FormatArgsArgName {
733    pub(crate) syntax: SyntaxNode,
734}
735impl FormatArgsArgName {
736    #[inline]
737    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
738}
739pub struct FormatArgsExpr {
740    pub(crate) syntax: SyntaxNode,
741}
742impl ast::HasAttrs for FormatArgsExpr {}
743impl FormatArgsExpr {
744    #[inline]
745    pub fn template(&self) -> Option<Expr> { support::child(&self.syntax) }
746    #[inline]
747    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
748    #[inline]
749    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
750    #[inline]
751    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
752    #[inline]
753    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
754    #[inline]
755    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
756    #[inline]
757    pub fn format_args_token(&self) -> Option<SyntaxToken> {
758        support::token(&self.syntax, T![format_args])
759    }
760}
761pub struct GenericArgList {
762    pub(crate) syntax: SyntaxNode,
763}
764impl GenericArgList {
765    #[inline]
766    pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
767    #[inline]
768    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
769    #[inline]
770    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
771    #[inline]
772    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
773}
774pub struct GenericParamList {
775    pub(crate) syntax: SyntaxNode,
776}
777impl GenericParamList {
778    #[inline]
779    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
780    #[inline]
781    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
782    #[inline]
783    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
784}
785pub struct IdentPat {
786    pub(crate) syntax: SyntaxNode,
787}
788impl ast::HasAttrs for IdentPat {}
789impl ast::HasName for IdentPat {}
790impl IdentPat {
791    #[inline]
792    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
793    #[inline]
794    pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
795    #[inline]
796    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
797    #[inline]
798    pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
799}
800pub struct IfExpr {
801    pub(crate) syntax: SyntaxNode,
802}
803impl ast::HasAttrs for IfExpr {}
804impl IfExpr {
805    #[inline]
806    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
807    #[inline]
808    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
809}
810pub struct Impl {
811    pub(crate) syntax: SyntaxNode,
812}
813impl ast::HasAttrs for Impl {}
814impl ast::HasDocComments for Impl {}
815impl ast::HasGenericParams for Impl {}
816impl ast::HasVisibility for Impl {}
817impl Impl {
818    #[inline]
819    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
820    #[inline]
821    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
822    #[inline]
823    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
824    #[inline]
825    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
826    #[inline]
827    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
828    #[inline]
829    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
830    #[inline]
831    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
832}
833pub struct ImplRestriction {
834    pub(crate) syntax: SyntaxNode,
835}
836impl ImplRestriction {
837    #[inline]
838    pub fn visibility_inner(&self) -> Option<VisibilityInner> { support::child(&self.syntax) }
839    #[inline]
840    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
841}
842pub struct ImplTraitType {
843    pub(crate) syntax: SyntaxNode,
844}
845impl ImplTraitType {
846    #[inline]
847    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
848    #[inline]
849    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
850}
851pub struct IncludeBytesExpr {
852    pub(crate) syntax: SyntaxNode,
853}
854impl IncludeBytesExpr {
855    #[inline]
856    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
857    #[inline]
858    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
859    #[inline]
860    pub fn include_bytes_token(&self) -> Option<SyntaxToken> {
861        support::token(&self.syntax, T![include_bytes])
862    }
863}
864pub struct IndexExpr {
865    pub(crate) syntax: SyntaxNode,
866}
867impl ast::HasAttrs for IndexExpr {}
868impl IndexExpr {
869    #[inline]
870    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
871    #[inline]
872    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
873}
874pub struct InferType {
875    pub(crate) syntax: SyntaxNode,
876}
877impl InferType {
878    #[inline]
879    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
880}
881pub struct ItemList {
882    pub(crate) syntax: SyntaxNode,
883}
884impl ast::HasAttrs for ItemList {}
885impl ast::HasModuleItem for ItemList {}
886impl ItemList {
887    #[inline]
888    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
889    #[inline]
890    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
891}
892pub struct KeyValueMeta {
893    pub(crate) syntax: SyntaxNode,
894}
895impl KeyValueMeta {
896    #[inline]
897    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
898    #[inline]
899    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
900    #[inline]
901    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
902}
903pub struct Label {
904    pub(crate) syntax: SyntaxNode,
905}
906impl Label {
907    #[inline]
908    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
909    #[inline]
910    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
911}
912pub struct LetElse {
913    pub(crate) syntax: SyntaxNode,
914}
915impl LetElse {
916    #[inline]
917    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
918    #[inline]
919    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
920}
921pub struct LetExpr {
922    pub(crate) syntax: SyntaxNode,
923}
924impl ast::HasAttrs for LetExpr {}
925impl LetExpr {
926    #[inline]
927    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
928    #[inline]
929    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
930    #[inline]
931    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
932    #[inline]
933    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
934}
935pub struct LetStmt {
936    pub(crate) syntax: SyntaxNode,
937}
938impl ast::HasAttrs for LetStmt {}
939impl LetStmt {
940    #[inline]
941    pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
942    #[inline]
943    pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) }
944    #[inline]
945    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
946    #[inline]
947    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
948    #[inline]
949    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
950    #[inline]
951    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
952    #[inline]
953    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
954    #[inline]
955    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
956    #[inline]
957    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
958}
959pub struct Lifetime {
960    pub(crate) syntax: SyntaxNode,
961}
962impl Lifetime {
963    #[inline]
964    pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> {
965        support::token(&self.syntax, T![lifetime_ident])
966    }
967}
968pub struct LifetimeArg {
969    pub(crate) syntax: SyntaxNode,
970}
971impl LifetimeArg {
972    #[inline]
973    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
974}
975pub struct LifetimeParam {
976    pub(crate) syntax: SyntaxNode,
977}
978impl ast::HasAttrs for LifetimeParam {}
979impl ast::HasTypeBounds for LifetimeParam {}
980impl LifetimeParam {
981    #[inline]
982    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
983}
984pub struct Literal {
985    pub(crate) syntax: SyntaxNode,
986}
987impl ast::HasAttrs for Literal {}
988impl Literal {}
989pub struct LiteralPat {
990    pub(crate) syntax: SyntaxNode,
991}
992impl LiteralPat {
993    #[inline]
994    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
995    #[inline]
996    pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }
997}
998pub struct LoopExpr {
999    pub(crate) syntax: SyntaxNode,
1000}
1001impl ast::HasAttrs for LoopExpr {}
1002impl ast::HasLoopBody for LoopExpr {}
1003impl LoopExpr {
1004    #[inline]
1005    pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
1006}
1007pub struct MacroCall {
1008    pub(crate) syntax: SyntaxNode,
1009}
1010impl ast::HasAttrs for MacroCall {}
1011impl ast::HasDocComments for MacroCall {}
1012impl MacroCall {
1013    #[inline]
1014    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1015    #[inline]
1016    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1017    #[inline]
1018    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1019    #[inline]
1020    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1021}
1022pub struct MacroDef {
1023    pub(crate) syntax: SyntaxNode,
1024}
1025impl ast::HasAttrs for MacroDef {}
1026impl ast::HasDocComments for MacroDef {}
1027impl ast::HasName for MacroDef {}
1028impl ast::HasVisibility for MacroDef {}
1029impl MacroDef {
1030    #[inline]
1031    pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) }
1032}
1033pub struct MacroExpr {
1034    pub(crate) syntax: SyntaxNode,
1035}
1036impl MacroExpr {
1037    #[inline]
1038    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1039}
1040pub struct MacroItems {
1041    pub(crate) syntax: SyntaxNode,
1042}
1043impl ast::HasModuleItem for MacroItems {}
1044impl MacroItems {}
1045pub struct MacroPat {
1046    pub(crate) syntax: SyntaxNode,
1047}
1048impl MacroPat {
1049    #[inline]
1050    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1051}
1052pub struct MacroRules {
1053    pub(crate) syntax: SyntaxNode,
1054}
1055impl ast::HasAttrs for MacroRules {}
1056impl ast::HasDocComments for MacroRules {}
1057impl ast::HasName for MacroRules {}
1058impl ast::HasVisibility for MacroRules {}
1059impl MacroRules {
1060    #[inline]
1061    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1062    #[inline]
1063    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1064    #[inline]
1065    pub fn macro_rules_token(&self) -> Option<SyntaxToken> {
1066        support::token(&self.syntax, T![macro_rules])
1067    }
1068}
1069pub struct MacroStmts {
1070    pub(crate) syntax: SyntaxNode,
1071}
1072impl MacroStmts {
1073    #[inline]
1074    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1075    #[inline]
1076    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
1077}
1078pub struct MacroType {
1079    pub(crate) syntax: SyntaxNode,
1080}
1081impl MacroType {
1082    #[inline]
1083    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1084}
1085pub struct MatchArm {
1086    pub(crate) syntax: SyntaxNode,
1087}
1088impl ast::HasAttrs for MatchArm {}
1089impl MatchArm {
1090    #[inline]
1091    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1092    #[inline]
1093    pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
1094    #[inline]
1095    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1096    #[inline]
1097    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1098    #[inline]
1099    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
1100}
1101pub struct MatchArmList {
1102    pub(crate) syntax: SyntaxNode,
1103}
1104impl ast::HasAttrs for MatchArmList {}
1105impl MatchArmList {
1106    #[inline]
1107    pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
1108    #[inline]
1109    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1110    #[inline]
1111    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1112}
1113pub struct MatchExpr {
1114    pub(crate) syntax: SyntaxNode,
1115}
1116impl ast::HasAttrs for MatchExpr {}
1117impl MatchExpr {
1118    #[inline]
1119    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1120    #[inline]
1121    pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
1122    #[inline]
1123    pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
1124}
1125pub struct MatchGuard {
1126    pub(crate) syntax: SyntaxNode,
1127}
1128impl MatchGuard {
1129    #[inline]
1130    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
1131}
1132pub struct MethodCallExpr {
1133    pub(crate) syntax: SyntaxNode,
1134}
1135impl ast::HasArgList for MethodCallExpr {}
1136impl ast::HasAttrs for MethodCallExpr {}
1137impl ast::HasGenericArgs for MethodCallExpr {}
1138impl MethodCallExpr {
1139    #[inline]
1140    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1141    #[inline]
1142    pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }
1143    #[inline]
1144    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
1145}
1146pub struct Module {
1147    pub(crate) syntax: SyntaxNode,
1148}
1149impl ast::HasAttrs for Module {}
1150impl ast::HasDocComments for Module {}
1151impl ast::HasName for Module {}
1152impl ast::HasVisibility for Module {}
1153impl Module {
1154    #[inline]
1155    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
1156    #[inline]
1157    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1158    #[inline]
1159    pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
1160}
1161pub struct MutRestriction {
1162    pub(crate) syntax: SyntaxNode,
1163}
1164impl MutRestriction {
1165    #[inline]
1166    pub fn visibility_inner(&self) -> Option<VisibilityInner> { support::child(&self.syntax) }
1167    #[inline]
1168    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1169}
1170pub struct Name {
1171    pub(crate) syntax: SyntaxNode,
1172}
1173impl Name {
1174    #[inline]
1175    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
1176    #[inline]
1177    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
1178}
1179pub struct NameRef {
1180    pub(crate) syntax: SyntaxNode,
1181}
1182impl NameRef {
1183    #[inline]
1184    pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) }
1185    #[inline]
1186    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
1187    #[inline]
1188    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
1189    #[inline]
1190    pub fn int_number_token(&self) -> Option<SyntaxToken> {
1191        support::token(&self.syntax, T![int_number])
1192    }
1193    #[inline]
1194    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
1195    #[inline]
1196    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
1197}
1198pub struct NeverType {
1199    pub(crate) syntax: SyntaxNode,
1200}
1201impl NeverType {
1202    #[inline]
1203    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1204}
1205pub struct NotNull {
1206    pub(crate) syntax: SyntaxNode,
1207}
1208impl NotNull {
1209    #[inline]
1210    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1211    #[inline]
1212    pub fn null_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![null]) }
1213}
1214pub struct OffsetOfExpr {
1215    pub(crate) syntax: SyntaxNode,
1216}
1217impl ast::HasAttrs for OffsetOfExpr {}
1218impl OffsetOfExpr {
1219    #[inline]
1220    pub fn fields(&self) -> AstChildren<NameRef> { support::children(&self.syntax) }
1221    #[inline]
1222    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1223    #[inline]
1224    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
1225    #[inline]
1226    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1227    #[inline]
1228    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1229    #[inline]
1230    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1231    #[inline]
1232    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
1233    #[inline]
1234    pub fn offset_of_token(&self) -> Option<SyntaxToken> {
1235        support::token(&self.syntax, T![offset_of])
1236    }
1237}
1238pub struct OrPat {
1239    pub(crate) syntax: SyntaxNode,
1240}
1241impl OrPat {
1242    #[inline]
1243    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1244    #[inline]
1245    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
1246}
1247pub struct Param {
1248    pub(crate) syntax: SyntaxNode,
1249}
1250impl ast::HasAttrs for Param {}
1251impl Param {
1252    #[inline]
1253    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1254    #[inline]
1255    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1256    #[inline]
1257    pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
1258    #[inline]
1259    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1260}
1261pub struct ParamList {
1262    pub(crate) syntax: SyntaxNode,
1263}
1264impl ParamList {
1265    #[inline]
1266    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
1267    #[inline]
1268    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
1269    #[inline]
1270    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1271    #[inline]
1272    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1273    #[inline]
1274    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1275    #[inline]
1276    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
1277}
1278pub struct ParenExpr {
1279    pub(crate) syntax: SyntaxNode,
1280}
1281impl ast::HasAttrs for ParenExpr {}
1282impl ParenExpr {
1283    #[inline]
1284    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1285    #[inline]
1286    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1287    #[inline]
1288    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1289}
1290pub struct ParenPat {
1291    pub(crate) syntax: SyntaxNode,
1292}
1293impl ParenPat {
1294    #[inline]
1295    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1296    #[inline]
1297    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1298    #[inline]
1299    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1300}
1301pub struct ParenType {
1302    pub(crate) syntax: SyntaxNode,
1303}
1304impl ParenType {
1305    #[inline]
1306    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1307    #[inline]
1308    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1309    #[inline]
1310    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1311}
1312pub struct ParenthesizedArgList {
1313    pub(crate) syntax: SyntaxNode,
1314}
1315impl ParenthesizedArgList {
1316    #[inline]
1317    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
1318    #[inline]
1319    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1320    #[inline]
1321    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1322    #[inline]
1323    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
1324}
1325pub struct Path {
1326    pub(crate) syntax: SyntaxNode,
1327}
1328impl Path {
1329    #[inline]
1330    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
1331    #[inline]
1332    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
1333    #[inline]
1334    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
1335}
1336pub struct PathExpr {
1337    pub(crate) syntax: SyntaxNode,
1338}
1339impl ast::HasAttrs for PathExpr {}
1340impl PathExpr {
1341    #[inline]
1342    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1343}
1344pub struct PathMeta {
1345    pub(crate) syntax: SyntaxNode,
1346}
1347impl PathMeta {
1348    #[inline]
1349    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1350}
1351pub struct PathPat {
1352    pub(crate) syntax: SyntaxNode,
1353}
1354impl PathPat {
1355    #[inline]
1356    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1357}
1358pub struct PathSegment {
1359    pub(crate) syntax: SyntaxNode,
1360}
1361impl ast::HasGenericArgs for PathSegment {}
1362impl PathSegment {
1363    #[inline]
1364    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1365    #[inline]
1366    pub fn parenthesized_arg_list(&self) -> Option<ParenthesizedArgList> {
1367        support::child(&self.syntax)
1368    }
1369    #[inline]
1370    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
1371    #[inline]
1372    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }
1373    #[inline]
1374    pub fn type_anchor(&self) -> Option<TypeAnchor> { support::child(&self.syntax) }
1375    #[inline]
1376    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
1377}
1378pub struct PathType {
1379    pub(crate) syntax: SyntaxNode,
1380}
1381impl PathType {
1382    #[inline]
1383    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1384}
1385pub struct PatternType {
1386    pub(crate) syntax: SyntaxNode,
1387}
1388impl PatternType {
1389    #[inline]
1390    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1391    #[inline]
1392    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1393    #[inline]
1394    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
1395    #[inline]
1396    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1397    #[inline]
1398    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1399    #[inline]
1400    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
1401    #[inline]
1402    pub fn is_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![is]) }
1403    #[inline]
1404    pub fn pattern_type_token(&self) -> Option<SyntaxToken> {
1405        support::token(&self.syntax, T![pattern_type])
1406    }
1407}
1408pub struct PrefixExpr {
1409    pub(crate) syntax: SyntaxNode,
1410}
1411impl ast::HasAttrs for PrefixExpr {}
1412impl PrefixExpr {
1413    #[inline]
1414    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1415}
1416pub struct PtrType {
1417    pub(crate) syntax: SyntaxNode,
1418}
1419impl PtrType {
1420    #[inline]
1421    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1422    #[inline]
1423    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
1424    #[inline]
1425    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1426    #[inline]
1427    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1428}
1429pub struct RangeExpr {
1430    pub(crate) syntax: SyntaxNode,
1431}
1432impl ast::HasAttrs for RangeExpr {}
1433impl RangeExpr {}
1434pub struct RangePat {
1435    pub(crate) syntax: SyntaxNode,
1436}
1437impl RangePat {}
1438pub struct RecordExpr {
1439    pub(crate) syntax: SyntaxNode,
1440}
1441impl RecordExpr {
1442    #[inline]
1443    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1444    #[inline]
1445    pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
1446        support::child(&self.syntax)
1447    }
1448}
1449pub struct RecordExprField {
1450    pub(crate) syntax: SyntaxNode,
1451}
1452impl ast::HasAttrs for RecordExprField {}
1453impl RecordExprField {
1454    #[inline]
1455    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1456    #[inline]
1457    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1458    #[inline]
1459    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1460}
1461pub struct RecordExprFieldList {
1462    pub(crate) syntax: SyntaxNode,
1463}
1464impl ast::HasAttrs for RecordExprFieldList {}
1465impl RecordExprFieldList {
1466    #[inline]
1467    pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
1468    #[inline]
1469    pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
1470    #[inline]
1471    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1472    #[inline]
1473    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1474    #[inline]
1475    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1476}
1477pub struct RecordField {
1478    pub(crate) syntax: SyntaxNode,
1479}
1480impl ast::HasAttrs for RecordField {}
1481impl ast::HasDocComments for RecordField {}
1482impl ast::HasName for RecordField {}
1483impl ast::HasVisibility for RecordField {}
1484impl RecordField {
1485    #[inline]
1486    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }
1487    #[inline]
1488    pub fn mut_restriction(&self) -> Option<MutRestriction> { support::child(&self.syntax) }
1489    #[inline]
1490    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1491    #[inline]
1492    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1493    #[inline]
1494    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1495    #[inline]
1496    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1497}
1498pub struct RecordFieldList {
1499    pub(crate) syntax: SyntaxNode,
1500}
1501impl RecordFieldList {
1502    #[inline]
1503    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
1504    #[inline]
1505    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1506    #[inline]
1507    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1508}
1509pub struct RecordPat {
1510    pub(crate) syntax: SyntaxNode,
1511}
1512impl RecordPat {
1513    #[inline]
1514    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1515    #[inline]
1516    pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
1517        support::child(&self.syntax)
1518    }
1519}
1520pub struct RecordPatField {
1521    pub(crate) syntax: SyntaxNode,
1522}
1523impl ast::HasAttrs for RecordPatField {}
1524impl RecordPatField {
1525    #[inline]
1526    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1527    #[inline]
1528    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1529    #[inline]
1530    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1531}
1532pub struct RecordPatFieldList {
1533    pub(crate) syntax: SyntaxNode,
1534}
1535impl RecordPatFieldList {
1536    #[inline]
1537    pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
1538    #[inline]
1539    pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) }
1540    #[inline]
1541    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1542    #[inline]
1543    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1544}
1545pub struct RefExpr {
1546    pub(crate) syntax: SyntaxNode,
1547}
1548impl ast::HasAttrs for RefExpr {}
1549impl RefExpr {
1550    #[inline]
1551    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1552    #[inline]
1553    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1554    #[inline]
1555    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1556    #[inline]
1557    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1558    #[inline]
1559    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
1560}
1561pub struct RefPat {
1562    pub(crate) syntax: SyntaxNode,
1563}
1564impl RefPat {
1565    #[inline]
1566    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1567    #[inline]
1568    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1569    #[inline]
1570    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1571}
1572pub struct RefType {
1573    pub(crate) syntax: SyntaxNode,
1574}
1575impl RefType {
1576    #[inline]
1577    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1578    #[inline]
1579    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1580    #[inline]
1581    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1582    #[inline]
1583    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1584}
1585pub struct Rename {
1586    pub(crate) syntax: SyntaxNode,
1587}
1588impl ast::HasName for Rename {}
1589impl Rename {
1590    #[inline]
1591    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1592    #[inline]
1593    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
1594}
1595pub struct RestPat {
1596    pub(crate) syntax: SyntaxNode,
1597}
1598impl ast::HasAttrs for RestPat {}
1599impl RestPat {
1600    #[inline]
1601    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1602}
1603pub struct RetType {
1604    pub(crate) syntax: SyntaxNode,
1605}
1606impl RetType {
1607    #[inline]
1608    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1609    #[inline]
1610    pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
1611}
1612pub struct ReturnExpr {
1613    pub(crate) syntax: SyntaxNode,
1614}
1615impl ast::HasAttrs for ReturnExpr {}
1616impl ReturnExpr {
1617    #[inline]
1618    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1619    #[inline]
1620    pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
1621}
1622pub struct ReturnTypeSyntax {
1623    pub(crate) syntax: SyntaxNode,
1624}
1625impl ReturnTypeSyntax {
1626    #[inline]
1627    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1628    #[inline]
1629    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1630    #[inline]
1631    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1632}
1633pub struct SelfParam {
1634    pub(crate) syntax: SyntaxNode,
1635}
1636impl ast::HasAttrs for SelfParam {}
1637impl ast::HasName for SelfParam {}
1638impl SelfParam {
1639    #[inline]
1640    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1641    #[inline]
1642    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1643    #[inline]
1644    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1645    #[inline]
1646    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1647    #[inline]
1648    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1649}
1650pub struct SlicePat {
1651    pub(crate) syntax: SyntaxNode,
1652}
1653impl SlicePat {
1654    #[inline]
1655    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1656    #[inline]
1657    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1658    #[inline]
1659    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1660}
1661pub struct SliceType {
1662    pub(crate) syntax: SyntaxNode,
1663}
1664impl SliceType {
1665    #[inline]
1666    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1667    #[inline]
1668    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1669    #[inline]
1670    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1671}
1672pub struct SourceFile {
1673    pub(crate) syntax: SyntaxNode,
1674}
1675impl ast::HasAttrs for SourceFile {}
1676impl ast::HasDocComments for SourceFile {}
1677impl ast::HasModuleItem for SourceFile {}
1678impl SourceFile {
1679    #[inline]
1680    pub fn frontmatter_token(&self) -> Option<SyntaxToken> {
1681        support::token(&self.syntax, T![frontmatter])
1682    }
1683    #[inline]
1684    pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
1685}
1686pub struct Static {
1687    pub(crate) syntax: SyntaxNode,
1688}
1689impl ast::HasAttrs for Static {}
1690impl ast::HasDocComments for Static {}
1691impl ast::HasName for Static {}
1692impl ast::HasVisibility for Static {}
1693impl Static {
1694    #[inline]
1695    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1696    #[inline]
1697    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1698    #[inline]
1699    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1700    #[inline]
1701    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1702    #[inline]
1703    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1704    #[inline]
1705    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }
1706    #[inline]
1707    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
1708    #[inline]
1709    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1710}
1711pub struct StmtList {
1712    pub(crate) syntax: SyntaxNode,
1713}
1714impl ast::HasAttrs for StmtList {}
1715impl StmtList {
1716    #[inline]
1717    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
1718    #[inline]
1719    pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1720    #[inline]
1721    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1722    #[inline]
1723    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1724}
1725pub struct Struct {
1726    pub(crate) syntax: SyntaxNode,
1727}
1728impl ast::HasAttrs for Struct {}
1729impl ast::HasDocComments for Struct {}
1730impl ast::HasGenericParams for Struct {}
1731impl ast::HasName for Struct {}
1732impl ast::HasVisibility for Struct {}
1733impl Struct {
1734    #[inline]
1735    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
1736    #[inline]
1737    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1738    #[inline]
1739    pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
1740}
1741pub struct TokenTree {
1742    pub(crate) syntax: SyntaxNode,
1743}
1744impl TokenTree {
1745    #[inline]
1746    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1747    #[inline]
1748    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1749    #[inline]
1750    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1751    #[inline]
1752    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1753    #[inline]
1754    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1755    #[inline]
1756    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1757}
1758pub struct TokenTreeMeta {
1759    pub(crate) syntax: SyntaxNode,
1760}
1761impl TokenTreeMeta {
1762    #[inline]
1763    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1764    #[inline]
1765    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1766}
1767pub struct Trait {
1768    pub(crate) syntax: SyntaxNode,
1769}
1770impl ast::HasAttrs for Trait {}
1771impl ast::HasDocComments for Trait {}
1772impl ast::HasGenericParams for Trait {}
1773impl ast::HasName for Trait {}
1774impl ast::HasTypeBounds for Trait {}
1775impl ast::HasVisibility for Trait {}
1776impl Trait {
1777    #[inline]
1778    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
1779    #[inline]
1780    pub fn impl_restriction(&self) -> Option<ImplRestriction> { support::child(&self.syntax) }
1781    #[inline]
1782    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1783    #[inline]
1784    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1785    #[inline]
1786    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
1787    #[inline]
1788    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
1789    #[inline]
1790    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1791}
1792pub struct TryBlockModifier {
1793    pub(crate) syntax: SyntaxNode,
1794}
1795impl TryBlockModifier {
1796    #[inline]
1797    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1798    #[inline]
1799    pub fn bikeshed_token(&self) -> Option<SyntaxToken> {
1800        support::token(&self.syntax, T![bikeshed])
1801    }
1802    #[inline]
1803    pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
1804}
1805pub struct TryExpr {
1806    pub(crate) syntax: SyntaxNode,
1807}
1808impl ast::HasAttrs for TryExpr {}
1809impl TryExpr {
1810    #[inline]
1811    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1812    #[inline]
1813    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1814}
1815pub struct TupleExpr {
1816    pub(crate) syntax: SyntaxNode,
1817}
1818impl ast::HasAttrs for TupleExpr {}
1819impl TupleExpr {
1820    #[inline]
1821    pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
1822    #[inline]
1823    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1824    #[inline]
1825    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1826}
1827pub struct TupleField {
1828    pub(crate) syntax: SyntaxNode,
1829}
1830impl ast::HasAttrs for TupleField {}
1831impl ast::HasDocComments for TupleField {}
1832impl ast::HasVisibility for TupleField {}
1833impl TupleField {
1834    #[inline]
1835    pub fn mut_restriction(&self) -> Option<MutRestriction> { support::child(&self.syntax) }
1836    #[inline]
1837    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1838}
1839pub struct TupleFieldList {
1840    pub(crate) syntax: SyntaxNode,
1841}
1842impl TupleFieldList {
1843    #[inline]
1844    pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
1845    #[inline]
1846    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1847    #[inline]
1848    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1849}
1850pub struct TuplePat {
1851    pub(crate) syntax: SyntaxNode,
1852}
1853impl TuplePat {
1854    #[inline]
1855    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1856    #[inline]
1857    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1858    #[inline]
1859    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1860}
1861pub struct TupleStructPat {
1862    pub(crate) syntax: SyntaxNode,
1863}
1864impl TupleStructPat {
1865    #[inline]
1866    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1867    #[inline]
1868    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1869    #[inline]
1870    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1871    #[inline]
1872    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1873}
1874pub struct TupleType {
1875    pub(crate) syntax: SyntaxNode,
1876}
1877impl TupleType {
1878    #[inline]
1879    pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
1880    #[inline]
1881    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1882    #[inline]
1883    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1884}
1885pub struct TypeAlias {
1886    pub(crate) syntax: SyntaxNode,
1887}
1888impl ast::HasAttrs for TypeAlias {}
1889impl ast::HasDocComments for TypeAlias {}
1890impl ast::HasGenericParams for TypeAlias {}
1891impl ast::HasName for TypeAlias {}
1892impl ast::HasTypeBounds for TypeAlias {}
1893impl ast::HasVisibility for TypeAlias {}
1894impl TypeAlias {
1895    #[inline]
1896    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1897    #[inline]
1898    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1899    #[inline]
1900    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1901    #[inline]
1902    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
1903    #[inline]
1904    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
1905}
1906pub struct TypeAnchor {
1907    pub(crate) syntax: SyntaxNode,
1908}
1909impl TypeAnchor {
1910    #[inline]
1911    pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
1912    #[inline]
1913    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1914    #[inline]
1915    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
1916    #[inline]
1917    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
1918    #[inline]
1919    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
1920}
1921pub struct TypeArg {
1922    pub(crate) syntax: SyntaxNode,
1923}
1924impl TypeArg {
1925    #[inline]
1926    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1927}
1928pub struct TypeBound {
1929    pub(crate) syntax: SyntaxNode,
1930}
1931impl TypeBound {
1932    #[inline]
1933    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
1934    #[inline]
1935    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
1936    #[inline]
1937    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1938    #[inline]
1939    pub fn use_bound_generic_args(&self) -> Option<UseBoundGenericArgs> {
1940        support::child(&self.syntax)
1941    }
1942    #[inline]
1943    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1944    #[inline]
1945    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1946    #[inline]
1947    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1948    #[inline]
1949    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
1950    #[inline]
1951    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1952    #[inline]
1953    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
1954    #[inline]
1955    pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }
1956}
1957pub struct TypeBoundList {
1958    pub(crate) syntax: SyntaxNode,
1959}
1960impl TypeBoundList {
1961    #[inline]
1962    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
1963}
1964pub struct TypeParam {
1965    pub(crate) syntax: SyntaxNode,
1966}
1967impl ast::HasAttrs for TypeParam {}
1968impl ast::HasName for TypeParam {}
1969impl ast::HasTypeBounds for TypeParam {}
1970impl TypeParam {
1971    #[inline]
1972    pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
1973    #[inline]
1974    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1975}
1976pub struct UnderscoreExpr {
1977    pub(crate) syntax: SyntaxNode,
1978}
1979impl ast::HasAttrs for UnderscoreExpr {}
1980impl UnderscoreExpr {
1981    #[inline]
1982    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1983}
1984pub struct Union {
1985    pub(crate) syntax: SyntaxNode,
1986}
1987impl ast::HasAttrs for Union {}
1988impl ast::HasDocComments for Union {}
1989impl ast::HasGenericParams for Union {}
1990impl ast::HasName for Union {}
1991impl ast::HasVisibility for Union {}
1992impl Union {
1993    #[inline]
1994    pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
1995    #[inline]
1996    pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
1997}
1998pub struct UnsafeMeta {
1999    pub(crate) syntax: SyntaxNode,
2000}
2001impl UnsafeMeta {
2002    #[inline]
2003    pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) }
2004    #[inline]
2005    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
2006    #[inline]
2007    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
2008    #[inline]
2009    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
2010}
2011pub struct Use {
2012    pub(crate) syntax: SyntaxNode,
2013}
2014impl ast::HasAttrs for Use {}
2015impl ast::HasDocComments for Use {}
2016impl ast::HasVisibility for Use {}
2017impl Use {
2018    #[inline]
2019    pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
2020    #[inline]
2021    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
2022    #[inline]
2023    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
2024}
2025pub struct UseBoundGenericArgs {
2026    pub(crate) syntax: SyntaxNode,
2027}
2028impl UseBoundGenericArgs {
2029    #[inline]
2030    pub fn use_bound_generic_args(&self) -> AstChildren<UseBoundGenericArg> {
2031        support::children(&self.syntax)
2032    }
2033    #[inline]
2034    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
2035    #[inline]
2036    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
2037}
2038pub struct UseTree {
2039    pub(crate) syntax: SyntaxNode,
2040}
2041impl UseTree {
2042    #[inline]
2043    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
2044    #[inline]
2045    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
2046    #[inline]
2047    pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
2048    #[inline]
2049    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
2050    #[inline]
2051    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
2052}
2053pub struct UseTreeList {
2054    pub(crate) syntax: SyntaxNode,
2055}
2056impl UseTreeList {
2057    #[inline]
2058    pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
2059    #[inline]
2060    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
2061    #[inline]
2062    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
2063}
2064pub struct Variant {
2065    pub(crate) syntax: SyntaxNode,
2066}
2067impl ast::HasAttrs for Variant {}
2068impl ast::HasDocComments for Variant {}
2069impl ast::HasName for Variant {}
2070impl ast::HasVisibility for Variant {}
2071impl Variant {
2072    #[inline]
2073    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
2074    #[inline]
2075    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
2076    #[inline]
2077    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2078    #[inline]
2079    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
2080}
2081pub struct VariantList {
2082    pub(crate) syntax: SyntaxNode,
2083}
2084impl VariantList {
2085    #[inline]
2086    pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
2087    #[inline]
2088    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
2089    #[inline]
2090    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
2091}
2092pub struct Visibility {
2093    pub(crate) syntax: SyntaxNode,
2094}
2095impl Visibility {
2096    #[inline]
2097    pub fn visibility_inner(&self) -> Option<VisibilityInner> { support::child(&self.syntax) }
2098    #[inline]
2099    pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
2100}
2101pub struct VisibilityInner {
2102    pub(crate) syntax: SyntaxNode,
2103}
2104impl VisibilityInner {
2105    #[inline]
2106    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
2107    #[inline]
2108    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
2109    #[inline]
2110    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
2111    #[inline]
2112    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
2113}
2114pub struct WhereClause {
2115    pub(crate) syntax: SyntaxNode,
2116}
2117impl WhereClause {
2118    #[inline]
2119    pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
2120    #[inline]
2121    pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
2122}
2123pub struct WherePred {
2124    pub(crate) syntax: SyntaxNode,
2125}
2126impl ast::HasTypeBounds for WherePred {}
2127impl WherePred {
2128    #[inline]
2129    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }
2130    #[inline]
2131    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
2132    #[inline]
2133    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
2134}
2135pub struct WhileExpr {
2136    pub(crate) syntax: SyntaxNode,
2137}
2138impl ast::HasAttrs for WhileExpr {}
2139impl WhileExpr {
2140    #[inline]
2141    pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
2142}
2143pub struct WildcardPat {
2144    pub(crate) syntax: SyntaxNode,
2145}
2146impl WildcardPat {
2147    #[inline]
2148    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
2149}
2150pub struct YeetExpr {
2151    pub(crate) syntax: SyntaxNode,
2152}
2153impl ast::HasAttrs for YeetExpr {}
2154impl YeetExpr {
2155    #[inline]
2156    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2157    #[inline]
2158    pub fn do_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![do]) }
2159    #[inline]
2160    pub fn yeet_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yeet]) }
2161}
2162pub struct YieldExpr {
2163    pub(crate) syntax: SyntaxNode,
2164}
2165impl ast::HasAttrs for YieldExpr {}
2166impl YieldExpr {
2167    #[inline]
2168    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2169    #[inline]
2170    pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) }
2171}
2172
2173#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2174pub enum Adt {
2175    Enum(Enum),
2176    Struct(Struct),
2177    Union(Union),
2178}
2179impl ast::HasAttrs for Adt {}
2180impl ast::HasDocComments for Adt {}
2181impl ast::HasGenericParams for Adt {}
2182impl ast::HasName for Adt {}
2183impl ast::HasVisibility for Adt {}
2184
2185#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2186pub enum AsmOperand {
2187    AsmConst(AsmConst),
2188    AsmLabel(AsmLabel),
2189    AsmRegOperand(AsmRegOperand),
2190    AsmSym(AsmSym),
2191}
2192
2193#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2194pub enum AsmPiece {
2195    AsmClobberAbi(AsmClobberAbi),
2196    AsmOperandNamed(AsmOperandNamed),
2197    AsmOptions(AsmOptions),
2198}
2199impl ast::HasAttrs for AsmPiece {}
2200
2201#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2202pub enum AssocItem {
2203    Const(Const),
2204    Fn(Fn),
2205    MacroCall(MacroCall),
2206    TypeAlias(TypeAlias),
2207}
2208impl ast::HasAttrs for AssocItem {}
2209impl ast::HasDocComments for AssocItem {}
2210
2211#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2212pub enum CfgPredicate {
2213    CfgAtom(CfgAtom),
2214    CfgComposite(CfgComposite),
2215}
2216
2217#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2218pub enum Expr {
2219    ArrayExpr(ArrayExpr),
2220    AsmExpr(AsmExpr),
2221    AwaitExpr(AwaitExpr),
2222    BecomeExpr(BecomeExpr),
2223    BinExpr(BinExpr),
2224    BlockExpr(BlockExpr),
2225    BreakExpr(BreakExpr),
2226    CallExpr(CallExpr),
2227    CastExpr(CastExpr),
2228    ClosureExpr(ClosureExpr),
2229    ContinueExpr(ContinueExpr),
2230    FieldExpr(FieldExpr),
2231    ForExpr(ForExpr),
2232    FormatArgsExpr(FormatArgsExpr),
2233    IfExpr(IfExpr),
2234    IncludeBytesExpr(IncludeBytesExpr),
2235    IndexExpr(IndexExpr),
2236    LetExpr(LetExpr),
2237    Literal(Literal),
2238    LoopExpr(LoopExpr),
2239    MacroExpr(MacroExpr),
2240    MatchExpr(MatchExpr),
2241    MethodCallExpr(MethodCallExpr),
2242    OffsetOfExpr(OffsetOfExpr),
2243    ParenExpr(ParenExpr),
2244    PathExpr(PathExpr),
2245    PrefixExpr(PrefixExpr),
2246    RangeExpr(RangeExpr),
2247    RecordExpr(RecordExpr),
2248    RefExpr(RefExpr),
2249    ReturnExpr(ReturnExpr),
2250    TryExpr(TryExpr),
2251    TupleExpr(TupleExpr),
2252    UnderscoreExpr(UnderscoreExpr),
2253    WhileExpr(WhileExpr),
2254    YeetExpr(YeetExpr),
2255    YieldExpr(YieldExpr),
2256}
2257
2258#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2259pub enum ExternItem {
2260    Fn(Fn),
2261    MacroCall(MacroCall),
2262    Static(Static),
2263    TypeAlias(TypeAlias),
2264}
2265impl ast::HasAttrs for ExternItem {}
2266impl ast::HasDocComments for ExternItem {}
2267
2268#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2269pub enum FieldList {
2270    RecordFieldList(RecordFieldList),
2271    TupleFieldList(TupleFieldList),
2272}
2273
2274#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2275pub enum GenericArg {
2276    AssocTypeArg(AssocTypeArg),
2277    ConstArg(ConstArg),
2278    LifetimeArg(LifetimeArg),
2279    TypeArg(TypeArg),
2280}
2281
2282#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2283pub enum GenericParam {
2284    ConstParam(ConstParam),
2285    LifetimeParam(LifetimeParam),
2286    TypeParam(TypeParam),
2287}
2288impl ast::HasAttrs for GenericParam {}
2289
2290#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2291pub enum Item {
2292    AsmExpr(AsmExpr),
2293    Const(Const),
2294    Enum(Enum),
2295    ExternBlock(ExternBlock),
2296    ExternCrate(ExternCrate),
2297    Fn(Fn),
2298    Impl(Impl),
2299    MacroCall(MacroCall),
2300    MacroDef(MacroDef),
2301    MacroRules(MacroRules),
2302    Module(Module),
2303    Static(Static),
2304    Struct(Struct),
2305    Trait(Trait),
2306    TypeAlias(TypeAlias),
2307    Union(Union),
2308    Use(Use),
2309}
2310impl ast::HasAttrs for Item {}
2311
2312#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2313pub enum Meta {
2314    CfgAttrMeta(CfgAttrMeta),
2315    CfgMeta(CfgMeta),
2316    KeyValueMeta(KeyValueMeta),
2317    PathMeta(PathMeta),
2318    TokenTreeMeta(TokenTreeMeta),
2319    UnsafeMeta(UnsafeMeta),
2320}
2321
2322#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2323pub enum Pat {
2324    BoxPat(BoxPat),
2325    ConstBlockPat(ConstBlockPat),
2326    DerefPat(DerefPat),
2327    IdentPat(IdentPat),
2328    LiteralPat(LiteralPat),
2329    MacroPat(MacroPat),
2330    NotNull(NotNull),
2331    OrPat(OrPat),
2332    ParenPat(ParenPat),
2333    PathPat(PathPat),
2334    RangePat(RangePat),
2335    RecordPat(RecordPat),
2336    RefPat(RefPat),
2337    RestPat(RestPat),
2338    SlicePat(SlicePat),
2339    TuplePat(TuplePat),
2340    TupleStructPat(TupleStructPat),
2341    WildcardPat(WildcardPat),
2342}
2343
2344#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2345pub enum Stmt {
2346    ExprStmt(ExprStmt),
2347    Item(Item),
2348    LetStmt(LetStmt),
2349}
2350
2351#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2352pub enum Type {
2353    ArrayType(ArrayType),
2354    DynTraitType(DynTraitType),
2355    FnPtrType(FnPtrType),
2356    ForType(ForType),
2357    ImplTraitType(ImplTraitType),
2358    InferType(InferType),
2359    MacroType(MacroType),
2360    NeverType(NeverType),
2361    ParenType(ParenType),
2362    PathType(PathType),
2363    PatternType(PatternType),
2364    PtrType(PtrType),
2365    RefType(RefType),
2366    SliceType(SliceType),
2367    TupleType(TupleType),
2368}
2369
2370#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2371pub enum UseBoundGenericArg {
2372    Lifetime(Lifetime),
2373    NameRef(NameRef),
2374}
2375
2376#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2377pub enum VariantDef {
2378    Struct(Struct),
2379    Union(Union),
2380    Variant(Variant),
2381}
2382impl ast::HasAttrs for VariantDef {}
2383impl ast::HasDocComments for VariantDef {}
2384impl ast::HasName for VariantDef {}
2385impl ast::HasVisibility for VariantDef {}
2386pub struct AnyHasArgList {
2387    pub(crate) syntax: SyntaxNode,
2388}
2389impl AnyHasArgList {
2390    #[inline]
2391    pub fn new<T: ast::HasArgList>(node: T) -> AnyHasArgList {
2392        AnyHasArgList { syntax: node.syntax().clone() }
2393    }
2394}
2395pub struct AnyHasAttrs {
2396    pub(crate) syntax: SyntaxNode,
2397}
2398impl AnyHasAttrs {
2399    #[inline]
2400    pub fn new<T: ast::HasAttrs>(node: T) -> AnyHasAttrs {
2401        AnyHasAttrs { syntax: node.syntax().clone() }
2402    }
2403}
2404pub struct AnyHasDocComments {
2405    pub(crate) syntax: SyntaxNode,
2406}
2407impl AnyHasDocComments {
2408    #[inline]
2409    pub fn new<T: ast::HasDocComments>(node: T) -> AnyHasDocComments {
2410        AnyHasDocComments { syntax: node.syntax().clone() }
2411    }
2412}
2413pub struct AnyHasGenericArgs {
2414    pub(crate) syntax: SyntaxNode,
2415}
2416impl AnyHasGenericArgs {
2417    #[inline]
2418    pub fn new<T: ast::HasGenericArgs>(node: T) -> AnyHasGenericArgs {
2419        AnyHasGenericArgs { syntax: node.syntax().clone() }
2420    }
2421}
2422pub struct AnyHasGenericParams {
2423    pub(crate) syntax: SyntaxNode,
2424}
2425impl AnyHasGenericParams {
2426    #[inline]
2427    pub fn new<T: ast::HasGenericParams>(node: T) -> AnyHasGenericParams {
2428        AnyHasGenericParams { syntax: node.syntax().clone() }
2429    }
2430}
2431pub struct AnyHasLoopBody {
2432    pub(crate) syntax: SyntaxNode,
2433}
2434impl AnyHasLoopBody {
2435    #[inline]
2436    pub fn new<T: ast::HasLoopBody>(node: T) -> AnyHasLoopBody {
2437        AnyHasLoopBody { syntax: node.syntax().clone() }
2438    }
2439}
2440pub struct AnyHasModuleItem {
2441    pub(crate) syntax: SyntaxNode,
2442}
2443impl AnyHasModuleItem {
2444    #[inline]
2445    pub fn new<T: ast::HasModuleItem>(node: T) -> AnyHasModuleItem {
2446        AnyHasModuleItem { syntax: node.syntax().clone() }
2447    }
2448}
2449pub struct AnyHasName {
2450    pub(crate) syntax: SyntaxNode,
2451}
2452impl AnyHasName {
2453    #[inline]
2454    pub fn new<T: ast::HasName>(node: T) -> AnyHasName {
2455        AnyHasName { syntax: node.syntax().clone() }
2456    }
2457}
2458pub struct AnyHasTypeBounds {
2459    pub(crate) syntax: SyntaxNode,
2460}
2461impl AnyHasTypeBounds {
2462    #[inline]
2463    pub fn new<T: ast::HasTypeBounds>(node: T) -> AnyHasTypeBounds {
2464        AnyHasTypeBounds { syntax: node.syntax().clone() }
2465    }
2466}
2467pub struct AnyHasVisibility {
2468    pub(crate) syntax: SyntaxNode,
2469}
2470impl AnyHasVisibility {
2471    #[inline]
2472    pub fn new<T: ast::HasVisibility>(node: T) -> AnyHasVisibility {
2473        AnyHasVisibility { syntax: node.syntax().clone() }
2474    }
2475}
2476impl AstNode for Abi {
2477    #[inline]
2478    fn kind() -> SyntaxKind
2479    where
2480        Self: Sized,
2481    {
2482        ABI
2483    }
2484    #[inline]
2485    fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
2486    #[inline]
2487    fn cast(syntax: SyntaxNode) -> Option<Self> {
2488        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2489    }
2490    #[inline]
2491    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2492}
2493impl hash::Hash for Abi {
2494    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2495}
2496impl Eq for Abi {}
2497impl PartialEq for Abi {
2498    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2499}
2500impl Clone for Abi {
2501    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2502}
2503impl fmt::Debug for Abi {
2504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2505        f.debug_struct("Abi").field("syntax", &self.syntax).finish()
2506    }
2507}
2508impl AstNode for ArgList {
2509    #[inline]
2510    fn kind() -> SyntaxKind
2511    where
2512        Self: Sized,
2513    {
2514        ARG_LIST
2515    }
2516    #[inline]
2517    fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
2518    #[inline]
2519    fn cast(syntax: SyntaxNode) -> Option<Self> {
2520        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2521    }
2522    #[inline]
2523    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2524}
2525impl hash::Hash for ArgList {
2526    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2527}
2528impl Eq for ArgList {}
2529impl PartialEq for ArgList {
2530    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2531}
2532impl Clone for ArgList {
2533    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2534}
2535impl fmt::Debug for ArgList {
2536    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2537        f.debug_struct("ArgList").field("syntax", &self.syntax).finish()
2538    }
2539}
2540impl AstNode for ArrayExpr {
2541    #[inline]
2542    fn kind() -> SyntaxKind
2543    where
2544        Self: Sized,
2545    {
2546        ARRAY_EXPR
2547    }
2548    #[inline]
2549    fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
2550    #[inline]
2551    fn cast(syntax: SyntaxNode) -> Option<Self> {
2552        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2553    }
2554    #[inline]
2555    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2556}
2557impl hash::Hash for ArrayExpr {
2558    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2559}
2560impl Eq for ArrayExpr {}
2561impl PartialEq for ArrayExpr {
2562    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2563}
2564impl Clone for ArrayExpr {
2565    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2566}
2567impl fmt::Debug for ArrayExpr {
2568    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2569        f.debug_struct("ArrayExpr").field("syntax", &self.syntax).finish()
2570    }
2571}
2572impl AstNode for ArrayType {
2573    #[inline]
2574    fn kind() -> SyntaxKind
2575    where
2576        Self: Sized,
2577    {
2578        ARRAY_TYPE
2579    }
2580    #[inline]
2581    fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
2582    #[inline]
2583    fn cast(syntax: SyntaxNode) -> Option<Self> {
2584        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2585    }
2586    #[inline]
2587    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2588}
2589impl hash::Hash for ArrayType {
2590    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2591}
2592impl Eq for ArrayType {}
2593impl PartialEq for ArrayType {
2594    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2595}
2596impl Clone for ArrayType {
2597    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2598}
2599impl fmt::Debug for ArrayType {
2600    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2601        f.debug_struct("ArrayType").field("syntax", &self.syntax).finish()
2602    }
2603}
2604impl AstNode for AsmClobberAbi {
2605    #[inline]
2606    fn kind() -> SyntaxKind
2607    where
2608        Self: Sized,
2609    {
2610        ASM_CLOBBER_ABI
2611    }
2612    #[inline]
2613    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CLOBBER_ABI }
2614    #[inline]
2615    fn cast(syntax: SyntaxNode) -> Option<Self> {
2616        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2617    }
2618    #[inline]
2619    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2620}
2621impl hash::Hash for AsmClobberAbi {
2622    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2623}
2624impl Eq for AsmClobberAbi {}
2625impl PartialEq for AsmClobberAbi {
2626    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2627}
2628impl Clone for AsmClobberAbi {
2629    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2630}
2631impl fmt::Debug for AsmClobberAbi {
2632    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2633        f.debug_struct("AsmClobberAbi").field("syntax", &self.syntax).finish()
2634    }
2635}
2636impl AstNode for AsmConst {
2637    #[inline]
2638    fn kind() -> SyntaxKind
2639    where
2640        Self: Sized,
2641    {
2642        ASM_CONST
2643    }
2644    #[inline]
2645    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CONST }
2646    #[inline]
2647    fn cast(syntax: SyntaxNode) -> Option<Self> {
2648        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2649    }
2650    #[inline]
2651    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2652}
2653impl hash::Hash for AsmConst {
2654    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2655}
2656impl Eq for AsmConst {}
2657impl PartialEq for AsmConst {
2658    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2659}
2660impl Clone for AsmConst {
2661    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2662}
2663impl fmt::Debug for AsmConst {
2664    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2665        f.debug_struct("AsmConst").field("syntax", &self.syntax).finish()
2666    }
2667}
2668impl AstNode for AsmDirSpec {
2669    #[inline]
2670    fn kind() -> SyntaxKind
2671    where
2672        Self: Sized,
2673    {
2674        ASM_DIR_SPEC
2675    }
2676    #[inline]
2677    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_DIR_SPEC }
2678    #[inline]
2679    fn cast(syntax: SyntaxNode) -> Option<Self> {
2680        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2681    }
2682    #[inline]
2683    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2684}
2685impl hash::Hash for AsmDirSpec {
2686    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2687}
2688impl Eq for AsmDirSpec {}
2689impl PartialEq for AsmDirSpec {
2690    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2691}
2692impl Clone for AsmDirSpec {
2693    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2694}
2695impl fmt::Debug for AsmDirSpec {
2696    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2697        f.debug_struct("AsmDirSpec").field("syntax", &self.syntax).finish()
2698    }
2699}
2700impl AstNode for AsmExpr {
2701    #[inline]
2702    fn kind() -> SyntaxKind
2703    where
2704        Self: Sized,
2705    {
2706        ASM_EXPR
2707    }
2708    #[inline]
2709    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_EXPR }
2710    #[inline]
2711    fn cast(syntax: SyntaxNode) -> Option<Self> {
2712        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2713    }
2714    #[inline]
2715    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2716}
2717impl hash::Hash for AsmExpr {
2718    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2719}
2720impl Eq for AsmExpr {}
2721impl PartialEq for AsmExpr {
2722    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2723}
2724impl Clone for AsmExpr {
2725    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2726}
2727impl fmt::Debug for AsmExpr {
2728    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2729        f.debug_struct("AsmExpr").field("syntax", &self.syntax).finish()
2730    }
2731}
2732impl AstNode for AsmLabel {
2733    #[inline]
2734    fn kind() -> SyntaxKind
2735    where
2736        Self: Sized,
2737    {
2738        ASM_LABEL
2739    }
2740    #[inline]
2741    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_LABEL }
2742    #[inline]
2743    fn cast(syntax: SyntaxNode) -> Option<Self> {
2744        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2745    }
2746    #[inline]
2747    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2748}
2749impl hash::Hash for AsmLabel {
2750    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2751}
2752impl Eq for AsmLabel {}
2753impl PartialEq for AsmLabel {
2754    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2755}
2756impl Clone for AsmLabel {
2757    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2758}
2759impl fmt::Debug for AsmLabel {
2760    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2761        f.debug_struct("AsmLabel").field("syntax", &self.syntax).finish()
2762    }
2763}
2764impl AstNode for AsmOperandExpr {
2765    #[inline]
2766    fn kind() -> SyntaxKind
2767    where
2768        Self: Sized,
2769    {
2770        ASM_OPERAND_EXPR
2771    }
2772    #[inline]
2773    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_EXPR }
2774    #[inline]
2775    fn cast(syntax: SyntaxNode) -> Option<Self> {
2776        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2777    }
2778    #[inline]
2779    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2780}
2781impl hash::Hash for AsmOperandExpr {
2782    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2783}
2784impl Eq for AsmOperandExpr {}
2785impl PartialEq for AsmOperandExpr {
2786    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2787}
2788impl Clone for AsmOperandExpr {
2789    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2790}
2791impl fmt::Debug for AsmOperandExpr {
2792    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2793        f.debug_struct("AsmOperandExpr").field("syntax", &self.syntax).finish()
2794    }
2795}
2796impl AstNode for AsmOperandNamed {
2797    #[inline]
2798    fn kind() -> SyntaxKind
2799    where
2800        Self: Sized,
2801    {
2802        ASM_OPERAND_NAMED
2803    }
2804    #[inline]
2805    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_NAMED }
2806    #[inline]
2807    fn cast(syntax: SyntaxNode) -> Option<Self> {
2808        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2809    }
2810    #[inline]
2811    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2812}
2813impl hash::Hash for AsmOperandNamed {
2814    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2815}
2816impl Eq for AsmOperandNamed {}
2817impl PartialEq for AsmOperandNamed {
2818    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2819}
2820impl Clone for AsmOperandNamed {
2821    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2822}
2823impl fmt::Debug for AsmOperandNamed {
2824    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2825        f.debug_struct("AsmOperandNamed").field("syntax", &self.syntax).finish()
2826    }
2827}
2828impl AstNode for AsmOption {
2829    #[inline]
2830    fn kind() -> SyntaxKind
2831    where
2832        Self: Sized,
2833    {
2834        ASM_OPTION
2835    }
2836    #[inline]
2837    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTION }
2838    #[inline]
2839    fn cast(syntax: SyntaxNode) -> Option<Self> {
2840        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2841    }
2842    #[inline]
2843    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2844}
2845impl hash::Hash for AsmOption {
2846    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2847}
2848impl Eq for AsmOption {}
2849impl PartialEq for AsmOption {
2850    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2851}
2852impl Clone for AsmOption {
2853    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2854}
2855impl fmt::Debug for AsmOption {
2856    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2857        f.debug_struct("AsmOption").field("syntax", &self.syntax).finish()
2858    }
2859}
2860impl AstNode for AsmOptions {
2861    #[inline]
2862    fn kind() -> SyntaxKind
2863    where
2864        Self: Sized,
2865    {
2866        ASM_OPTIONS
2867    }
2868    #[inline]
2869    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTIONS }
2870    #[inline]
2871    fn cast(syntax: SyntaxNode) -> Option<Self> {
2872        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2873    }
2874    #[inline]
2875    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2876}
2877impl hash::Hash for AsmOptions {
2878    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2879}
2880impl Eq for AsmOptions {}
2881impl PartialEq for AsmOptions {
2882    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2883}
2884impl Clone for AsmOptions {
2885    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2886}
2887impl fmt::Debug for AsmOptions {
2888    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2889        f.debug_struct("AsmOptions").field("syntax", &self.syntax).finish()
2890    }
2891}
2892impl AstNode for AsmRegOperand {
2893    #[inline]
2894    fn kind() -> SyntaxKind
2895    where
2896        Self: Sized,
2897    {
2898        ASM_REG_OPERAND
2899    }
2900    #[inline]
2901    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_OPERAND }
2902    #[inline]
2903    fn cast(syntax: SyntaxNode) -> Option<Self> {
2904        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2905    }
2906    #[inline]
2907    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2908}
2909impl hash::Hash for AsmRegOperand {
2910    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2911}
2912impl Eq for AsmRegOperand {}
2913impl PartialEq for AsmRegOperand {
2914    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2915}
2916impl Clone for AsmRegOperand {
2917    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2918}
2919impl fmt::Debug for AsmRegOperand {
2920    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2921        f.debug_struct("AsmRegOperand").field("syntax", &self.syntax).finish()
2922    }
2923}
2924impl AstNode for AsmRegSpec {
2925    #[inline]
2926    fn kind() -> SyntaxKind
2927    where
2928        Self: Sized,
2929    {
2930        ASM_REG_SPEC
2931    }
2932    #[inline]
2933    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_SPEC }
2934    #[inline]
2935    fn cast(syntax: SyntaxNode) -> Option<Self> {
2936        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2937    }
2938    #[inline]
2939    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2940}
2941impl hash::Hash for AsmRegSpec {
2942    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2943}
2944impl Eq for AsmRegSpec {}
2945impl PartialEq for AsmRegSpec {
2946    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2947}
2948impl Clone for AsmRegSpec {
2949    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2950}
2951impl fmt::Debug for AsmRegSpec {
2952    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2953        f.debug_struct("AsmRegSpec").field("syntax", &self.syntax).finish()
2954    }
2955}
2956impl AstNode for AsmSym {
2957    #[inline]
2958    fn kind() -> SyntaxKind
2959    where
2960        Self: Sized,
2961    {
2962        ASM_SYM
2963    }
2964    #[inline]
2965    fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_SYM }
2966    #[inline]
2967    fn cast(syntax: SyntaxNode) -> Option<Self> {
2968        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
2969    }
2970    #[inline]
2971    fn syntax(&self) -> &SyntaxNode { &self.syntax }
2972}
2973impl hash::Hash for AsmSym {
2974    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
2975}
2976impl Eq for AsmSym {}
2977impl PartialEq for AsmSym {
2978    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
2979}
2980impl Clone for AsmSym {
2981    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
2982}
2983impl fmt::Debug for AsmSym {
2984    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2985        f.debug_struct("AsmSym").field("syntax", &self.syntax).finish()
2986    }
2987}
2988impl AstNode for AssocItemList {
2989    #[inline]
2990    fn kind() -> SyntaxKind
2991    where
2992        Self: Sized,
2993    {
2994        ASSOC_ITEM_LIST
2995    }
2996    #[inline]
2997    fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
2998    #[inline]
2999    fn cast(syntax: SyntaxNode) -> Option<Self> {
3000        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3001    }
3002    #[inline]
3003    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3004}
3005impl hash::Hash for AssocItemList {
3006    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3007}
3008impl Eq for AssocItemList {}
3009impl PartialEq for AssocItemList {
3010    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3011}
3012impl Clone for AssocItemList {
3013    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3014}
3015impl fmt::Debug for AssocItemList {
3016    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3017        f.debug_struct("AssocItemList").field("syntax", &self.syntax).finish()
3018    }
3019}
3020impl AstNode for AssocTypeArg {
3021    #[inline]
3022    fn kind() -> SyntaxKind
3023    where
3024        Self: Sized,
3025    {
3026        ASSOC_TYPE_ARG
3027    }
3028    #[inline]
3029    fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
3030    #[inline]
3031    fn cast(syntax: SyntaxNode) -> Option<Self> {
3032        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3033    }
3034    #[inline]
3035    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3036}
3037impl hash::Hash for AssocTypeArg {
3038    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3039}
3040impl Eq for AssocTypeArg {}
3041impl PartialEq for AssocTypeArg {
3042    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3043}
3044impl Clone for AssocTypeArg {
3045    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3046}
3047impl fmt::Debug for AssocTypeArg {
3048    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3049        f.debug_struct("AssocTypeArg").field("syntax", &self.syntax).finish()
3050    }
3051}
3052impl AstNode for Attr {
3053    #[inline]
3054    fn kind() -> SyntaxKind
3055    where
3056        Self: Sized,
3057    {
3058        ATTR
3059    }
3060    #[inline]
3061    fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
3062    #[inline]
3063    fn cast(syntax: SyntaxNode) -> Option<Self> {
3064        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3065    }
3066    #[inline]
3067    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3068}
3069impl hash::Hash for Attr {
3070    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3071}
3072impl Eq for Attr {}
3073impl PartialEq for Attr {
3074    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3075}
3076impl Clone for Attr {
3077    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3078}
3079impl fmt::Debug for Attr {
3080    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3081        f.debug_struct("Attr").field("syntax", &self.syntax).finish()
3082    }
3083}
3084impl AstNode for AwaitExpr {
3085    #[inline]
3086    fn kind() -> SyntaxKind
3087    where
3088        Self: Sized,
3089    {
3090        AWAIT_EXPR
3091    }
3092    #[inline]
3093    fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
3094    #[inline]
3095    fn cast(syntax: SyntaxNode) -> Option<Self> {
3096        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3097    }
3098    #[inline]
3099    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3100}
3101impl hash::Hash for AwaitExpr {
3102    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3103}
3104impl Eq for AwaitExpr {}
3105impl PartialEq for AwaitExpr {
3106    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3107}
3108impl Clone for AwaitExpr {
3109    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3110}
3111impl fmt::Debug for AwaitExpr {
3112    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3113        f.debug_struct("AwaitExpr").field("syntax", &self.syntax).finish()
3114    }
3115}
3116impl AstNode for BecomeExpr {
3117    #[inline]
3118    fn kind() -> SyntaxKind
3119    where
3120        Self: Sized,
3121    {
3122        BECOME_EXPR
3123    }
3124    #[inline]
3125    fn can_cast(kind: SyntaxKind) -> bool { kind == BECOME_EXPR }
3126    #[inline]
3127    fn cast(syntax: SyntaxNode) -> Option<Self> {
3128        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3129    }
3130    #[inline]
3131    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3132}
3133impl hash::Hash for BecomeExpr {
3134    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3135}
3136impl Eq for BecomeExpr {}
3137impl PartialEq for BecomeExpr {
3138    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3139}
3140impl Clone for BecomeExpr {
3141    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3142}
3143impl fmt::Debug for BecomeExpr {
3144    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3145        f.debug_struct("BecomeExpr").field("syntax", &self.syntax).finish()
3146    }
3147}
3148impl AstNode for BinExpr {
3149    #[inline]
3150    fn kind() -> SyntaxKind
3151    where
3152        Self: Sized,
3153    {
3154        BIN_EXPR
3155    }
3156    #[inline]
3157    fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
3158    #[inline]
3159    fn cast(syntax: SyntaxNode) -> Option<Self> {
3160        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3161    }
3162    #[inline]
3163    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3164}
3165impl hash::Hash for BinExpr {
3166    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3167}
3168impl Eq for BinExpr {}
3169impl PartialEq for BinExpr {
3170    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3171}
3172impl Clone for BinExpr {
3173    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3174}
3175impl fmt::Debug for BinExpr {
3176    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3177        f.debug_struct("BinExpr").field("syntax", &self.syntax).finish()
3178    }
3179}
3180impl AstNode for BlockExpr {
3181    #[inline]
3182    fn kind() -> SyntaxKind
3183    where
3184        Self: Sized,
3185    {
3186        BLOCK_EXPR
3187    }
3188    #[inline]
3189    fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
3190    #[inline]
3191    fn cast(syntax: SyntaxNode) -> Option<Self> {
3192        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3193    }
3194    #[inline]
3195    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3196}
3197impl hash::Hash for BlockExpr {
3198    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3199}
3200impl Eq for BlockExpr {}
3201impl PartialEq for BlockExpr {
3202    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3203}
3204impl Clone for BlockExpr {
3205    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3206}
3207impl fmt::Debug for BlockExpr {
3208    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3209        f.debug_struct("BlockExpr").field("syntax", &self.syntax).finish()
3210    }
3211}
3212impl AstNode for BoxPat {
3213    #[inline]
3214    fn kind() -> SyntaxKind
3215    where
3216        Self: Sized,
3217    {
3218        BOX_PAT
3219    }
3220    #[inline]
3221    fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
3222    #[inline]
3223    fn cast(syntax: SyntaxNode) -> Option<Self> {
3224        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3225    }
3226    #[inline]
3227    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3228}
3229impl hash::Hash for BoxPat {
3230    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3231}
3232impl Eq for BoxPat {}
3233impl PartialEq for BoxPat {
3234    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3235}
3236impl Clone for BoxPat {
3237    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3238}
3239impl fmt::Debug for BoxPat {
3240    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3241        f.debug_struct("BoxPat").field("syntax", &self.syntax).finish()
3242    }
3243}
3244impl AstNode for BreakExpr {
3245    #[inline]
3246    fn kind() -> SyntaxKind
3247    where
3248        Self: Sized,
3249    {
3250        BREAK_EXPR
3251    }
3252    #[inline]
3253    fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
3254    #[inline]
3255    fn cast(syntax: SyntaxNode) -> Option<Self> {
3256        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3257    }
3258    #[inline]
3259    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3260}
3261impl hash::Hash for BreakExpr {
3262    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3263}
3264impl Eq for BreakExpr {}
3265impl PartialEq for BreakExpr {
3266    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3267}
3268impl Clone for BreakExpr {
3269    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3270}
3271impl fmt::Debug for BreakExpr {
3272    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3273        f.debug_struct("BreakExpr").field("syntax", &self.syntax).finish()
3274    }
3275}
3276impl AstNode for CallExpr {
3277    #[inline]
3278    fn kind() -> SyntaxKind
3279    where
3280        Self: Sized,
3281    {
3282        CALL_EXPR
3283    }
3284    #[inline]
3285    fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
3286    #[inline]
3287    fn cast(syntax: SyntaxNode) -> Option<Self> {
3288        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3289    }
3290    #[inline]
3291    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3292}
3293impl hash::Hash for CallExpr {
3294    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3295}
3296impl Eq for CallExpr {}
3297impl PartialEq for CallExpr {
3298    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3299}
3300impl Clone for CallExpr {
3301    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3302}
3303impl fmt::Debug for CallExpr {
3304    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3305        f.debug_struct("CallExpr").field("syntax", &self.syntax).finish()
3306    }
3307}
3308impl AstNode for CastExpr {
3309    #[inline]
3310    fn kind() -> SyntaxKind
3311    where
3312        Self: Sized,
3313    {
3314        CAST_EXPR
3315    }
3316    #[inline]
3317    fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
3318    #[inline]
3319    fn cast(syntax: SyntaxNode) -> Option<Self> {
3320        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3321    }
3322    #[inline]
3323    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3324}
3325impl hash::Hash for CastExpr {
3326    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3327}
3328impl Eq for CastExpr {}
3329impl PartialEq for CastExpr {
3330    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3331}
3332impl Clone for CastExpr {
3333    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3334}
3335impl fmt::Debug for CastExpr {
3336    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3337        f.debug_struct("CastExpr").field("syntax", &self.syntax).finish()
3338    }
3339}
3340impl AstNode for CfgAtom {
3341    #[inline]
3342    fn kind() -> SyntaxKind
3343    where
3344        Self: Sized,
3345    {
3346        CFG_ATOM
3347    }
3348    #[inline]
3349    fn can_cast(kind: SyntaxKind) -> bool { kind == CFG_ATOM }
3350    #[inline]
3351    fn cast(syntax: SyntaxNode) -> Option<Self> {
3352        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3353    }
3354    #[inline]
3355    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3356}
3357impl hash::Hash for CfgAtom {
3358    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3359}
3360impl Eq for CfgAtom {}
3361impl PartialEq for CfgAtom {
3362    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3363}
3364impl Clone for CfgAtom {
3365    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3366}
3367impl fmt::Debug for CfgAtom {
3368    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3369        f.debug_struct("CfgAtom").field("syntax", &self.syntax).finish()
3370    }
3371}
3372impl AstNode for CfgAttrMeta {
3373    #[inline]
3374    fn kind() -> SyntaxKind
3375    where
3376        Self: Sized,
3377    {
3378        CFG_ATTR_META
3379    }
3380    #[inline]
3381    fn can_cast(kind: SyntaxKind) -> bool { kind == CFG_ATTR_META }
3382    #[inline]
3383    fn cast(syntax: SyntaxNode) -> Option<Self> {
3384        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3385    }
3386    #[inline]
3387    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3388}
3389impl hash::Hash for CfgAttrMeta {
3390    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3391}
3392impl Eq for CfgAttrMeta {}
3393impl PartialEq for CfgAttrMeta {
3394    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3395}
3396impl Clone for CfgAttrMeta {
3397    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3398}
3399impl fmt::Debug for CfgAttrMeta {
3400    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3401        f.debug_struct("CfgAttrMeta").field("syntax", &self.syntax).finish()
3402    }
3403}
3404impl AstNode for CfgComposite {
3405    #[inline]
3406    fn kind() -> SyntaxKind
3407    where
3408        Self: Sized,
3409    {
3410        CFG_COMPOSITE
3411    }
3412    #[inline]
3413    fn can_cast(kind: SyntaxKind) -> bool { kind == CFG_COMPOSITE }
3414    #[inline]
3415    fn cast(syntax: SyntaxNode) -> Option<Self> {
3416        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3417    }
3418    #[inline]
3419    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3420}
3421impl hash::Hash for CfgComposite {
3422    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3423}
3424impl Eq for CfgComposite {}
3425impl PartialEq for CfgComposite {
3426    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3427}
3428impl Clone for CfgComposite {
3429    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3430}
3431impl fmt::Debug for CfgComposite {
3432    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3433        f.debug_struct("CfgComposite").field("syntax", &self.syntax).finish()
3434    }
3435}
3436impl AstNode for CfgMeta {
3437    #[inline]
3438    fn kind() -> SyntaxKind
3439    where
3440        Self: Sized,
3441    {
3442        CFG_META
3443    }
3444    #[inline]
3445    fn can_cast(kind: SyntaxKind) -> bool { kind == CFG_META }
3446    #[inline]
3447    fn cast(syntax: SyntaxNode) -> Option<Self> {
3448        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3449    }
3450    #[inline]
3451    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3452}
3453impl hash::Hash for CfgMeta {
3454    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3455}
3456impl Eq for CfgMeta {}
3457impl PartialEq for CfgMeta {
3458    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3459}
3460impl Clone for CfgMeta {
3461    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3462}
3463impl fmt::Debug for CfgMeta {
3464    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3465        f.debug_struct("CfgMeta").field("syntax", &self.syntax).finish()
3466    }
3467}
3468impl AstNode for ClosureExpr {
3469    #[inline]
3470    fn kind() -> SyntaxKind
3471    where
3472        Self: Sized,
3473    {
3474        CLOSURE_EXPR
3475    }
3476    #[inline]
3477    fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
3478    #[inline]
3479    fn cast(syntax: SyntaxNode) -> Option<Self> {
3480        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3481    }
3482    #[inline]
3483    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3484}
3485impl hash::Hash for ClosureExpr {
3486    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3487}
3488impl Eq for ClosureExpr {}
3489impl PartialEq for ClosureExpr {
3490    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3491}
3492impl Clone for ClosureExpr {
3493    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3494}
3495impl fmt::Debug for ClosureExpr {
3496    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3497        f.debug_struct("ClosureExpr").field("syntax", &self.syntax).finish()
3498    }
3499}
3500impl AstNode for Const {
3501    #[inline]
3502    fn kind() -> SyntaxKind
3503    where
3504        Self: Sized,
3505    {
3506        CONST
3507    }
3508    #[inline]
3509    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
3510    #[inline]
3511    fn cast(syntax: SyntaxNode) -> Option<Self> {
3512        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3513    }
3514    #[inline]
3515    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3516}
3517impl hash::Hash for Const {
3518    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3519}
3520impl Eq for Const {}
3521impl PartialEq for Const {
3522    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3523}
3524impl Clone for Const {
3525    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3526}
3527impl fmt::Debug for Const {
3528    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3529        f.debug_struct("Const").field("syntax", &self.syntax).finish()
3530    }
3531}
3532impl AstNode for ConstArg {
3533    #[inline]
3534    fn kind() -> SyntaxKind
3535    where
3536        Self: Sized,
3537    {
3538        CONST_ARG
3539    }
3540    #[inline]
3541    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
3542    #[inline]
3543    fn cast(syntax: SyntaxNode) -> Option<Self> {
3544        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3545    }
3546    #[inline]
3547    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3548}
3549impl hash::Hash for ConstArg {
3550    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3551}
3552impl Eq for ConstArg {}
3553impl PartialEq for ConstArg {
3554    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3555}
3556impl Clone for ConstArg {
3557    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3558}
3559impl fmt::Debug for ConstArg {
3560    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3561        f.debug_struct("ConstArg").field("syntax", &self.syntax).finish()
3562    }
3563}
3564impl AstNode for ConstBlockPat {
3565    #[inline]
3566    fn kind() -> SyntaxKind
3567    where
3568        Self: Sized,
3569    {
3570        CONST_BLOCK_PAT
3571    }
3572    #[inline]
3573    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
3574    #[inline]
3575    fn cast(syntax: SyntaxNode) -> Option<Self> {
3576        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3577    }
3578    #[inline]
3579    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3580}
3581impl hash::Hash for ConstBlockPat {
3582    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3583}
3584impl Eq for ConstBlockPat {}
3585impl PartialEq for ConstBlockPat {
3586    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3587}
3588impl Clone for ConstBlockPat {
3589    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3590}
3591impl fmt::Debug for ConstBlockPat {
3592    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3593        f.debug_struct("ConstBlockPat").field("syntax", &self.syntax).finish()
3594    }
3595}
3596impl AstNode for ConstParam {
3597    #[inline]
3598    fn kind() -> SyntaxKind
3599    where
3600        Self: Sized,
3601    {
3602        CONST_PARAM
3603    }
3604    #[inline]
3605    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
3606    #[inline]
3607    fn cast(syntax: SyntaxNode) -> Option<Self> {
3608        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3609    }
3610    #[inline]
3611    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3612}
3613impl hash::Hash for ConstParam {
3614    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3615}
3616impl Eq for ConstParam {}
3617impl PartialEq for ConstParam {
3618    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3619}
3620impl Clone for ConstParam {
3621    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3622}
3623impl fmt::Debug for ConstParam {
3624    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3625        f.debug_struct("ConstParam").field("syntax", &self.syntax).finish()
3626    }
3627}
3628impl AstNode for ContinueExpr {
3629    #[inline]
3630    fn kind() -> SyntaxKind
3631    where
3632        Self: Sized,
3633    {
3634        CONTINUE_EXPR
3635    }
3636    #[inline]
3637    fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
3638    #[inline]
3639    fn cast(syntax: SyntaxNode) -> Option<Self> {
3640        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3641    }
3642    #[inline]
3643    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3644}
3645impl hash::Hash for ContinueExpr {
3646    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3647}
3648impl Eq for ContinueExpr {}
3649impl PartialEq for ContinueExpr {
3650    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3651}
3652impl Clone for ContinueExpr {
3653    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3654}
3655impl fmt::Debug for ContinueExpr {
3656    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3657        f.debug_struct("ContinueExpr").field("syntax", &self.syntax).finish()
3658    }
3659}
3660impl AstNode for DerefPat {
3661    #[inline]
3662    fn kind() -> SyntaxKind
3663    where
3664        Self: Sized,
3665    {
3666        DEREF_PAT
3667    }
3668    #[inline]
3669    fn can_cast(kind: SyntaxKind) -> bool { kind == DEREF_PAT }
3670    #[inline]
3671    fn cast(syntax: SyntaxNode) -> Option<Self> {
3672        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3673    }
3674    #[inline]
3675    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3676}
3677impl hash::Hash for DerefPat {
3678    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3679}
3680impl Eq for DerefPat {}
3681impl PartialEq for DerefPat {
3682    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3683}
3684impl Clone for DerefPat {
3685    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3686}
3687impl fmt::Debug for DerefPat {
3688    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3689        f.debug_struct("DerefPat").field("syntax", &self.syntax).finish()
3690    }
3691}
3692impl AstNode for DynTraitType {
3693    #[inline]
3694    fn kind() -> SyntaxKind
3695    where
3696        Self: Sized,
3697    {
3698        DYN_TRAIT_TYPE
3699    }
3700    #[inline]
3701    fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
3702    #[inline]
3703    fn cast(syntax: SyntaxNode) -> Option<Self> {
3704        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3705    }
3706    #[inline]
3707    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3708}
3709impl hash::Hash for DynTraitType {
3710    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3711}
3712impl Eq for DynTraitType {}
3713impl PartialEq for DynTraitType {
3714    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3715}
3716impl Clone for DynTraitType {
3717    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3718}
3719impl fmt::Debug for DynTraitType {
3720    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3721        f.debug_struct("DynTraitType").field("syntax", &self.syntax).finish()
3722    }
3723}
3724impl AstNode for Enum {
3725    #[inline]
3726    fn kind() -> SyntaxKind
3727    where
3728        Self: Sized,
3729    {
3730        ENUM
3731    }
3732    #[inline]
3733    fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
3734    #[inline]
3735    fn cast(syntax: SyntaxNode) -> Option<Self> {
3736        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3737    }
3738    #[inline]
3739    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3740}
3741impl hash::Hash for Enum {
3742    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3743}
3744impl Eq for Enum {}
3745impl PartialEq for Enum {
3746    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3747}
3748impl Clone for Enum {
3749    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3750}
3751impl fmt::Debug for Enum {
3752    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3753        f.debug_struct("Enum").field("syntax", &self.syntax).finish()
3754    }
3755}
3756impl AstNode for ExprStmt {
3757    #[inline]
3758    fn kind() -> SyntaxKind
3759    where
3760        Self: Sized,
3761    {
3762        EXPR_STMT
3763    }
3764    #[inline]
3765    fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
3766    #[inline]
3767    fn cast(syntax: SyntaxNode) -> Option<Self> {
3768        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3769    }
3770    #[inline]
3771    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3772}
3773impl hash::Hash for ExprStmt {
3774    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3775}
3776impl Eq for ExprStmt {}
3777impl PartialEq for ExprStmt {
3778    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3779}
3780impl Clone for ExprStmt {
3781    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3782}
3783impl fmt::Debug for ExprStmt {
3784    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3785        f.debug_struct("ExprStmt").field("syntax", &self.syntax).finish()
3786    }
3787}
3788impl AstNode for ExternBlock {
3789    #[inline]
3790    fn kind() -> SyntaxKind
3791    where
3792        Self: Sized,
3793    {
3794        EXTERN_BLOCK
3795    }
3796    #[inline]
3797    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
3798    #[inline]
3799    fn cast(syntax: SyntaxNode) -> Option<Self> {
3800        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3801    }
3802    #[inline]
3803    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3804}
3805impl hash::Hash for ExternBlock {
3806    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3807}
3808impl Eq for ExternBlock {}
3809impl PartialEq for ExternBlock {
3810    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3811}
3812impl Clone for ExternBlock {
3813    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3814}
3815impl fmt::Debug for ExternBlock {
3816    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3817        f.debug_struct("ExternBlock").field("syntax", &self.syntax).finish()
3818    }
3819}
3820impl AstNode for ExternCrate {
3821    #[inline]
3822    fn kind() -> SyntaxKind
3823    where
3824        Self: Sized,
3825    {
3826        EXTERN_CRATE
3827    }
3828    #[inline]
3829    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
3830    #[inline]
3831    fn cast(syntax: SyntaxNode) -> Option<Self> {
3832        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3833    }
3834    #[inline]
3835    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3836}
3837impl hash::Hash for ExternCrate {
3838    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3839}
3840impl Eq for ExternCrate {}
3841impl PartialEq for ExternCrate {
3842    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3843}
3844impl Clone for ExternCrate {
3845    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3846}
3847impl fmt::Debug for ExternCrate {
3848    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3849        f.debug_struct("ExternCrate").field("syntax", &self.syntax).finish()
3850    }
3851}
3852impl AstNode for ExternItemList {
3853    #[inline]
3854    fn kind() -> SyntaxKind
3855    where
3856        Self: Sized,
3857    {
3858        EXTERN_ITEM_LIST
3859    }
3860    #[inline]
3861    fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
3862    #[inline]
3863    fn cast(syntax: SyntaxNode) -> Option<Self> {
3864        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3865    }
3866    #[inline]
3867    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3868}
3869impl hash::Hash for ExternItemList {
3870    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3871}
3872impl Eq for ExternItemList {}
3873impl PartialEq for ExternItemList {
3874    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3875}
3876impl Clone for ExternItemList {
3877    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3878}
3879impl fmt::Debug for ExternItemList {
3880    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3881        f.debug_struct("ExternItemList").field("syntax", &self.syntax).finish()
3882    }
3883}
3884impl AstNode for FieldExpr {
3885    #[inline]
3886    fn kind() -> SyntaxKind
3887    where
3888        Self: Sized,
3889    {
3890        FIELD_EXPR
3891    }
3892    #[inline]
3893    fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
3894    #[inline]
3895    fn cast(syntax: SyntaxNode) -> Option<Self> {
3896        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3897    }
3898    #[inline]
3899    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3900}
3901impl hash::Hash for FieldExpr {
3902    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3903}
3904impl Eq for FieldExpr {}
3905impl PartialEq for FieldExpr {
3906    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3907}
3908impl Clone for FieldExpr {
3909    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3910}
3911impl fmt::Debug for FieldExpr {
3912    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3913        f.debug_struct("FieldExpr").field("syntax", &self.syntax).finish()
3914    }
3915}
3916impl AstNode for Fn {
3917    #[inline]
3918    fn kind() -> SyntaxKind
3919    where
3920        Self: Sized,
3921    {
3922        FN
3923    }
3924    #[inline]
3925    fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
3926    #[inline]
3927    fn cast(syntax: SyntaxNode) -> Option<Self> {
3928        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3929    }
3930    #[inline]
3931    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3932}
3933impl hash::Hash for Fn {
3934    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3935}
3936impl Eq for Fn {}
3937impl PartialEq for Fn {
3938    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3939}
3940impl Clone for Fn {
3941    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3942}
3943impl fmt::Debug for Fn {
3944    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3945        f.debug_struct("Fn").field("syntax", &self.syntax).finish()
3946    }
3947}
3948impl AstNode for FnPtrType {
3949    #[inline]
3950    fn kind() -> SyntaxKind
3951    where
3952        Self: Sized,
3953    {
3954        FN_PTR_TYPE
3955    }
3956    #[inline]
3957    fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
3958    #[inline]
3959    fn cast(syntax: SyntaxNode) -> Option<Self> {
3960        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3961    }
3962    #[inline]
3963    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3964}
3965impl hash::Hash for FnPtrType {
3966    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3967}
3968impl Eq for FnPtrType {}
3969impl PartialEq for FnPtrType {
3970    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
3971}
3972impl Clone for FnPtrType {
3973    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
3974}
3975impl fmt::Debug for FnPtrType {
3976    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3977        f.debug_struct("FnPtrType").field("syntax", &self.syntax).finish()
3978    }
3979}
3980impl AstNode for ForBinder {
3981    #[inline]
3982    fn kind() -> SyntaxKind
3983    where
3984        Self: Sized,
3985    {
3986        FOR_BINDER
3987    }
3988    #[inline]
3989    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_BINDER }
3990    #[inline]
3991    fn cast(syntax: SyntaxNode) -> Option<Self> {
3992        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
3993    }
3994    #[inline]
3995    fn syntax(&self) -> &SyntaxNode { &self.syntax }
3996}
3997impl hash::Hash for ForBinder {
3998    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
3999}
4000impl Eq for ForBinder {}
4001impl PartialEq for ForBinder {
4002    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4003}
4004impl Clone for ForBinder {
4005    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4006}
4007impl fmt::Debug for ForBinder {
4008    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4009        f.debug_struct("ForBinder").field("syntax", &self.syntax).finish()
4010    }
4011}
4012impl AstNode for ForExpr {
4013    #[inline]
4014    fn kind() -> SyntaxKind
4015    where
4016        Self: Sized,
4017    {
4018        FOR_EXPR
4019    }
4020    #[inline]
4021    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
4022    #[inline]
4023    fn cast(syntax: SyntaxNode) -> Option<Self> {
4024        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4025    }
4026    #[inline]
4027    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4028}
4029impl hash::Hash for ForExpr {
4030    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4031}
4032impl Eq for ForExpr {}
4033impl PartialEq for ForExpr {
4034    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4035}
4036impl Clone for ForExpr {
4037    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4038}
4039impl fmt::Debug for ForExpr {
4040    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4041        f.debug_struct("ForExpr").field("syntax", &self.syntax).finish()
4042    }
4043}
4044impl AstNode for ForType {
4045    #[inline]
4046    fn kind() -> SyntaxKind
4047    where
4048        Self: Sized,
4049    {
4050        FOR_TYPE
4051    }
4052    #[inline]
4053    fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
4054    #[inline]
4055    fn cast(syntax: SyntaxNode) -> Option<Self> {
4056        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4057    }
4058    #[inline]
4059    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4060}
4061impl hash::Hash for ForType {
4062    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4063}
4064impl Eq for ForType {}
4065impl PartialEq for ForType {
4066    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4067}
4068impl Clone for ForType {
4069    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4070}
4071impl fmt::Debug for ForType {
4072    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4073        f.debug_struct("ForType").field("syntax", &self.syntax).finish()
4074    }
4075}
4076impl AstNode for FormatArgsArg {
4077    #[inline]
4078    fn kind() -> SyntaxKind
4079    where
4080        Self: Sized,
4081    {
4082        FORMAT_ARGS_ARG
4083    }
4084    #[inline]
4085    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG }
4086    #[inline]
4087    fn cast(syntax: SyntaxNode) -> Option<Self> {
4088        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4089    }
4090    #[inline]
4091    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4092}
4093impl hash::Hash for FormatArgsArg {
4094    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4095}
4096impl Eq for FormatArgsArg {}
4097impl PartialEq for FormatArgsArg {
4098    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4099}
4100impl Clone for FormatArgsArg {
4101    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4102}
4103impl fmt::Debug for FormatArgsArg {
4104    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4105        f.debug_struct("FormatArgsArg").field("syntax", &self.syntax).finish()
4106    }
4107}
4108impl AstNode for FormatArgsArgName {
4109    #[inline]
4110    fn kind() -> SyntaxKind
4111    where
4112        Self: Sized,
4113    {
4114        FORMAT_ARGS_ARG_NAME
4115    }
4116    #[inline]
4117    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG_NAME }
4118    #[inline]
4119    fn cast(syntax: SyntaxNode) -> Option<Self> {
4120        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4121    }
4122    #[inline]
4123    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4124}
4125impl hash::Hash for FormatArgsArgName {
4126    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4127}
4128impl Eq for FormatArgsArgName {}
4129impl PartialEq for FormatArgsArgName {
4130    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4131}
4132impl Clone for FormatArgsArgName {
4133    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4134}
4135impl fmt::Debug for FormatArgsArgName {
4136    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4137        f.debug_struct("FormatArgsArgName").field("syntax", &self.syntax).finish()
4138    }
4139}
4140impl AstNode for FormatArgsExpr {
4141    #[inline]
4142    fn kind() -> SyntaxKind
4143    where
4144        Self: Sized,
4145    {
4146        FORMAT_ARGS_EXPR
4147    }
4148    #[inline]
4149    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_EXPR }
4150    #[inline]
4151    fn cast(syntax: SyntaxNode) -> Option<Self> {
4152        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4153    }
4154    #[inline]
4155    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4156}
4157impl hash::Hash for FormatArgsExpr {
4158    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4159}
4160impl Eq for FormatArgsExpr {}
4161impl PartialEq for FormatArgsExpr {
4162    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4163}
4164impl Clone for FormatArgsExpr {
4165    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4166}
4167impl fmt::Debug for FormatArgsExpr {
4168    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4169        f.debug_struct("FormatArgsExpr").field("syntax", &self.syntax).finish()
4170    }
4171}
4172impl AstNode for GenericArgList {
4173    #[inline]
4174    fn kind() -> SyntaxKind
4175    where
4176        Self: Sized,
4177    {
4178        GENERIC_ARG_LIST
4179    }
4180    #[inline]
4181    fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
4182    #[inline]
4183    fn cast(syntax: SyntaxNode) -> Option<Self> {
4184        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4185    }
4186    #[inline]
4187    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4188}
4189impl hash::Hash for GenericArgList {
4190    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4191}
4192impl Eq for GenericArgList {}
4193impl PartialEq for GenericArgList {
4194    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4195}
4196impl Clone for GenericArgList {
4197    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4198}
4199impl fmt::Debug for GenericArgList {
4200    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4201        f.debug_struct("GenericArgList").field("syntax", &self.syntax).finish()
4202    }
4203}
4204impl AstNode for GenericParamList {
4205    #[inline]
4206    fn kind() -> SyntaxKind
4207    where
4208        Self: Sized,
4209    {
4210        GENERIC_PARAM_LIST
4211    }
4212    #[inline]
4213    fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
4214    #[inline]
4215    fn cast(syntax: SyntaxNode) -> Option<Self> {
4216        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4217    }
4218    #[inline]
4219    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4220}
4221impl hash::Hash for GenericParamList {
4222    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4223}
4224impl Eq for GenericParamList {}
4225impl PartialEq for GenericParamList {
4226    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4227}
4228impl Clone for GenericParamList {
4229    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4230}
4231impl fmt::Debug for GenericParamList {
4232    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4233        f.debug_struct("GenericParamList").field("syntax", &self.syntax).finish()
4234    }
4235}
4236impl AstNode for IdentPat {
4237    #[inline]
4238    fn kind() -> SyntaxKind
4239    where
4240        Self: Sized,
4241    {
4242        IDENT_PAT
4243    }
4244    #[inline]
4245    fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
4246    #[inline]
4247    fn cast(syntax: SyntaxNode) -> Option<Self> {
4248        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4249    }
4250    #[inline]
4251    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4252}
4253impl hash::Hash for IdentPat {
4254    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4255}
4256impl Eq for IdentPat {}
4257impl PartialEq for IdentPat {
4258    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4259}
4260impl Clone for IdentPat {
4261    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4262}
4263impl fmt::Debug for IdentPat {
4264    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4265        f.debug_struct("IdentPat").field("syntax", &self.syntax).finish()
4266    }
4267}
4268impl AstNode for IfExpr {
4269    #[inline]
4270    fn kind() -> SyntaxKind
4271    where
4272        Self: Sized,
4273    {
4274        IF_EXPR
4275    }
4276    #[inline]
4277    fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
4278    #[inline]
4279    fn cast(syntax: SyntaxNode) -> Option<Self> {
4280        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4281    }
4282    #[inline]
4283    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4284}
4285impl hash::Hash for IfExpr {
4286    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4287}
4288impl Eq for IfExpr {}
4289impl PartialEq for IfExpr {
4290    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4291}
4292impl Clone for IfExpr {
4293    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4294}
4295impl fmt::Debug for IfExpr {
4296    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4297        f.debug_struct("IfExpr").field("syntax", &self.syntax).finish()
4298    }
4299}
4300impl AstNode for Impl {
4301    #[inline]
4302    fn kind() -> SyntaxKind
4303    where
4304        Self: Sized,
4305    {
4306        IMPL
4307    }
4308    #[inline]
4309    fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
4310    #[inline]
4311    fn cast(syntax: SyntaxNode) -> Option<Self> {
4312        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4313    }
4314    #[inline]
4315    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4316}
4317impl hash::Hash for Impl {
4318    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4319}
4320impl Eq for Impl {}
4321impl PartialEq for Impl {
4322    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4323}
4324impl Clone for Impl {
4325    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4326}
4327impl fmt::Debug for Impl {
4328    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4329        f.debug_struct("Impl").field("syntax", &self.syntax).finish()
4330    }
4331}
4332impl AstNode for ImplRestriction {
4333    #[inline]
4334    fn kind() -> SyntaxKind
4335    where
4336        Self: Sized,
4337    {
4338        IMPL_RESTRICTION
4339    }
4340    #[inline]
4341    fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_RESTRICTION }
4342    #[inline]
4343    fn cast(syntax: SyntaxNode) -> Option<Self> {
4344        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4345    }
4346    #[inline]
4347    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4348}
4349impl hash::Hash for ImplRestriction {
4350    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4351}
4352impl Eq for ImplRestriction {}
4353impl PartialEq for ImplRestriction {
4354    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4355}
4356impl Clone for ImplRestriction {
4357    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4358}
4359impl fmt::Debug for ImplRestriction {
4360    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4361        f.debug_struct("ImplRestriction").field("syntax", &self.syntax).finish()
4362    }
4363}
4364impl AstNode for ImplTraitType {
4365    #[inline]
4366    fn kind() -> SyntaxKind
4367    where
4368        Self: Sized,
4369    {
4370        IMPL_TRAIT_TYPE
4371    }
4372    #[inline]
4373    fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
4374    #[inline]
4375    fn cast(syntax: SyntaxNode) -> Option<Self> {
4376        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4377    }
4378    #[inline]
4379    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4380}
4381impl hash::Hash for ImplTraitType {
4382    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4383}
4384impl Eq for ImplTraitType {}
4385impl PartialEq for ImplTraitType {
4386    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4387}
4388impl Clone for ImplTraitType {
4389    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4390}
4391impl fmt::Debug for ImplTraitType {
4392    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4393        f.debug_struct("ImplTraitType").field("syntax", &self.syntax).finish()
4394    }
4395}
4396impl AstNode for IncludeBytesExpr {
4397    #[inline]
4398    fn kind() -> SyntaxKind
4399    where
4400        Self: Sized,
4401    {
4402        INCLUDE_BYTES_EXPR
4403    }
4404    #[inline]
4405    fn can_cast(kind: SyntaxKind) -> bool { kind == INCLUDE_BYTES_EXPR }
4406    #[inline]
4407    fn cast(syntax: SyntaxNode) -> Option<Self> {
4408        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4409    }
4410    #[inline]
4411    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4412}
4413impl hash::Hash for IncludeBytesExpr {
4414    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4415}
4416impl Eq for IncludeBytesExpr {}
4417impl PartialEq for IncludeBytesExpr {
4418    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4419}
4420impl Clone for IncludeBytesExpr {
4421    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4422}
4423impl fmt::Debug for IncludeBytesExpr {
4424    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4425        f.debug_struct("IncludeBytesExpr").field("syntax", &self.syntax).finish()
4426    }
4427}
4428impl AstNode for IndexExpr {
4429    #[inline]
4430    fn kind() -> SyntaxKind
4431    where
4432        Self: Sized,
4433    {
4434        INDEX_EXPR
4435    }
4436    #[inline]
4437    fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
4438    #[inline]
4439    fn cast(syntax: SyntaxNode) -> Option<Self> {
4440        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4441    }
4442    #[inline]
4443    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4444}
4445impl hash::Hash for IndexExpr {
4446    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4447}
4448impl Eq for IndexExpr {}
4449impl PartialEq for IndexExpr {
4450    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4451}
4452impl Clone for IndexExpr {
4453    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4454}
4455impl fmt::Debug for IndexExpr {
4456    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4457        f.debug_struct("IndexExpr").field("syntax", &self.syntax).finish()
4458    }
4459}
4460impl AstNode for InferType {
4461    #[inline]
4462    fn kind() -> SyntaxKind
4463    where
4464        Self: Sized,
4465    {
4466        INFER_TYPE
4467    }
4468    #[inline]
4469    fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
4470    #[inline]
4471    fn cast(syntax: SyntaxNode) -> Option<Self> {
4472        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4473    }
4474    #[inline]
4475    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4476}
4477impl hash::Hash for InferType {
4478    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4479}
4480impl Eq for InferType {}
4481impl PartialEq for InferType {
4482    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4483}
4484impl Clone for InferType {
4485    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4486}
4487impl fmt::Debug for InferType {
4488    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4489        f.debug_struct("InferType").field("syntax", &self.syntax).finish()
4490    }
4491}
4492impl AstNode for ItemList {
4493    #[inline]
4494    fn kind() -> SyntaxKind
4495    where
4496        Self: Sized,
4497    {
4498        ITEM_LIST
4499    }
4500    #[inline]
4501    fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
4502    #[inline]
4503    fn cast(syntax: SyntaxNode) -> Option<Self> {
4504        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4505    }
4506    #[inline]
4507    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4508}
4509impl hash::Hash for ItemList {
4510    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4511}
4512impl Eq for ItemList {}
4513impl PartialEq for ItemList {
4514    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4515}
4516impl Clone for ItemList {
4517    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4518}
4519impl fmt::Debug for ItemList {
4520    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4521        f.debug_struct("ItemList").field("syntax", &self.syntax).finish()
4522    }
4523}
4524impl AstNode for KeyValueMeta {
4525    #[inline]
4526    fn kind() -> SyntaxKind
4527    where
4528        Self: Sized,
4529    {
4530        KEY_VALUE_META
4531    }
4532    #[inline]
4533    fn can_cast(kind: SyntaxKind) -> bool { kind == KEY_VALUE_META }
4534    #[inline]
4535    fn cast(syntax: SyntaxNode) -> Option<Self> {
4536        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4537    }
4538    #[inline]
4539    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4540}
4541impl hash::Hash for KeyValueMeta {
4542    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4543}
4544impl Eq for KeyValueMeta {}
4545impl PartialEq for KeyValueMeta {
4546    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4547}
4548impl Clone for KeyValueMeta {
4549    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4550}
4551impl fmt::Debug for KeyValueMeta {
4552    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4553        f.debug_struct("KeyValueMeta").field("syntax", &self.syntax).finish()
4554    }
4555}
4556impl AstNode for Label {
4557    #[inline]
4558    fn kind() -> SyntaxKind
4559    where
4560        Self: Sized,
4561    {
4562        LABEL
4563    }
4564    #[inline]
4565    fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
4566    #[inline]
4567    fn cast(syntax: SyntaxNode) -> Option<Self> {
4568        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4569    }
4570    #[inline]
4571    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4572}
4573impl hash::Hash for Label {
4574    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4575}
4576impl Eq for Label {}
4577impl PartialEq for Label {
4578    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4579}
4580impl Clone for Label {
4581    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4582}
4583impl fmt::Debug for Label {
4584    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4585        f.debug_struct("Label").field("syntax", &self.syntax).finish()
4586    }
4587}
4588impl AstNode for LetElse {
4589    #[inline]
4590    fn kind() -> SyntaxKind
4591    where
4592        Self: Sized,
4593    {
4594        LET_ELSE
4595    }
4596    #[inline]
4597    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE }
4598    #[inline]
4599    fn cast(syntax: SyntaxNode) -> Option<Self> {
4600        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4601    }
4602    #[inline]
4603    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4604}
4605impl hash::Hash for LetElse {
4606    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4607}
4608impl Eq for LetElse {}
4609impl PartialEq for LetElse {
4610    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4611}
4612impl Clone for LetElse {
4613    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4614}
4615impl fmt::Debug for LetElse {
4616    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4617        f.debug_struct("LetElse").field("syntax", &self.syntax).finish()
4618    }
4619}
4620impl AstNode for LetExpr {
4621    #[inline]
4622    fn kind() -> SyntaxKind
4623    where
4624        Self: Sized,
4625    {
4626        LET_EXPR
4627    }
4628    #[inline]
4629    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR }
4630    #[inline]
4631    fn cast(syntax: SyntaxNode) -> Option<Self> {
4632        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4633    }
4634    #[inline]
4635    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4636}
4637impl hash::Hash for LetExpr {
4638    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4639}
4640impl Eq for LetExpr {}
4641impl PartialEq for LetExpr {
4642    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4643}
4644impl Clone for LetExpr {
4645    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4646}
4647impl fmt::Debug for LetExpr {
4648    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4649        f.debug_struct("LetExpr").field("syntax", &self.syntax).finish()
4650    }
4651}
4652impl AstNode for LetStmt {
4653    #[inline]
4654    fn kind() -> SyntaxKind
4655    where
4656        Self: Sized,
4657    {
4658        LET_STMT
4659    }
4660    #[inline]
4661    fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
4662    #[inline]
4663    fn cast(syntax: SyntaxNode) -> Option<Self> {
4664        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4665    }
4666    #[inline]
4667    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4668}
4669impl hash::Hash for LetStmt {
4670    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4671}
4672impl Eq for LetStmt {}
4673impl PartialEq for LetStmt {
4674    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4675}
4676impl Clone for LetStmt {
4677    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4678}
4679impl fmt::Debug for LetStmt {
4680    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4681        f.debug_struct("LetStmt").field("syntax", &self.syntax).finish()
4682    }
4683}
4684impl AstNode for Lifetime {
4685    #[inline]
4686    fn kind() -> SyntaxKind
4687    where
4688        Self: Sized,
4689    {
4690        LIFETIME
4691    }
4692    #[inline]
4693    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME }
4694    #[inline]
4695    fn cast(syntax: SyntaxNode) -> Option<Self> {
4696        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4697    }
4698    #[inline]
4699    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4700}
4701impl hash::Hash for Lifetime {
4702    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4703}
4704impl Eq for Lifetime {}
4705impl PartialEq for Lifetime {
4706    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4707}
4708impl Clone for Lifetime {
4709    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4710}
4711impl fmt::Debug for Lifetime {
4712    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4713        f.debug_struct("Lifetime").field("syntax", &self.syntax).finish()
4714    }
4715}
4716impl AstNode for LifetimeArg {
4717    #[inline]
4718    fn kind() -> SyntaxKind
4719    where
4720        Self: Sized,
4721    {
4722        LIFETIME_ARG
4723    }
4724    #[inline]
4725    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
4726    #[inline]
4727    fn cast(syntax: SyntaxNode) -> Option<Self> {
4728        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4729    }
4730    #[inline]
4731    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4732}
4733impl hash::Hash for LifetimeArg {
4734    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4735}
4736impl Eq for LifetimeArg {}
4737impl PartialEq for LifetimeArg {
4738    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4739}
4740impl Clone for LifetimeArg {
4741    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4742}
4743impl fmt::Debug for LifetimeArg {
4744    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4745        f.debug_struct("LifetimeArg").field("syntax", &self.syntax).finish()
4746    }
4747}
4748impl AstNode for LifetimeParam {
4749    #[inline]
4750    fn kind() -> SyntaxKind
4751    where
4752        Self: Sized,
4753    {
4754        LIFETIME_PARAM
4755    }
4756    #[inline]
4757    fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
4758    #[inline]
4759    fn cast(syntax: SyntaxNode) -> Option<Self> {
4760        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4761    }
4762    #[inline]
4763    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4764}
4765impl hash::Hash for LifetimeParam {
4766    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4767}
4768impl Eq for LifetimeParam {}
4769impl PartialEq for LifetimeParam {
4770    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4771}
4772impl Clone for LifetimeParam {
4773    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4774}
4775impl fmt::Debug for LifetimeParam {
4776    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4777        f.debug_struct("LifetimeParam").field("syntax", &self.syntax).finish()
4778    }
4779}
4780impl AstNode for Literal {
4781    #[inline]
4782    fn kind() -> SyntaxKind
4783    where
4784        Self: Sized,
4785    {
4786        LITERAL
4787    }
4788    #[inline]
4789    fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
4790    #[inline]
4791    fn cast(syntax: SyntaxNode) -> Option<Self> {
4792        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4793    }
4794    #[inline]
4795    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4796}
4797impl hash::Hash for Literal {
4798    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4799}
4800impl Eq for Literal {}
4801impl PartialEq for Literal {
4802    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4803}
4804impl Clone for Literal {
4805    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4806}
4807impl fmt::Debug for Literal {
4808    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4809        f.debug_struct("Literal").field("syntax", &self.syntax).finish()
4810    }
4811}
4812impl AstNode for LiteralPat {
4813    #[inline]
4814    fn kind() -> SyntaxKind
4815    where
4816        Self: Sized,
4817    {
4818        LITERAL_PAT
4819    }
4820    #[inline]
4821    fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
4822    #[inline]
4823    fn cast(syntax: SyntaxNode) -> Option<Self> {
4824        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4825    }
4826    #[inline]
4827    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4828}
4829impl hash::Hash for LiteralPat {
4830    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4831}
4832impl Eq for LiteralPat {}
4833impl PartialEq for LiteralPat {
4834    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4835}
4836impl Clone for LiteralPat {
4837    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4838}
4839impl fmt::Debug for LiteralPat {
4840    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4841        f.debug_struct("LiteralPat").field("syntax", &self.syntax).finish()
4842    }
4843}
4844impl AstNode for LoopExpr {
4845    #[inline]
4846    fn kind() -> SyntaxKind
4847    where
4848        Self: Sized,
4849    {
4850        LOOP_EXPR
4851    }
4852    #[inline]
4853    fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
4854    #[inline]
4855    fn cast(syntax: SyntaxNode) -> Option<Self> {
4856        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4857    }
4858    #[inline]
4859    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4860}
4861impl hash::Hash for LoopExpr {
4862    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4863}
4864impl Eq for LoopExpr {}
4865impl PartialEq for LoopExpr {
4866    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4867}
4868impl Clone for LoopExpr {
4869    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4870}
4871impl fmt::Debug for LoopExpr {
4872    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4873        f.debug_struct("LoopExpr").field("syntax", &self.syntax).finish()
4874    }
4875}
4876impl AstNode for MacroCall {
4877    #[inline]
4878    fn kind() -> SyntaxKind
4879    where
4880        Self: Sized,
4881    {
4882        MACRO_CALL
4883    }
4884    #[inline]
4885    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
4886    #[inline]
4887    fn cast(syntax: SyntaxNode) -> Option<Self> {
4888        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4889    }
4890    #[inline]
4891    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4892}
4893impl hash::Hash for MacroCall {
4894    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4895}
4896impl Eq for MacroCall {}
4897impl PartialEq for MacroCall {
4898    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4899}
4900impl Clone for MacroCall {
4901    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4902}
4903impl fmt::Debug for MacroCall {
4904    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4905        f.debug_struct("MacroCall").field("syntax", &self.syntax).finish()
4906    }
4907}
4908impl AstNode for MacroDef {
4909    #[inline]
4910    fn kind() -> SyntaxKind
4911    where
4912        Self: Sized,
4913    {
4914        MACRO_DEF
4915    }
4916    #[inline]
4917    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
4918    #[inline]
4919    fn cast(syntax: SyntaxNode) -> Option<Self> {
4920        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4921    }
4922    #[inline]
4923    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4924}
4925impl hash::Hash for MacroDef {
4926    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4927}
4928impl Eq for MacroDef {}
4929impl PartialEq for MacroDef {
4930    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4931}
4932impl Clone for MacroDef {
4933    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4934}
4935impl fmt::Debug for MacroDef {
4936    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4937        f.debug_struct("MacroDef").field("syntax", &self.syntax).finish()
4938    }
4939}
4940impl AstNode for MacroExpr {
4941    #[inline]
4942    fn kind() -> SyntaxKind
4943    where
4944        Self: Sized,
4945    {
4946        MACRO_EXPR
4947    }
4948    #[inline]
4949    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR }
4950    #[inline]
4951    fn cast(syntax: SyntaxNode) -> Option<Self> {
4952        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4953    }
4954    #[inline]
4955    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4956}
4957impl hash::Hash for MacroExpr {
4958    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4959}
4960impl Eq for MacroExpr {}
4961impl PartialEq for MacroExpr {
4962    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4963}
4964impl Clone for MacroExpr {
4965    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4966}
4967impl fmt::Debug for MacroExpr {
4968    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4969        f.debug_struct("MacroExpr").field("syntax", &self.syntax).finish()
4970    }
4971}
4972impl AstNode for MacroItems {
4973    #[inline]
4974    fn kind() -> SyntaxKind
4975    where
4976        Self: Sized,
4977    {
4978        MACRO_ITEMS
4979    }
4980    #[inline]
4981    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
4982    #[inline]
4983    fn cast(syntax: SyntaxNode) -> Option<Self> {
4984        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
4985    }
4986    #[inline]
4987    fn syntax(&self) -> &SyntaxNode { &self.syntax }
4988}
4989impl hash::Hash for MacroItems {
4990    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
4991}
4992impl Eq for MacroItems {}
4993impl PartialEq for MacroItems {
4994    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
4995}
4996impl Clone for MacroItems {
4997    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
4998}
4999impl fmt::Debug for MacroItems {
5000    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5001        f.debug_struct("MacroItems").field("syntax", &self.syntax).finish()
5002    }
5003}
5004impl AstNode for MacroPat {
5005    #[inline]
5006    fn kind() -> SyntaxKind
5007    where
5008        Self: Sized,
5009    {
5010        MACRO_PAT
5011    }
5012    #[inline]
5013    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
5014    #[inline]
5015    fn cast(syntax: SyntaxNode) -> Option<Self> {
5016        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5017    }
5018    #[inline]
5019    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5020}
5021impl hash::Hash for MacroPat {
5022    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5023}
5024impl Eq for MacroPat {}
5025impl PartialEq for MacroPat {
5026    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5027}
5028impl Clone for MacroPat {
5029    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5030}
5031impl fmt::Debug for MacroPat {
5032    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5033        f.debug_struct("MacroPat").field("syntax", &self.syntax).finish()
5034    }
5035}
5036impl AstNode for MacroRules {
5037    #[inline]
5038    fn kind() -> SyntaxKind
5039    where
5040        Self: Sized,
5041    {
5042        MACRO_RULES
5043    }
5044    #[inline]
5045    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
5046    #[inline]
5047    fn cast(syntax: SyntaxNode) -> Option<Self> {
5048        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5049    }
5050    #[inline]
5051    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5052}
5053impl hash::Hash for MacroRules {
5054    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5055}
5056impl Eq for MacroRules {}
5057impl PartialEq for MacroRules {
5058    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5059}
5060impl Clone for MacroRules {
5061    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5062}
5063impl fmt::Debug for MacroRules {
5064    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5065        f.debug_struct("MacroRules").field("syntax", &self.syntax).finish()
5066    }
5067}
5068impl AstNode for MacroStmts {
5069    #[inline]
5070    fn kind() -> SyntaxKind
5071    where
5072        Self: Sized,
5073    {
5074        MACRO_STMTS
5075    }
5076    #[inline]
5077    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
5078    #[inline]
5079    fn cast(syntax: SyntaxNode) -> Option<Self> {
5080        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5081    }
5082    #[inline]
5083    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5084}
5085impl hash::Hash for MacroStmts {
5086    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5087}
5088impl Eq for MacroStmts {}
5089impl PartialEq for MacroStmts {
5090    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5091}
5092impl Clone for MacroStmts {
5093    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5094}
5095impl fmt::Debug for MacroStmts {
5096    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5097        f.debug_struct("MacroStmts").field("syntax", &self.syntax).finish()
5098    }
5099}
5100impl AstNode for MacroType {
5101    #[inline]
5102    fn kind() -> SyntaxKind
5103    where
5104        Self: Sized,
5105    {
5106        MACRO_TYPE
5107    }
5108    #[inline]
5109    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE }
5110    #[inline]
5111    fn cast(syntax: SyntaxNode) -> Option<Self> {
5112        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5113    }
5114    #[inline]
5115    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5116}
5117impl hash::Hash for MacroType {
5118    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5119}
5120impl Eq for MacroType {}
5121impl PartialEq for MacroType {
5122    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5123}
5124impl Clone for MacroType {
5125    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5126}
5127impl fmt::Debug for MacroType {
5128    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5129        f.debug_struct("MacroType").field("syntax", &self.syntax).finish()
5130    }
5131}
5132impl AstNode for MatchArm {
5133    #[inline]
5134    fn kind() -> SyntaxKind
5135    where
5136        Self: Sized,
5137    {
5138        MATCH_ARM
5139    }
5140    #[inline]
5141    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
5142    #[inline]
5143    fn cast(syntax: SyntaxNode) -> Option<Self> {
5144        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5145    }
5146    #[inline]
5147    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5148}
5149impl hash::Hash for MatchArm {
5150    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5151}
5152impl Eq for MatchArm {}
5153impl PartialEq for MatchArm {
5154    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5155}
5156impl Clone for MatchArm {
5157    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5158}
5159impl fmt::Debug for MatchArm {
5160    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5161        f.debug_struct("MatchArm").field("syntax", &self.syntax).finish()
5162    }
5163}
5164impl AstNode for MatchArmList {
5165    #[inline]
5166    fn kind() -> SyntaxKind
5167    where
5168        Self: Sized,
5169    {
5170        MATCH_ARM_LIST
5171    }
5172    #[inline]
5173    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
5174    #[inline]
5175    fn cast(syntax: SyntaxNode) -> Option<Self> {
5176        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5177    }
5178    #[inline]
5179    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5180}
5181impl hash::Hash for MatchArmList {
5182    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5183}
5184impl Eq for MatchArmList {}
5185impl PartialEq for MatchArmList {
5186    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5187}
5188impl Clone for MatchArmList {
5189    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5190}
5191impl fmt::Debug for MatchArmList {
5192    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5193        f.debug_struct("MatchArmList").field("syntax", &self.syntax).finish()
5194    }
5195}
5196impl AstNode for MatchExpr {
5197    #[inline]
5198    fn kind() -> SyntaxKind
5199    where
5200        Self: Sized,
5201    {
5202        MATCH_EXPR
5203    }
5204    #[inline]
5205    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
5206    #[inline]
5207    fn cast(syntax: SyntaxNode) -> Option<Self> {
5208        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5209    }
5210    #[inline]
5211    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5212}
5213impl hash::Hash for MatchExpr {
5214    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5215}
5216impl Eq for MatchExpr {}
5217impl PartialEq for MatchExpr {
5218    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5219}
5220impl Clone for MatchExpr {
5221    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5222}
5223impl fmt::Debug for MatchExpr {
5224    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5225        f.debug_struct("MatchExpr").field("syntax", &self.syntax).finish()
5226    }
5227}
5228impl AstNode for MatchGuard {
5229    #[inline]
5230    fn kind() -> SyntaxKind
5231    where
5232        Self: Sized,
5233    {
5234        MATCH_GUARD
5235    }
5236    #[inline]
5237    fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
5238    #[inline]
5239    fn cast(syntax: SyntaxNode) -> Option<Self> {
5240        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5241    }
5242    #[inline]
5243    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5244}
5245impl hash::Hash for MatchGuard {
5246    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5247}
5248impl Eq for MatchGuard {}
5249impl PartialEq for MatchGuard {
5250    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5251}
5252impl Clone for MatchGuard {
5253    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5254}
5255impl fmt::Debug for MatchGuard {
5256    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5257        f.debug_struct("MatchGuard").field("syntax", &self.syntax).finish()
5258    }
5259}
5260impl AstNode for MethodCallExpr {
5261    #[inline]
5262    fn kind() -> SyntaxKind
5263    where
5264        Self: Sized,
5265    {
5266        METHOD_CALL_EXPR
5267    }
5268    #[inline]
5269    fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
5270    #[inline]
5271    fn cast(syntax: SyntaxNode) -> Option<Self> {
5272        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5273    }
5274    #[inline]
5275    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5276}
5277impl hash::Hash for MethodCallExpr {
5278    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5279}
5280impl Eq for MethodCallExpr {}
5281impl PartialEq for MethodCallExpr {
5282    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5283}
5284impl Clone for MethodCallExpr {
5285    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5286}
5287impl fmt::Debug for MethodCallExpr {
5288    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5289        f.debug_struct("MethodCallExpr").field("syntax", &self.syntax).finish()
5290    }
5291}
5292impl AstNode for Module {
5293    #[inline]
5294    fn kind() -> SyntaxKind
5295    where
5296        Self: Sized,
5297    {
5298        MODULE
5299    }
5300    #[inline]
5301    fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
5302    #[inline]
5303    fn cast(syntax: SyntaxNode) -> Option<Self> {
5304        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5305    }
5306    #[inline]
5307    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5308}
5309impl hash::Hash for Module {
5310    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5311}
5312impl Eq for Module {}
5313impl PartialEq for Module {
5314    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5315}
5316impl Clone for Module {
5317    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5318}
5319impl fmt::Debug for Module {
5320    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5321        f.debug_struct("Module").field("syntax", &self.syntax).finish()
5322    }
5323}
5324impl AstNode for MutRestriction {
5325    #[inline]
5326    fn kind() -> SyntaxKind
5327    where
5328        Self: Sized,
5329    {
5330        MUT_RESTRICTION
5331    }
5332    #[inline]
5333    fn can_cast(kind: SyntaxKind) -> bool { kind == MUT_RESTRICTION }
5334    #[inline]
5335    fn cast(syntax: SyntaxNode) -> Option<Self> {
5336        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5337    }
5338    #[inline]
5339    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5340}
5341impl hash::Hash for MutRestriction {
5342    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5343}
5344impl Eq for MutRestriction {}
5345impl PartialEq for MutRestriction {
5346    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5347}
5348impl Clone for MutRestriction {
5349    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5350}
5351impl fmt::Debug for MutRestriction {
5352    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5353        f.debug_struct("MutRestriction").field("syntax", &self.syntax).finish()
5354    }
5355}
5356impl AstNode for Name {
5357    #[inline]
5358    fn kind() -> SyntaxKind
5359    where
5360        Self: Sized,
5361    {
5362        NAME
5363    }
5364    #[inline]
5365    fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
5366    #[inline]
5367    fn cast(syntax: SyntaxNode) -> Option<Self> {
5368        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5369    }
5370    #[inline]
5371    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5372}
5373impl hash::Hash for Name {
5374    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5375}
5376impl Eq for Name {}
5377impl PartialEq for Name {
5378    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5379}
5380impl Clone for Name {
5381    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5382}
5383impl fmt::Debug for Name {
5384    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5385        f.debug_struct("Name").field("syntax", &self.syntax).finish()
5386    }
5387}
5388impl AstNode for NameRef {
5389    #[inline]
5390    fn kind() -> SyntaxKind
5391    where
5392        Self: Sized,
5393    {
5394        NAME_REF
5395    }
5396    #[inline]
5397    fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
5398    #[inline]
5399    fn cast(syntax: SyntaxNode) -> Option<Self> {
5400        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5401    }
5402    #[inline]
5403    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5404}
5405impl hash::Hash for NameRef {
5406    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5407}
5408impl Eq for NameRef {}
5409impl PartialEq for NameRef {
5410    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5411}
5412impl Clone for NameRef {
5413    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5414}
5415impl fmt::Debug for NameRef {
5416    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5417        f.debug_struct("NameRef").field("syntax", &self.syntax).finish()
5418    }
5419}
5420impl AstNode for NeverType {
5421    #[inline]
5422    fn kind() -> SyntaxKind
5423    where
5424        Self: Sized,
5425    {
5426        NEVER_TYPE
5427    }
5428    #[inline]
5429    fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
5430    #[inline]
5431    fn cast(syntax: SyntaxNode) -> Option<Self> {
5432        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5433    }
5434    #[inline]
5435    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5436}
5437impl hash::Hash for NeverType {
5438    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5439}
5440impl Eq for NeverType {}
5441impl PartialEq for NeverType {
5442    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5443}
5444impl Clone for NeverType {
5445    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5446}
5447impl fmt::Debug for NeverType {
5448    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5449        f.debug_struct("NeverType").field("syntax", &self.syntax).finish()
5450    }
5451}
5452impl AstNode for NotNull {
5453    #[inline]
5454    fn kind() -> SyntaxKind
5455    where
5456        Self: Sized,
5457    {
5458        NOT_NULL
5459    }
5460    #[inline]
5461    fn can_cast(kind: SyntaxKind) -> bool { kind == NOT_NULL }
5462    #[inline]
5463    fn cast(syntax: SyntaxNode) -> Option<Self> {
5464        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5465    }
5466    #[inline]
5467    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5468}
5469impl hash::Hash for NotNull {
5470    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5471}
5472impl Eq for NotNull {}
5473impl PartialEq for NotNull {
5474    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5475}
5476impl Clone for NotNull {
5477    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5478}
5479impl fmt::Debug for NotNull {
5480    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5481        f.debug_struct("NotNull").field("syntax", &self.syntax).finish()
5482    }
5483}
5484impl AstNode for OffsetOfExpr {
5485    #[inline]
5486    fn kind() -> SyntaxKind
5487    where
5488        Self: Sized,
5489    {
5490        OFFSET_OF_EXPR
5491    }
5492    #[inline]
5493    fn can_cast(kind: SyntaxKind) -> bool { kind == OFFSET_OF_EXPR }
5494    #[inline]
5495    fn cast(syntax: SyntaxNode) -> Option<Self> {
5496        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5497    }
5498    #[inline]
5499    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5500}
5501impl hash::Hash for OffsetOfExpr {
5502    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5503}
5504impl Eq for OffsetOfExpr {}
5505impl PartialEq for OffsetOfExpr {
5506    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5507}
5508impl Clone for OffsetOfExpr {
5509    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5510}
5511impl fmt::Debug for OffsetOfExpr {
5512    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5513        f.debug_struct("OffsetOfExpr").field("syntax", &self.syntax).finish()
5514    }
5515}
5516impl AstNode for OrPat {
5517    #[inline]
5518    fn kind() -> SyntaxKind
5519    where
5520        Self: Sized,
5521    {
5522        OR_PAT
5523    }
5524    #[inline]
5525    fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
5526    #[inline]
5527    fn cast(syntax: SyntaxNode) -> Option<Self> {
5528        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5529    }
5530    #[inline]
5531    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5532}
5533impl hash::Hash for OrPat {
5534    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5535}
5536impl Eq for OrPat {}
5537impl PartialEq for OrPat {
5538    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5539}
5540impl Clone for OrPat {
5541    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5542}
5543impl fmt::Debug for OrPat {
5544    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5545        f.debug_struct("OrPat").field("syntax", &self.syntax).finish()
5546    }
5547}
5548impl AstNode for Param {
5549    #[inline]
5550    fn kind() -> SyntaxKind
5551    where
5552        Self: Sized,
5553    {
5554        PARAM
5555    }
5556    #[inline]
5557    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
5558    #[inline]
5559    fn cast(syntax: SyntaxNode) -> Option<Self> {
5560        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5561    }
5562    #[inline]
5563    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5564}
5565impl hash::Hash for Param {
5566    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5567}
5568impl Eq for Param {}
5569impl PartialEq for Param {
5570    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5571}
5572impl Clone for Param {
5573    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5574}
5575impl fmt::Debug for Param {
5576    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5577        f.debug_struct("Param").field("syntax", &self.syntax).finish()
5578    }
5579}
5580impl AstNode for ParamList {
5581    #[inline]
5582    fn kind() -> SyntaxKind
5583    where
5584        Self: Sized,
5585    {
5586        PARAM_LIST
5587    }
5588    #[inline]
5589    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
5590    #[inline]
5591    fn cast(syntax: SyntaxNode) -> Option<Self> {
5592        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5593    }
5594    #[inline]
5595    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5596}
5597impl hash::Hash for ParamList {
5598    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5599}
5600impl Eq for ParamList {}
5601impl PartialEq for ParamList {
5602    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5603}
5604impl Clone for ParamList {
5605    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5606}
5607impl fmt::Debug for ParamList {
5608    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5609        f.debug_struct("ParamList").field("syntax", &self.syntax).finish()
5610    }
5611}
5612impl AstNode for ParenExpr {
5613    #[inline]
5614    fn kind() -> SyntaxKind
5615    where
5616        Self: Sized,
5617    {
5618        PAREN_EXPR
5619    }
5620    #[inline]
5621    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
5622    #[inline]
5623    fn cast(syntax: SyntaxNode) -> Option<Self> {
5624        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5625    }
5626    #[inline]
5627    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5628}
5629impl hash::Hash for ParenExpr {
5630    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5631}
5632impl Eq for ParenExpr {}
5633impl PartialEq for ParenExpr {
5634    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5635}
5636impl Clone for ParenExpr {
5637    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5638}
5639impl fmt::Debug for ParenExpr {
5640    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5641        f.debug_struct("ParenExpr").field("syntax", &self.syntax).finish()
5642    }
5643}
5644impl AstNode for ParenPat {
5645    #[inline]
5646    fn kind() -> SyntaxKind
5647    where
5648        Self: Sized,
5649    {
5650        PAREN_PAT
5651    }
5652    #[inline]
5653    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
5654    #[inline]
5655    fn cast(syntax: SyntaxNode) -> Option<Self> {
5656        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5657    }
5658    #[inline]
5659    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5660}
5661impl hash::Hash for ParenPat {
5662    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5663}
5664impl Eq for ParenPat {}
5665impl PartialEq for ParenPat {
5666    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5667}
5668impl Clone for ParenPat {
5669    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5670}
5671impl fmt::Debug for ParenPat {
5672    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5673        f.debug_struct("ParenPat").field("syntax", &self.syntax).finish()
5674    }
5675}
5676impl AstNode for ParenType {
5677    #[inline]
5678    fn kind() -> SyntaxKind
5679    where
5680        Self: Sized,
5681    {
5682        PAREN_TYPE
5683    }
5684    #[inline]
5685    fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
5686    #[inline]
5687    fn cast(syntax: SyntaxNode) -> Option<Self> {
5688        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5689    }
5690    #[inline]
5691    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5692}
5693impl hash::Hash for ParenType {
5694    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5695}
5696impl Eq for ParenType {}
5697impl PartialEq for ParenType {
5698    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5699}
5700impl Clone for ParenType {
5701    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5702}
5703impl fmt::Debug for ParenType {
5704    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5705        f.debug_struct("ParenType").field("syntax", &self.syntax).finish()
5706    }
5707}
5708impl AstNode for ParenthesizedArgList {
5709    #[inline]
5710    fn kind() -> SyntaxKind
5711    where
5712        Self: Sized,
5713    {
5714        PARENTHESIZED_ARG_LIST
5715    }
5716    #[inline]
5717    fn can_cast(kind: SyntaxKind) -> bool { kind == PARENTHESIZED_ARG_LIST }
5718    #[inline]
5719    fn cast(syntax: SyntaxNode) -> Option<Self> {
5720        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5721    }
5722    #[inline]
5723    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5724}
5725impl hash::Hash for ParenthesizedArgList {
5726    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5727}
5728impl Eq for ParenthesizedArgList {}
5729impl PartialEq for ParenthesizedArgList {
5730    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5731}
5732impl Clone for ParenthesizedArgList {
5733    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5734}
5735impl fmt::Debug for ParenthesizedArgList {
5736    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5737        f.debug_struct("ParenthesizedArgList").field("syntax", &self.syntax).finish()
5738    }
5739}
5740impl AstNode for Path {
5741    #[inline]
5742    fn kind() -> SyntaxKind
5743    where
5744        Self: Sized,
5745    {
5746        PATH
5747    }
5748    #[inline]
5749    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
5750    #[inline]
5751    fn cast(syntax: SyntaxNode) -> Option<Self> {
5752        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5753    }
5754    #[inline]
5755    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5756}
5757impl hash::Hash for Path {
5758    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5759}
5760impl Eq for Path {}
5761impl PartialEq for Path {
5762    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5763}
5764impl Clone for Path {
5765    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5766}
5767impl fmt::Debug for Path {
5768    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5769        f.debug_struct("Path").field("syntax", &self.syntax).finish()
5770    }
5771}
5772impl AstNode for PathExpr {
5773    #[inline]
5774    fn kind() -> SyntaxKind
5775    where
5776        Self: Sized,
5777    {
5778        PATH_EXPR
5779    }
5780    #[inline]
5781    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
5782    #[inline]
5783    fn cast(syntax: SyntaxNode) -> Option<Self> {
5784        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5785    }
5786    #[inline]
5787    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5788}
5789impl hash::Hash for PathExpr {
5790    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5791}
5792impl Eq for PathExpr {}
5793impl PartialEq for PathExpr {
5794    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5795}
5796impl Clone for PathExpr {
5797    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5798}
5799impl fmt::Debug for PathExpr {
5800    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5801        f.debug_struct("PathExpr").field("syntax", &self.syntax).finish()
5802    }
5803}
5804impl AstNode for PathMeta {
5805    #[inline]
5806    fn kind() -> SyntaxKind
5807    where
5808        Self: Sized,
5809    {
5810        PATH_META
5811    }
5812    #[inline]
5813    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_META }
5814    #[inline]
5815    fn cast(syntax: SyntaxNode) -> Option<Self> {
5816        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5817    }
5818    #[inline]
5819    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5820}
5821impl hash::Hash for PathMeta {
5822    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5823}
5824impl Eq for PathMeta {}
5825impl PartialEq for PathMeta {
5826    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5827}
5828impl Clone for PathMeta {
5829    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5830}
5831impl fmt::Debug for PathMeta {
5832    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5833        f.debug_struct("PathMeta").field("syntax", &self.syntax).finish()
5834    }
5835}
5836impl AstNode for PathPat {
5837    #[inline]
5838    fn kind() -> SyntaxKind
5839    where
5840        Self: Sized,
5841    {
5842        PATH_PAT
5843    }
5844    #[inline]
5845    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
5846    #[inline]
5847    fn cast(syntax: SyntaxNode) -> Option<Self> {
5848        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5849    }
5850    #[inline]
5851    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5852}
5853impl hash::Hash for PathPat {
5854    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5855}
5856impl Eq for PathPat {}
5857impl PartialEq for PathPat {
5858    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5859}
5860impl Clone for PathPat {
5861    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5862}
5863impl fmt::Debug for PathPat {
5864    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5865        f.debug_struct("PathPat").field("syntax", &self.syntax).finish()
5866    }
5867}
5868impl AstNode for PathSegment {
5869    #[inline]
5870    fn kind() -> SyntaxKind
5871    where
5872        Self: Sized,
5873    {
5874        PATH_SEGMENT
5875    }
5876    #[inline]
5877    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
5878    #[inline]
5879    fn cast(syntax: SyntaxNode) -> Option<Self> {
5880        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5881    }
5882    #[inline]
5883    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5884}
5885impl hash::Hash for PathSegment {
5886    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5887}
5888impl Eq for PathSegment {}
5889impl PartialEq for PathSegment {
5890    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5891}
5892impl Clone for PathSegment {
5893    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5894}
5895impl fmt::Debug for PathSegment {
5896    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5897        f.debug_struct("PathSegment").field("syntax", &self.syntax).finish()
5898    }
5899}
5900impl AstNode for PathType {
5901    #[inline]
5902    fn kind() -> SyntaxKind
5903    where
5904        Self: Sized,
5905    {
5906        PATH_TYPE
5907    }
5908    #[inline]
5909    fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
5910    #[inline]
5911    fn cast(syntax: SyntaxNode) -> Option<Self> {
5912        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5913    }
5914    #[inline]
5915    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5916}
5917impl hash::Hash for PathType {
5918    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5919}
5920impl Eq for PathType {}
5921impl PartialEq for PathType {
5922    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5923}
5924impl Clone for PathType {
5925    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5926}
5927impl fmt::Debug for PathType {
5928    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5929        f.debug_struct("PathType").field("syntax", &self.syntax).finish()
5930    }
5931}
5932impl AstNode for PatternType {
5933    #[inline]
5934    fn kind() -> SyntaxKind
5935    where
5936        Self: Sized,
5937    {
5938        PATTERN_TYPE
5939    }
5940    #[inline]
5941    fn can_cast(kind: SyntaxKind) -> bool { kind == PATTERN_TYPE }
5942    #[inline]
5943    fn cast(syntax: SyntaxNode) -> Option<Self> {
5944        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5945    }
5946    #[inline]
5947    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5948}
5949impl hash::Hash for PatternType {
5950    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5951}
5952impl Eq for PatternType {}
5953impl PartialEq for PatternType {
5954    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5955}
5956impl Clone for PatternType {
5957    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5958}
5959impl fmt::Debug for PatternType {
5960    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5961        f.debug_struct("PatternType").field("syntax", &self.syntax).finish()
5962    }
5963}
5964impl AstNode for PrefixExpr {
5965    #[inline]
5966    fn kind() -> SyntaxKind
5967    where
5968        Self: Sized,
5969    {
5970        PREFIX_EXPR
5971    }
5972    #[inline]
5973    fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
5974    #[inline]
5975    fn cast(syntax: SyntaxNode) -> Option<Self> {
5976        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
5977    }
5978    #[inline]
5979    fn syntax(&self) -> &SyntaxNode { &self.syntax }
5980}
5981impl hash::Hash for PrefixExpr {
5982    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
5983}
5984impl Eq for PrefixExpr {}
5985impl PartialEq for PrefixExpr {
5986    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
5987}
5988impl Clone for PrefixExpr {
5989    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
5990}
5991impl fmt::Debug for PrefixExpr {
5992    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5993        f.debug_struct("PrefixExpr").field("syntax", &self.syntax).finish()
5994    }
5995}
5996impl AstNode for PtrType {
5997    #[inline]
5998    fn kind() -> SyntaxKind
5999    where
6000        Self: Sized,
6001    {
6002        PTR_TYPE
6003    }
6004    #[inline]
6005    fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
6006    #[inline]
6007    fn cast(syntax: SyntaxNode) -> Option<Self> {
6008        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6009    }
6010    #[inline]
6011    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6012}
6013impl hash::Hash for PtrType {
6014    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6015}
6016impl Eq for PtrType {}
6017impl PartialEq for PtrType {
6018    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6019}
6020impl Clone for PtrType {
6021    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6022}
6023impl fmt::Debug for PtrType {
6024    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6025        f.debug_struct("PtrType").field("syntax", &self.syntax).finish()
6026    }
6027}
6028impl AstNode for RangeExpr {
6029    #[inline]
6030    fn kind() -> SyntaxKind
6031    where
6032        Self: Sized,
6033    {
6034        RANGE_EXPR
6035    }
6036    #[inline]
6037    fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
6038    #[inline]
6039    fn cast(syntax: SyntaxNode) -> Option<Self> {
6040        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6041    }
6042    #[inline]
6043    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6044}
6045impl hash::Hash for RangeExpr {
6046    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6047}
6048impl Eq for RangeExpr {}
6049impl PartialEq for RangeExpr {
6050    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6051}
6052impl Clone for RangeExpr {
6053    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6054}
6055impl fmt::Debug for RangeExpr {
6056    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6057        f.debug_struct("RangeExpr").field("syntax", &self.syntax).finish()
6058    }
6059}
6060impl AstNode for RangePat {
6061    #[inline]
6062    fn kind() -> SyntaxKind
6063    where
6064        Self: Sized,
6065    {
6066        RANGE_PAT
6067    }
6068    #[inline]
6069    fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
6070    #[inline]
6071    fn cast(syntax: SyntaxNode) -> Option<Self> {
6072        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6073    }
6074    #[inline]
6075    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6076}
6077impl hash::Hash for RangePat {
6078    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6079}
6080impl Eq for RangePat {}
6081impl PartialEq for RangePat {
6082    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6083}
6084impl Clone for RangePat {
6085    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6086}
6087impl fmt::Debug for RangePat {
6088    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6089        f.debug_struct("RangePat").field("syntax", &self.syntax).finish()
6090    }
6091}
6092impl AstNode for RecordExpr {
6093    #[inline]
6094    fn kind() -> SyntaxKind
6095    where
6096        Self: Sized,
6097    {
6098        RECORD_EXPR
6099    }
6100    #[inline]
6101    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
6102    #[inline]
6103    fn cast(syntax: SyntaxNode) -> Option<Self> {
6104        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6105    }
6106    #[inline]
6107    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6108}
6109impl hash::Hash for RecordExpr {
6110    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6111}
6112impl Eq for RecordExpr {}
6113impl PartialEq for RecordExpr {
6114    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6115}
6116impl Clone for RecordExpr {
6117    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6118}
6119impl fmt::Debug for RecordExpr {
6120    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6121        f.debug_struct("RecordExpr").field("syntax", &self.syntax).finish()
6122    }
6123}
6124impl AstNode for RecordExprField {
6125    #[inline]
6126    fn kind() -> SyntaxKind
6127    where
6128        Self: Sized,
6129    {
6130        RECORD_EXPR_FIELD
6131    }
6132    #[inline]
6133    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
6134    #[inline]
6135    fn cast(syntax: SyntaxNode) -> Option<Self> {
6136        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6137    }
6138    #[inline]
6139    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6140}
6141impl hash::Hash for RecordExprField {
6142    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6143}
6144impl Eq for RecordExprField {}
6145impl PartialEq for RecordExprField {
6146    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6147}
6148impl Clone for RecordExprField {
6149    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6150}
6151impl fmt::Debug for RecordExprField {
6152    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6153        f.debug_struct("RecordExprField").field("syntax", &self.syntax).finish()
6154    }
6155}
6156impl AstNode for RecordExprFieldList {
6157    #[inline]
6158    fn kind() -> SyntaxKind
6159    where
6160        Self: Sized,
6161    {
6162        RECORD_EXPR_FIELD_LIST
6163    }
6164    #[inline]
6165    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
6166    #[inline]
6167    fn cast(syntax: SyntaxNode) -> Option<Self> {
6168        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6169    }
6170    #[inline]
6171    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6172}
6173impl hash::Hash for RecordExprFieldList {
6174    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6175}
6176impl Eq for RecordExprFieldList {}
6177impl PartialEq for RecordExprFieldList {
6178    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6179}
6180impl Clone for RecordExprFieldList {
6181    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6182}
6183impl fmt::Debug for RecordExprFieldList {
6184    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6185        f.debug_struct("RecordExprFieldList").field("syntax", &self.syntax).finish()
6186    }
6187}
6188impl AstNode for RecordField {
6189    #[inline]
6190    fn kind() -> SyntaxKind
6191    where
6192        Self: Sized,
6193    {
6194        RECORD_FIELD
6195    }
6196    #[inline]
6197    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
6198    #[inline]
6199    fn cast(syntax: SyntaxNode) -> Option<Self> {
6200        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6201    }
6202    #[inline]
6203    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6204}
6205impl hash::Hash for RecordField {
6206    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6207}
6208impl Eq for RecordField {}
6209impl PartialEq for RecordField {
6210    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6211}
6212impl Clone for RecordField {
6213    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6214}
6215impl fmt::Debug for RecordField {
6216    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6217        f.debug_struct("RecordField").field("syntax", &self.syntax).finish()
6218    }
6219}
6220impl AstNode for RecordFieldList {
6221    #[inline]
6222    fn kind() -> SyntaxKind
6223    where
6224        Self: Sized,
6225    {
6226        RECORD_FIELD_LIST
6227    }
6228    #[inline]
6229    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
6230    #[inline]
6231    fn cast(syntax: SyntaxNode) -> Option<Self> {
6232        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6233    }
6234    #[inline]
6235    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6236}
6237impl hash::Hash for RecordFieldList {
6238    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6239}
6240impl Eq for RecordFieldList {}
6241impl PartialEq for RecordFieldList {
6242    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6243}
6244impl Clone for RecordFieldList {
6245    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6246}
6247impl fmt::Debug for RecordFieldList {
6248    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6249        f.debug_struct("RecordFieldList").field("syntax", &self.syntax).finish()
6250    }
6251}
6252impl AstNode for RecordPat {
6253    #[inline]
6254    fn kind() -> SyntaxKind
6255    where
6256        Self: Sized,
6257    {
6258        RECORD_PAT
6259    }
6260    #[inline]
6261    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
6262    #[inline]
6263    fn cast(syntax: SyntaxNode) -> Option<Self> {
6264        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6265    }
6266    #[inline]
6267    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6268}
6269impl hash::Hash for RecordPat {
6270    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6271}
6272impl Eq for RecordPat {}
6273impl PartialEq for RecordPat {
6274    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6275}
6276impl Clone for RecordPat {
6277    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6278}
6279impl fmt::Debug for RecordPat {
6280    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6281        f.debug_struct("RecordPat").field("syntax", &self.syntax).finish()
6282    }
6283}
6284impl AstNode for RecordPatField {
6285    #[inline]
6286    fn kind() -> SyntaxKind
6287    where
6288        Self: Sized,
6289    {
6290        RECORD_PAT_FIELD
6291    }
6292    #[inline]
6293    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
6294    #[inline]
6295    fn cast(syntax: SyntaxNode) -> Option<Self> {
6296        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6297    }
6298    #[inline]
6299    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6300}
6301impl hash::Hash for RecordPatField {
6302    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6303}
6304impl Eq for RecordPatField {}
6305impl PartialEq for RecordPatField {
6306    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6307}
6308impl Clone for RecordPatField {
6309    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6310}
6311impl fmt::Debug for RecordPatField {
6312    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6313        f.debug_struct("RecordPatField").field("syntax", &self.syntax).finish()
6314    }
6315}
6316impl AstNode for RecordPatFieldList {
6317    #[inline]
6318    fn kind() -> SyntaxKind
6319    where
6320        Self: Sized,
6321    {
6322        RECORD_PAT_FIELD_LIST
6323    }
6324    #[inline]
6325    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
6326    #[inline]
6327    fn cast(syntax: SyntaxNode) -> Option<Self> {
6328        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6329    }
6330    #[inline]
6331    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6332}
6333impl hash::Hash for RecordPatFieldList {
6334    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6335}
6336impl Eq for RecordPatFieldList {}
6337impl PartialEq for RecordPatFieldList {
6338    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6339}
6340impl Clone for RecordPatFieldList {
6341    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6342}
6343impl fmt::Debug for RecordPatFieldList {
6344    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6345        f.debug_struct("RecordPatFieldList").field("syntax", &self.syntax).finish()
6346    }
6347}
6348impl AstNode for RefExpr {
6349    #[inline]
6350    fn kind() -> SyntaxKind
6351    where
6352        Self: Sized,
6353    {
6354        REF_EXPR
6355    }
6356    #[inline]
6357    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
6358    #[inline]
6359    fn cast(syntax: SyntaxNode) -> Option<Self> {
6360        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6361    }
6362    #[inline]
6363    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6364}
6365impl hash::Hash for RefExpr {
6366    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6367}
6368impl Eq for RefExpr {}
6369impl PartialEq for RefExpr {
6370    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6371}
6372impl Clone for RefExpr {
6373    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6374}
6375impl fmt::Debug for RefExpr {
6376    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6377        f.debug_struct("RefExpr").field("syntax", &self.syntax).finish()
6378    }
6379}
6380impl AstNode for RefPat {
6381    #[inline]
6382    fn kind() -> SyntaxKind
6383    where
6384        Self: Sized,
6385    {
6386        REF_PAT
6387    }
6388    #[inline]
6389    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
6390    #[inline]
6391    fn cast(syntax: SyntaxNode) -> Option<Self> {
6392        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6393    }
6394    #[inline]
6395    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6396}
6397impl hash::Hash for RefPat {
6398    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6399}
6400impl Eq for RefPat {}
6401impl PartialEq for RefPat {
6402    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6403}
6404impl Clone for RefPat {
6405    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6406}
6407impl fmt::Debug for RefPat {
6408    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6409        f.debug_struct("RefPat").field("syntax", &self.syntax).finish()
6410    }
6411}
6412impl AstNode for RefType {
6413    #[inline]
6414    fn kind() -> SyntaxKind
6415    where
6416        Self: Sized,
6417    {
6418        REF_TYPE
6419    }
6420    #[inline]
6421    fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
6422    #[inline]
6423    fn cast(syntax: SyntaxNode) -> Option<Self> {
6424        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6425    }
6426    #[inline]
6427    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6428}
6429impl hash::Hash for RefType {
6430    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6431}
6432impl Eq for RefType {}
6433impl PartialEq for RefType {
6434    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6435}
6436impl Clone for RefType {
6437    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6438}
6439impl fmt::Debug for RefType {
6440    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6441        f.debug_struct("RefType").field("syntax", &self.syntax).finish()
6442    }
6443}
6444impl AstNode for Rename {
6445    #[inline]
6446    fn kind() -> SyntaxKind
6447    where
6448        Self: Sized,
6449    {
6450        RENAME
6451    }
6452    #[inline]
6453    fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
6454    #[inline]
6455    fn cast(syntax: SyntaxNode) -> Option<Self> {
6456        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6457    }
6458    #[inline]
6459    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6460}
6461impl hash::Hash for Rename {
6462    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6463}
6464impl Eq for Rename {}
6465impl PartialEq for Rename {
6466    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6467}
6468impl Clone for Rename {
6469    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6470}
6471impl fmt::Debug for Rename {
6472    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6473        f.debug_struct("Rename").field("syntax", &self.syntax).finish()
6474    }
6475}
6476impl AstNode for RestPat {
6477    #[inline]
6478    fn kind() -> SyntaxKind
6479    where
6480        Self: Sized,
6481    {
6482        REST_PAT
6483    }
6484    #[inline]
6485    fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
6486    #[inline]
6487    fn cast(syntax: SyntaxNode) -> Option<Self> {
6488        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6489    }
6490    #[inline]
6491    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6492}
6493impl hash::Hash for RestPat {
6494    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6495}
6496impl Eq for RestPat {}
6497impl PartialEq for RestPat {
6498    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6499}
6500impl Clone for RestPat {
6501    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6502}
6503impl fmt::Debug for RestPat {
6504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6505        f.debug_struct("RestPat").field("syntax", &self.syntax).finish()
6506    }
6507}
6508impl AstNode for RetType {
6509    #[inline]
6510    fn kind() -> SyntaxKind
6511    where
6512        Self: Sized,
6513    {
6514        RET_TYPE
6515    }
6516    #[inline]
6517    fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
6518    #[inline]
6519    fn cast(syntax: SyntaxNode) -> Option<Self> {
6520        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6521    }
6522    #[inline]
6523    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6524}
6525impl hash::Hash for RetType {
6526    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6527}
6528impl Eq for RetType {}
6529impl PartialEq for RetType {
6530    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6531}
6532impl Clone for RetType {
6533    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6534}
6535impl fmt::Debug for RetType {
6536    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6537        f.debug_struct("RetType").field("syntax", &self.syntax).finish()
6538    }
6539}
6540impl AstNode for ReturnExpr {
6541    #[inline]
6542    fn kind() -> SyntaxKind
6543    where
6544        Self: Sized,
6545    {
6546        RETURN_EXPR
6547    }
6548    #[inline]
6549    fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
6550    #[inline]
6551    fn cast(syntax: SyntaxNode) -> Option<Self> {
6552        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6553    }
6554    #[inline]
6555    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6556}
6557impl hash::Hash for ReturnExpr {
6558    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6559}
6560impl Eq for ReturnExpr {}
6561impl PartialEq for ReturnExpr {
6562    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6563}
6564impl Clone for ReturnExpr {
6565    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6566}
6567impl fmt::Debug for ReturnExpr {
6568    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6569        f.debug_struct("ReturnExpr").field("syntax", &self.syntax).finish()
6570    }
6571}
6572impl AstNode for ReturnTypeSyntax {
6573    #[inline]
6574    fn kind() -> SyntaxKind
6575    where
6576        Self: Sized,
6577    {
6578        RETURN_TYPE_SYNTAX
6579    }
6580    #[inline]
6581    fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_TYPE_SYNTAX }
6582    #[inline]
6583    fn cast(syntax: SyntaxNode) -> Option<Self> {
6584        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6585    }
6586    #[inline]
6587    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6588}
6589impl hash::Hash for ReturnTypeSyntax {
6590    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6591}
6592impl Eq for ReturnTypeSyntax {}
6593impl PartialEq for ReturnTypeSyntax {
6594    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6595}
6596impl Clone for ReturnTypeSyntax {
6597    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6598}
6599impl fmt::Debug for ReturnTypeSyntax {
6600    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6601        f.debug_struct("ReturnTypeSyntax").field("syntax", &self.syntax).finish()
6602    }
6603}
6604impl AstNode for SelfParam {
6605    #[inline]
6606    fn kind() -> SyntaxKind
6607    where
6608        Self: Sized,
6609    {
6610        SELF_PARAM
6611    }
6612    #[inline]
6613    fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
6614    #[inline]
6615    fn cast(syntax: SyntaxNode) -> Option<Self> {
6616        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6617    }
6618    #[inline]
6619    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6620}
6621impl hash::Hash for SelfParam {
6622    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6623}
6624impl Eq for SelfParam {}
6625impl PartialEq for SelfParam {
6626    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6627}
6628impl Clone for SelfParam {
6629    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6630}
6631impl fmt::Debug for SelfParam {
6632    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6633        f.debug_struct("SelfParam").field("syntax", &self.syntax).finish()
6634    }
6635}
6636impl AstNode for SlicePat {
6637    #[inline]
6638    fn kind() -> SyntaxKind
6639    where
6640        Self: Sized,
6641    {
6642        SLICE_PAT
6643    }
6644    #[inline]
6645    fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
6646    #[inline]
6647    fn cast(syntax: SyntaxNode) -> Option<Self> {
6648        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6649    }
6650    #[inline]
6651    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6652}
6653impl hash::Hash for SlicePat {
6654    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6655}
6656impl Eq for SlicePat {}
6657impl PartialEq for SlicePat {
6658    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6659}
6660impl Clone for SlicePat {
6661    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6662}
6663impl fmt::Debug for SlicePat {
6664    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6665        f.debug_struct("SlicePat").field("syntax", &self.syntax).finish()
6666    }
6667}
6668impl AstNode for SliceType {
6669    #[inline]
6670    fn kind() -> SyntaxKind
6671    where
6672        Self: Sized,
6673    {
6674        SLICE_TYPE
6675    }
6676    #[inline]
6677    fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
6678    #[inline]
6679    fn cast(syntax: SyntaxNode) -> Option<Self> {
6680        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6681    }
6682    #[inline]
6683    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6684}
6685impl hash::Hash for SliceType {
6686    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6687}
6688impl Eq for SliceType {}
6689impl PartialEq for SliceType {
6690    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6691}
6692impl Clone for SliceType {
6693    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6694}
6695impl fmt::Debug for SliceType {
6696    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6697        f.debug_struct("SliceType").field("syntax", &self.syntax).finish()
6698    }
6699}
6700impl AstNode for SourceFile {
6701    #[inline]
6702    fn kind() -> SyntaxKind
6703    where
6704        Self: Sized,
6705    {
6706        SOURCE_FILE
6707    }
6708    #[inline]
6709    fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
6710    #[inline]
6711    fn cast(syntax: SyntaxNode) -> Option<Self> {
6712        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6713    }
6714    #[inline]
6715    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6716}
6717impl hash::Hash for SourceFile {
6718    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6719}
6720impl Eq for SourceFile {}
6721impl PartialEq for SourceFile {
6722    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6723}
6724impl Clone for SourceFile {
6725    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6726}
6727impl fmt::Debug for SourceFile {
6728    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6729        f.debug_struct("SourceFile").field("syntax", &self.syntax).finish()
6730    }
6731}
6732impl AstNode for Static {
6733    #[inline]
6734    fn kind() -> SyntaxKind
6735    where
6736        Self: Sized,
6737    {
6738        STATIC
6739    }
6740    #[inline]
6741    fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
6742    #[inline]
6743    fn cast(syntax: SyntaxNode) -> Option<Self> {
6744        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6745    }
6746    #[inline]
6747    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6748}
6749impl hash::Hash for Static {
6750    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6751}
6752impl Eq for Static {}
6753impl PartialEq for Static {
6754    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6755}
6756impl Clone for Static {
6757    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6758}
6759impl fmt::Debug for Static {
6760    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6761        f.debug_struct("Static").field("syntax", &self.syntax).finish()
6762    }
6763}
6764impl AstNode for StmtList {
6765    #[inline]
6766    fn kind() -> SyntaxKind
6767    where
6768        Self: Sized,
6769    {
6770        STMT_LIST
6771    }
6772    #[inline]
6773    fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST }
6774    #[inline]
6775    fn cast(syntax: SyntaxNode) -> Option<Self> {
6776        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6777    }
6778    #[inline]
6779    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6780}
6781impl hash::Hash for StmtList {
6782    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6783}
6784impl Eq for StmtList {}
6785impl PartialEq for StmtList {
6786    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6787}
6788impl Clone for StmtList {
6789    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6790}
6791impl fmt::Debug for StmtList {
6792    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6793        f.debug_struct("StmtList").field("syntax", &self.syntax).finish()
6794    }
6795}
6796impl AstNode for Struct {
6797    #[inline]
6798    fn kind() -> SyntaxKind
6799    where
6800        Self: Sized,
6801    {
6802        STRUCT
6803    }
6804    #[inline]
6805    fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
6806    #[inline]
6807    fn cast(syntax: SyntaxNode) -> Option<Self> {
6808        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6809    }
6810    #[inline]
6811    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6812}
6813impl hash::Hash for Struct {
6814    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6815}
6816impl Eq for Struct {}
6817impl PartialEq for Struct {
6818    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6819}
6820impl Clone for Struct {
6821    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6822}
6823impl fmt::Debug for Struct {
6824    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6825        f.debug_struct("Struct").field("syntax", &self.syntax).finish()
6826    }
6827}
6828impl AstNode for TokenTree {
6829    #[inline]
6830    fn kind() -> SyntaxKind
6831    where
6832        Self: Sized,
6833    {
6834        TOKEN_TREE
6835    }
6836    #[inline]
6837    fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
6838    #[inline]
6839    fn cast(syntax: SyntaxNode) -> Option<Self> {
6840        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6841    }
6842    #[inline]
6843    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6844}
6845impl hash::Hash for TokenTree {
6846    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6847}
6848impl Eq for TokenTree {}
6849impl PartialEq for TokenTree {
6850    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6851}
6852impl Clone for TokenTree {
6853    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6854}
6855impl fmt::Debug for TokenTree {
6856    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6857        f.debug_struct("TokenTree").field("syntax", &self.syntax).finish()
6858    }
6859}
6860impl AstNode for TokenTreeMeta {
6861    #[inline]
6862    fn kind() -> SyntaxKind
6863    where
6864        Self: Sized,
6865    {
6866        TOKEN_TREE_META
6867    }
6868    #[inline]
6869    fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE_META }
6870    #[inline]
6871    fn cast(syntax: SyntaxNode) -> Option<Self> {
6872        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6873    }
6874    #[inline]
6875    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6876}
6877impl hash::Hash for TokenTreeMeta {
6878    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6879}
6880impl Eq for TokenTreeMeta {}
6881impl PartialEq for TokenTreeMeta {
6882    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6883}
6884impl Clone for TokenTreeMeta {
6885    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6886}
6887impl fmt::Debug for TokenTreeMeta {
6888    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6889        f.debug_struct("TokenTreeMeta").field("syntax", &self.syntax).finish()
6890    }
6891}
6892impl AstNode for Trait {
6893    #[inline]
6894    fn kind() -> SyntaxKind
6895    where
6896        Self: Sized,
6897    {
6898        TRAIT
6899    }
6900    #[inline]
6901    fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
6902    #[inline]
6903    fn cast(syntax: SyntaxNode) -> Option<Self> {
6904        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6905    }
6906    #[inline]
6907    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6908}
6909impl hash::Hash for Trait {
6910    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6911}
6912impl Eq for Trait {}
6913impl PartialEq for Trait {
6914    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6915}
6916impl Clone for Trait {
6917    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6918}
6919impl fmt::Debug for Trait {
6920    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6921        f.debug_struct("Trait").field("syntax", &self.syntax).finish()
6922    }
6923}
6924impl AstNode for TryBlockModifier {
6925    #[inline]
6926    fn kind() -> SyntaxKind
6927    where
6928        Self: Sized,
6929    {
6930        TRY_BLOCK_MODIFIER
6931    }
6932    #[inline]
6933    fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_BLOCK_MODIFIER }
6934    #[inline]
6935    fn cast(syntax: SyntaxNode) -> Option<Self> {
6936        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6937    }
6938    #[inline]
6939    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6940}
6941impl hash::Hash for TryBlockModifier {
6942    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6943}
6944impl Eq for TryBlockModifier {}
6945impl PartialEq for TryBlockModifier {
6946    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6947}
6948impl Clone for TryBlockModifier {
6949    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6950}
6951impl fmt::Debug for TryBlockModifier {
6952    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6953        f.debug_struct("TryBlockModifier").field("syntax", &self.syntax).finish()
6954    }
6955}
6956impl AstNode for TryExpr {
6957    #[inline]
6958    fn kind() -> SyntaxKind
6959    where
6960        Self: Sized,
6961    {
6962        TRY_EXPR
6963    }
6964    #[inline]
6965    fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
6966    #[inline]
6967    fn cast(syntax: SyntaxNode) -> Option<Self> {
6968        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
6969    }
6970    #[inline]
6971    fn syntax(&self) -> &SyntaxNode { &self.syntax }
6972}
6973impl hash::Hash for TryExpr {
6974    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
6975}
6976impl Eq for TryExpr {}
6977impl PartialEq for TryExpr {
6978    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
6979}
6980impl Clone for TryExpr {
6981    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
6982}
6983impl fmt::Debug for TryExpr {
6984    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6985        f.debug_struct("TryExpr").field("syntax", &self.syntax).finish()
6986    }
6987}
6988impl AstNode for TupleExpr {
6989    #[inline]
6990    fn kind() -> SyntaxKind
6991    where
6992        Self: Sized,
6993    {
6994        TUPLE_EXPR
6995    }
6996    #[inline]
6997    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
6998    #[inline]
6999    fn cast(syntax: SyntaxNode) -> Option<Self> {
7000        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7001    }
7002    #[inline]
7003    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7004}
7005impl hash::Hash for TupleExpr {
7006    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7007}
7008impl Eq for TupleExpr {}
7009impl PartialEq for TupleExpr {
7010    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7011}
7012impl Clone for TupleExpr {
7013    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7014}
7015impl fmt::Debug for TupleExpr {
7016    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7017        f.debug_struct("TupleExpr").field("syntax", &self.syntax).finish()
7018    }
7019}
7020impl AstNode for TupleField {
7021    #[inline]
7022    fn kind() -> SyntaxKind
7023    where
7024        Self: Sized,
7025    {
7026        TUPLE_FIELD
7027    }
7028    #[inline]
7029    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
7030    #[inline]
7031    fn cast(syntax: SyntaxNode) -> Option<Self> {
7032        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7033    }
7034    #[inline]
7035    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7036}
7037impl hash::Hash for TupleField {
7038    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7039}
7040impl Eq for TupleField {}
7041impl PartialEq for TupleField {
7042    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7043}
7044impl Clone for TupleField {
7045    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7046}
7047impl fmt::Debug for TupleField {
7048    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7049        f.debug_struct("TupleField").field("syntax", &self.syntax).finish()
7050    }
7051}
7052impl AstNode for TupleFieldList {
7053    #[inline]
7054    fn kind() -> SyntaxKind
7055    where
7056        Self: Sized,
7057    {
7058        TUPLE_FIELD_LIST
7059    }
7060    #[inline]
7061    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
7062    #[inline]
7063    fn cast(syntax: SyntaxNode) -> Option<Self> {
7064        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7065    }
7066    #[inline]
7067    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7068}
7069impl hash::Hash for TupleFieldList {
7070    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7071}
7072impl Eq for TupleFieldList {}
7073impl PartialEq for TupleFieldList {
7074    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7075}
7076impl Clone for TupleFieldList {
7077    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7078}
7079impl fmt::Debug for TupleFieldList {
7080    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7081        f.debug_struct("TupleFieldList").field("syntax", &self.syntax).finish()
7082    }
7083}
7084impl AstNode for TuplePat {
7085    #[inline]
7086    fn kind() -> SyntaxKind
7087    where
7088        Self: Sized,
7089    {
7090        TUPLE_PAT
7091    }
7092    #[inline]
7093    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
7094    #[inline]
7095    fn cast(syntax: SyntaxNode) -> Option<Self> {
7096        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7097    }
7098    #[inline]
7099    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7100}
7101impl hash::Hash for TuplePat {
7102    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7103}
7104impl Eq for TuplePat {}
7105impl PartialEq for TuplePat {
7106    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7107}
7108impl Clone for TuplePat {
7109    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7110}
7111impl fmt::Debug for TuplePat {
7112    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7113        f.debug_struct("TuplePat").field("syntax", &self.syntax).finish()
7114    }
7115}
7116impl AstNode for TupleStructPat {
7117    #[inline]
7118    fn kind() -> SyntaxKind
7119    where
7120        Self: Sized,
7121    {
7122        TUPLE_STRUCT_PAT
7123    }
7124    #[inline]
7125    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
7126    #[inline]
7127    fn cast(syntax: SyntaxNode) -> Option<Self> {
7128        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7129    }
7130    #[inline]
7131    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7132}
7133impl hash::Hash for TupleStructPat {
7134    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7135}
7136impl Eq for TupleStructPat {}
7137impl PartialEq for TupleStructPat {
7138    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7139}
7140impl Clone for TupleStructPat {
7141    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7142}
7143impl fmt::Debug for TupleStructPat {
7144    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7145        f.debug_struct("TupleStructPat").field("syntax", &self.syntax).finish()
7146    }
7147}
7148impl AstNode for TupleType {
7149    #[inline]
7150    fn kind() -> SyntaxKind
7151    where
7152        Self: Sized,
7153    {
7154        TUPLE_TYPE
7155    }
7156    #[inline]
7157    fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
7158    #[inline]
7159    fn cast(syntax: SyntaxNode) -> Option<Self> {
7160        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7161    }
7162    #[inline]
7163    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7164}
7165impl hash::Hash for TupleType {
7166    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7167}
7168impl Eq for TupleType {}
7169impl PartialEq for TupleType {
7170    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7171}
7172impl Clone for TupleType {
7173    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7174}
7175impl fmt::Debug for TupleType {
7176    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7177        f.debug_struct("TupleType").field("syntax", &self.syntax).finish()
7178    }
7179}
7180impl AstNode for TypeAlias {
7181    #[inline]
7182    fn kind() -> SyntaxKind
7183    where
7184        Self: Sized,
7185    {
7186        TYPE_ALIAS
7187    }
7188    #[inline]
7189    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
7190    #[inline]
7191    fn cast(syntax: SyntaxNode) -> Option<Self> {
7192        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7193    }
7194    #[inline]
7195    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7196}
7197impl hash::Hash for TypeAlias {
7198    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7199}
7200impl Eq for TypeAlias {}
7201impl PartialEq for TypeAlias {
7202    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7203}
7204impl Clone for TypeAlias {
7205    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7206}
7207impl fmt::Debug for TypeAlias {
7208    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7209        f.debug_struct("TypeAlias").field("syntax", &self.syntax).finish()
7210    }
7211}
7212impl AstNode for TypeAnchor {
7213    #[inline]
7214    fn kind() -> SyntaxKind
7215    where
7216        Self: Sized,
7217    {
7218        TYPE_ANCHOR
7219    }
7220    #[inline]
7221    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ANCHOR }
7222    #[inline]
7223    fn cast(syntax: SyntaxNode) -> Option<Self> {
7224        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7225    }
7226    #[inline]
7227    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7228}
7229impl hash::Hash for TypeAnchor {
7230    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7231}
7232impl Eq for TypeAnchor {}
7233impl PartialEq for TypeAnchor {
7234    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7235}
7236impl Clone for TypeAnchor {
7237    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7238}
7239impl fmt::Debug for TypeAnchor {
7240    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7241        f.debug_struct("TypeAnchor").field("syntax", &self.syntax).finish()
7242    }
7243}
7244impl AstNode for TypeArg {
7245    #[inline]
7246    fn kind() -> SyntaxKind
7247    where
7248        Self: Sized,
7249    {
7250        TYPE_ARG
7251    }
7252    #[inline]
7253    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
7254    #[inline]
7255    fn cast(syntax: SyntaxNode) -> Option<Self> {
7256        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7257    }
7258    #[inline]
7259    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7260}
7261impl hash::Hash for TypeArg {
7262    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7263}
7264impl Eq for TypeArg {}
7265impl PartialEq for TypeArg {
7266    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7267}
7268impl Clone for TypeArg {
7269    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7270}
7271impl fmt::Debug for TypeArg {
7272    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7273        f.debug_struct("TypeArg").field("syntax", &self.syntax).finish()
7274    }
7275}
7276impl AstNode for TypeBound {
7277    #[inline]
7278    fn kind() -> SyntaxKind
7279    where
7280        Self: Sized,
7281    {
7282        TYPE_BOUND
7283    }
7284    #[inline]
7285    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
7286    #[inline]
7287    fn cast(syntax: SyntaxNode) -> Option<Self> {
7288        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7289    }
7290    #[inline]
7291    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7292}
7293impl hash::Hash for TypeBound {
7294    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7295}
7296impl Eq for TypeBound {}
7297impl PartialEq for TypeBound {
7298    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7299}
7300impl Clone for TypeBound {
7301    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7302}
7303impl fmt::Debug for TypeBound {
7304    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7305        f.debug_struct("TypeBound").field("syntax", &self.syntax).finish()
7306    }
7307}
7308impl AstNode for TypeBoundList {
7309    #[inline]
7310    fn kind() -> SyntaxKind
7311    where
7312        Self: Sized,
7313    {
7314        TYPE_BOUND_LIST
7315    }
7316    #[inline]
7317    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
7318    #[inline]
7319    fn cast(syntax: SyntaxNode) -> Option<Self> {
7320        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7321    }
7322    #[inline]
7323    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7324}
7325impl hash::Hash for TypeBoundList {
7326    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7327}
7328impl Eq for TypeBoundList {}
7329impl PartialEq for TypeBoundList {
7330    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7331}
7332impl Clone for TypeBoundList {
7333    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7334}
7335impl fmt::Debug for TypeBoundList {
7336    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7337        f.debug_struct("TypeBoundList").field("syntax", &self.syntax).finish()
7338    }
7339}
7340impl AstNode for TypeParam {
7341    #[inline]
7342    fn kind() -> SyntaxKind
7343    where
7344        Self: Sized,
7345    {
7346        TYPE_PARAM
7347    }
7348    #[inline]
7349    fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
7350    #[inline]
7351    fn cast(syntax: SyntaxNode) -> Option<Self> {
7352        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7353    }
7354    #[inline]
7355    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7356}
7357impl hash::Hash for TypeParam {
7358    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7359}
7360impl Eq for TypeParam {}
7361impl PartialEq for TypeParam {
7362    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7363}
7364impl Clone for TypeParam {
7365    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7366}
7367impl fmt::Debug for TypeParam {
7368    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7369        f.debug_struct("TypeParam").field("syntax", &self.syntax).finish()
7370    }
7371}
7372impl AstNode for UnderscoreExpr {
7373    #[inline]
7374    fn kind() -> SyntaxKind
7375    where
7376        Self: Sized,
7377    {
7378        UNDERSCORE_EXPR
7379    }
7380    #[inline]
7381    fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR }
7382    #[inline]
7383    fn cast(syntax: SyntaxNode) -> Option<Self> {
7384        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7385    }
7386    #[inline]
7387    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7388}
7389impl hash::Hash for UnderscoreExpr {
7390    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7391}
7392impl Eq for UnderscoreExpr {}
7393impl PartialEq for UnderscoreExpr {
7394    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7395}
7396impl Clone for UnderscoreExpr {
7397    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7398}
7399impl fmt::Debug for UnderscoreExpr {
7400    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7401        f.debug_struct("UnderscoreExpr").field("syntax", &self.syntax).finish()
7402    }
7403}
7404impl AstNode for Union {
7405    #[inline]
7406    fn kind() -> SyntaxKind
7407    where
7408        Self: Sized,
7409    {
7410        UNION
7411    }
7412    #[inline]
7413    fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
7414    #[inline]
7415    fn cast(syntax: SyntaxNode) -> Option<Self> {
7416        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7417    }
7418    #[inline]
7419    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7420}
7421impl hash::Hash for Union {
7422    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7423}
7424impl Eq for Union {}
7425impl PartialEq for Union {
7426    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7427}
7428impl Clone for Union {
7429    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7430}
7431impl fmt::Debug for Union {
7432    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7433        f.debug_struct("Union").field("syntax", &self.syntax).finish()
7434    }
7435}
7436impl AstNode for UnsafeMeta {
7437    #[inline]
7438    fn kind() -> SyntaxKind
7439    where
7440        Self: Sized,
7441    {
7442        UNSAFE_META
7443    }
7444    #[inline]
7445    fn can_cast(kind: SyntaxKind) -> bool { kind == UNSAFE_META }
7446    #[inline]
7447    fn cast(syntax: SyntaxNode) -> Option<Self> {
7448        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7449    }
7450    #[inline]
7451    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7452}
7453impl hash::Hash for UnsafeMeta {
7454    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7455}
7456impl Eq for UnsafeMeta {}
7457impl PartialEq for UnsafeMeta {
7458    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7459}
7460impl Clone for UnsafeMeta {
7461    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7462}
7463impl fmt::Debug for UnsafeMeta {
7464    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7465        f.debug_struct("UnsafeMeta").field("syntax", &self.syntax).finish()
7466    }
7467}
7468impl AstNode for Use {
7469    #[inline]
7470    fn kind() -> SyntaxKind
7471    where
7472        Self: Sized,
7473    {
7474        USE
7475    }
7476    #[inline]
7477    fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
7478    #[inline]
7479    fn cast(syntax: SyntaxNode) -> Option<Self> {
7480        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7481    }
7482    #[inline]
7483    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7484}
7485impl hash::Hash for Use {
7486    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7487}
7488impl Eq for Use {}
7489impl PartialEq for Use {
7490    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7491}
7492impl Clone for Use {
7493    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7494}
7495impl fmt::Debug for Use {
7496    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7497        f.debug_struct("Use").field("syntax", &self.syntax).finish()
7498    }
7499}
7500impl AstNode for UseBoundGenericArgs {
7501    #[inline]
7502    fn kind() -> SyntaxKind
7503    where
7504        Self: Sized,
7505    {
7506        USE_BOUND_GENERIC_ARGS
7507    }
7508    #[inline]
7509    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_BOUND_GENERIC_ARGS }
7510    #[inline]
7511    fn cast(syntax: SyntaxNode) -> Option<Self> {
7512        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7513    }
7514    #[inline]
7515    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7516}
7517impl hash::Hash for UseBoundGenericArgs {
7518    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7519}
7520impl Eq for UseBoundGenericArgs {}
7521impl PartialEq for UseBoundGenericArgs {
7522    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7523}
7524impl Clone for UseBoundGenericArgs {
7525    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7526}
7527impl fmt::Debug for UseBoundGenericArgs {
7528    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7529        f.debug_struct("UseBoundGenericArgs").field("syntax", &self.syntax).finish()
7530    }
7531}
7532impl AstNode for UseTree {
7533    #[inline]
7534    fn kind() -> SyntaxKind
7535    where
7536        Self: Sized,
7537    {
7538        USE_TREE
7539    }
7540    #[inline]
7541    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
7542    #[inline]
7543    fn cast(syntax: SyntaxNode) -> Option<Self> {
7544        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7545    }
7546    #[inline]
7547    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7548}
7549impl hash::Hash for UseTree {
7550    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7551}
7552impl Eq for UseTree {}
7553impl PartialEq for UseTree {
7554    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7555}
7556impl Clone for UseTree {
7557    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7558}
7559impl fmt::Debug for UseTree {
7560    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7561        f.debug_struct("UseTree").field("syntax", &self.syntax).finish()
7562    }
7563}
7564impl AstNode for UseTreeList {
7565    #[inline]
7566    fn kind() -> SyntaxKind
7567    where
7568        Self: Sized,
7569    {
7570        USE_TREE_LIST
7571    }
7572    #[inline]
7573    fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
7574    #[inline]
7575    fn cast(syntax: SyntaxNode) -> Option<Self> {
7576        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7577    }
7578    #[inline]
7579    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7580}
7581impl hash::Hash for UseTreeList {
7582    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7583}
7584impl Eq for UseTreeList {}
7585impl PartialEq for UseTreeList {
7586    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7587}
7588impl Clone for UseTreeList {
7589    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7590}
7591impl fmt::Debug for UseTreeList {
7592    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7593        f.debug_struct("UseTreeList").field("syntax", &self.syntax).finish()
7594    }
7595}
7596impl AstNode for Variant {
7597    #[inline]
7598    fn kind() -> SyntaxKind
7599    where
7600        Self: Sized,
7601    {
7602        VARIANT
7603    }
7604    #[inline]
7605    fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
7606    #[inline]
7607    fn cast(syntax: SyntaxNode) -> Option<Self> {
7608        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7609    }
7610    #[inline]
7611    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7612}
7613impl hash::Hash for Variant {
7614    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7615}
7616impl Eq for Variant {}
7617impl PartialEq for Variant {
7618    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7619}
7620impl Clone for Variant {
7621    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7622}
7623impl fmt::Debug for Variant {
7624    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7625        f.debug_struct("Variant").field("syntax", &self.syntax).finish()
7626    }
7627}
7628impl AstNode for VariantList {
7629    #[inline]
7630    fn kind() -> SyntaxKind
7631    where
7632        Self: Sized,
7633    {
7634        VARIANT_LIST
7635    }
7636    #[inline]
7637    fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
7638    #[inline]
7639    fn cast(syntax: SyntaxNode) -> Option<Self> {
7640        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7641    }
7642    #[inline]
7643    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7644}
7645impl hash::Hash for VariantList {
7646    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7647}
7648impl Eq for VariantList {}
7649impl PartialEq for VariantList {
7650    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7651}
7652impl Clone for VariantList {
7653    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7654}
7655impl fmt::Debug for VariantList {
7656    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7657        f.debug_struct("VariantList").field("syntax", &self.syntax).finish()
7658    }
7659}
7660impl AstNode for Visibility {
7661    #[inline]
7662    fn kind() -> SyntaxKind
7663    where
7664        Self: Sized,
7665    {
7666        VISIBILITY
7667    }
7668    #[inline]
7669    fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
7670    #[inline]
7671    fn cast(syntax: SyntaxNode) -> Option<Self> {
7672        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7673    }
7674    #[inline]
7675    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7676}
7677impl hash::Hash for Visibility {
7678    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7679}
7680impl Eq for Visibility {}
7681impl PartialEq for Visibility {
7682    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7683}
7684impl Clone for Visibility {
7685    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7686}
7687impl fmt::Debug for Visibility {
7688    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7689        f.debug_struct("Visibility").field("syntax", &self.syntax).finish()
7690    }
7691}
7692impl AstNode for VisibilityInner {
7693    #[inline]
7694    fn kind() -> SyntaxKind
7695    where
7696        Self: Sized,
7697    {
7698        VISIBILITY_INNER
7699    }
7700    #[inline]
7701    fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY_INNER }
7702    #[inline]
7703    fn cast(syntax: SyntaxNode) -> Option<Self> {
7704        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7705    }
7706    #[inline]
7707    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7708}
7709impl hash::Hash for VisibilityInner {
7710    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7711}
7712impl Eq for VisibilityInner {}
7713impl PartialEq for VisibilityInner {
7714    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7715}
7716impl Clone for VisibilityInner {
7717    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7718}
7719impl fmt::Debug for VisibilityInner {
7720    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7721        f.debug_struct("VisibilityInner").field("syntax", &self.syntax).finish()
7722    }
7723}
7724impl AstNode for WhereClause {
7725    #[inline]
7726    fn kind() -> SyntaxKind
7727    where
7728        Self: Sized,
7729    {
7730        WHERE_CLAUSE
7731    }
7732    #[inline]
7733    fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
7734    #[inline]
7735    fn cast(syntax: SyntaxNode) -> Option<Self> {
7736        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7737    }
7738    #[inline]
7739    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7740}
7741impl hash::Hash for WhereClause {
7742    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7743}
7744impl Eq for WhereClause {}
7745impl PartialEq for WhereClause {
7746    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7747}
7748impl Clone for WhereClause {
7749    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7750}
7751impl fmt::Debug for WhereClause {
7752    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7753        f.debug_struct("WhereClause").field("syntax", &self.syntax).finish()
7754    }
7755}
7756impl AstNode for WherePred {
7757    #[inline]
7758    fn kind() -> SyntaxKind
7759    where
7760        Self: Sized,
7761    {
7762        WHERE_PRED
7763    }
7764    #[inline]
7765    fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
7766    #[inline]
7767    fn cast(syntax: SyntaxNode) -> Option<Self> {
7768        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7769    }
7770    #[inline]
7771    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7772}
7773impl hash::Hash for WherePred {
7774    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7775}
7776impl Eq for WherePred {}
7777impl PartialEq for WherePred {
7778    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7779}
7780impl Clone for WherePred {
7781    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7782}
7783impl fmt::Debug for WherePred {
7784    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7785        f.debug_struct("WherePred").field("syntax", &self.syntax).finish()
7786    }
7787}
7788impl AstNode for WhileExpr {
7789    #[inline]
7790    fn kind() -> SyntaxKind
7791    where
7792        Self: Sized,
7793    {
7794        WHILE_EXPR
7795    }
7796    #[inline]
7797    fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
7798    #[inline]
7799    fn cast(syntax: SyntaxNode) -> Option<Self> {
7800        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7801    }
7802    #[inline]
7803    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7804}
7805impl hash::Hash for WhileExpr {
7806    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7807}
7808impl Eq for WhileExpr {}
7809impl PartialEq for WhileExpr {
7810    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7811}
7812impl Clone for WhileExpr {
7813    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7814}
7815impl fmt::Debug for WhileExpr {
7816    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7817        f.debug_struct("WhileExpr").field("syntax", &self.syntax).finish()
7818    }
7819}
7820impl AstNode for WildcardPat {
7821    #[inline]
7822    fn kind() -> SyntaxKind
7823    where
7824        Self: Sized,
7825    {
7826        WILDCARD_PAT
7827    }
7828    #[inline]
7829    fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
7830    #[inline]
7831    fn cast(syntax: SyntaxNode) -> Option<Self> {
7832        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7833    }
7834    #[inline]
7835    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7836}
7837impl hash::Hash for WildcardPat {
7838    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7839}
7840impl Eq for WildcardPat {}
7841impl PartialEq for WildcardPat {
7842    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7843}
7844impl Clone for WildcardPat {
7845    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7846}
7847impl fmt::Debug for WildcardPat {
7848    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7849        f.debug_struct("WildcardPat").field("syntax", &self.syntax).finish()
7850    }
7851}
7852impl AstNode for YeetExpr {
7853    #[inline]
7854    fn kind() -> SyntaxKind
7855    where
7856        Self: Sized,
7857    {
7858        YEET_EXPR
7859    }
7860    #[inline]
7861    fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR }
7862    #[inline]
7863    fn cast(syntax: SyntaxNode) -> Option<Self> {
7864        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7865    }
7866    #[inline]
7867    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7868}
7869impl hash::Hash for YeetExpr {
7870    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7871}
7872impl Eq for YeetExpr {}
7873impl PartialEq for YeetExpr {
7874    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7875}
7876impl Clone for YeetExpr {
7877    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7878}
7879impl fmt::Debug for YeetExpr {
7880    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7881        f.debug_struct("YeetExpr").field("syntax", &self.syntax).finish()
7882    }
7883}
7884impl AstNode for YieldExpr {
7885    #[inline]
7886    fn kind() -> SyntaxKind
7887    where
7888        Self: Sized,
7889    {
7890        YIELD_EXPR
7891    }
7892    #[inline]
7893    fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR }
7894    #[inline]
7895    fn cast(syntax: SyntaxNode) -> Option<Self> {
7896        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
7897    }
7898    #[inline]
7899    fn syntax(&self) -> &SyntaxNode { &self.syntax }
7900}
7901impl hash::Hash for YieldExpr {
7902    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
7903}
7904impl Eq for YieldExpr {}
7905impl PartialEq for YieldExpr {
7906    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
7907}
7908impl Clone for YieldExpr {
7909    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
7910}
7911impl fmt::Debug for YieldExpr {
7912    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7913        f.debug_struct("YieldExpr").field("syntax", &self.syntax).finish()
7914    }
7915}
7916impl From<Enum> for Adt {
7917    #[inline]
7918    fn from(node: Enum) -> Adt { Adt::Enum(node) }
7919}
7920impl From<Struct> for Adt {
7921    #[inline]
7922    fn from(node: Struct) -> Adt { Adt::Struct(node) }
7923}
7924impl From<Union> for Adt {
7925    #[inline]
7926    fn from(node: Union) -> Adt { Adt::Union(node) }
7927}
7928impl AstNode for Adt {
7929    #[inline]
7930    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | STRUCT | UNION) }
7931    #[inline]
7932    fn cast(syntax: SyntaxNode) -> Option<Self> {
7933        let res = match syntax.kind() {
7934            ENUM => Adt::Enum(Enum { syntax }),
7935            STRUCT => Adt::Struct(Struct { syntax }),
7936            UNION => Adt::Union(Union { syntax }),
7937            _ => return None,
7938        };
7939        Some(res)
7940    }
7941    #[inline]
7942    fn syntax(&self) -> &SyntaxNode {
7943        match self {
7944            Adt::Enum(it) => &it.syntax,
7945            Adt::Struct(it) => &it.syntax,
7946            Adt::Union(it) => &it.syntax,
7947        }
7948    }
7949}
7950impl From<AsmConst> for AsmOperand {
7951    #[inline]
7952    fn from(node: AsmConst) -> AsmOperand { AsmOperand::AsmConst(node) }
7953}
7954impl From<AsmLabel> for AsmOperand {
7955    #[inline]
7956    fn from(node: AsmLabel) -> AsmOperand { AsmOperand::AsmLabel(node) }
7957}
7958impl From<AsmRegOperand> for AsmOperand {
7959    #[inline]
7960    fn from(node: AsmRegOperand) -> AsmOperand { AsmOperand::AsmRegOperand(node) }
7961}
7962impl From<AsmSym> for AsmOperand {
7963    #[inline]
7964    fn from(node: AsmSym) -> AsmOperand { AsmOperand::AsmSym(node) }
7965}
7966impl AstNode for AsmOperand {
7967    #[inline]
7968    fn can_cast(kind: SyntaxKind) -> bool {
7969        matches!(kind, ASM_CONST | ASM_LABEL | ASM_REG_OPERAND | ASM_SYM)
7970    }
7971    #[inline]
7972    fn cast(syntax: SyntaxNode) -> Option<Self> {
7973        let res = match syntax.kind() {
7974            ASM_CONST => AsmOperand::AsmConst(AsmConst { syntax }),
7975            ASM_LABEL => AsmOperand::AsmLabel(AsmLabel { syntax }),
7976            ASM_REG_OPERAND => AsmOperand::AsmRegOperand(AsmRegOperand { syntax }),
7977            ASM_SYM => AsmOperand::AsmSym(AsmSym { syntax }),
7978            _ => return None,
7979        };
7980        Some(res)
7981    }
7982    #[inline]
7983    fn syntax(&self) -> &SyntaxNode {
7984        match self {
7985            AsmOperand::AsmConst(it) => &it.syntax,
7986            AsmOperand::AsmLabel(it) => &it.syntax,
7987            AsmOperand::AsmRegOperand(it) => &it.syntax,
7988            AsmOperand::AsmSym(it) => &it.syntax,
7989        }
7990    }
7991}
7992impl From<AsmClobberAbi> for AsmPiece {
7993    #[inline]
7994    fn from(node: AsmClobberAbi) -> AsmPiece { AsmPiece::AsmClobberAbi(node) }
7995}
7996impl From<AsmOperandNamed> for AsmPiece {
7997    #[inline]
7998    fn from(node: AsmOperandNamed) -> AsmPiece { AsmPiece::AsmOperandNamed(node) }
7999}
8000impl From<AsmOptions> for AsmPiece {
8001    #[inline]
8002    fn from(node: AsmOptions) -> AsmPiece { AsmPiece::AsmOptions(node) }
8003}
8004impl AstNode for AsmPiece {
8005    #[inline]
8006    fn can_cast(kind: SyntaxKind) -> bool {
8007        matches!(kind, ASM_CLOBBER_ABI | ASM_OPERAND_NAMED | ASM_OPTIONS)
8008    }
8009    #[inline]
8010    fn cast(syntax: SyntaxNode) -> Option<Self> {
8011        let res = match syntax.kind() {
8012            ASM_CLOBBER_ABI => AsmPiece::AsmClobberAbi(AsmClobberAbi { syntax }),
8013            ASM_OPERAND_NAMED => AsmPiece::AsmOperandNamed(AsmOperandNamed { syntax }),
8014            ASM_OPTIONS => AsmPiece::AsmOptions(AsmOptions { syntax }),
8015            _ => return None,
8016        };
8017        Some(res)
8018    }
8019    #[inline]
8020    fn syntax(&self) -> &SyntaxNode {
8021        match self {
8022            AsmPiece::AsmClobberAbi(it) => &it.syntax,
8023            AsmPiece::AsmOperandNamed(it) => &it.syntax,
8024            AsmPiece::AsmOptions(it) => &it.syntax,
8025        }
8026    }
8027}
8028impl From<Const> for AssocItem {
8029    #[inline]
8030    fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
8031}
8032impl From<Fn> for AssocItem {
8033    #[inline]
8034    fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
8035}
8036impl From<MacroCall> for AssocItem {
8037    #[inline]
8038    fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
8039}
8040impl From<TypeAlias> for AssocItem {
8041    #[inline]
8042    fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
8043}
8044impl AstNode for AssocItem {
8045    #[inline]
8046    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST | FN | MACRO_CALL | TYPE_ALIAS) }
8047    #[inline]
8048    fn cast(syntax: SyntaxNode) -> Option<Self> {
8049        let res = match syntax.kind() {
8050            CONST => AssocItem::Const(Const { syntax }),
8051            FN => AssocItem::Fn(Fn { syntax }),
8052            MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
8053            TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
8054            _ => return None,
8055        };
8056        Some(res)
8057    }
8058    #[inline]
8059    fn syntax(&self) -> &SyntaxNode {
8060        match self {
8061            AssocItem::Const(it) => &it.syntax,
8062            AssocItem::Fn(it) => &it.syntax,
8063            AssocItem::MacroCall(it) => &it.syntax,
8064            AssocItem::TypeAlias(it) => &it.syntax,
8065        }
8066    }
8067}
8068impl From<CfgAtom> for CfgPredicate {
8069    #[inline]
8070    fn from(node: CfgAtom) -> CfgPredicate { CfgPredicate::CfgAtom(node) }
8071}
8072impl From<CfgComposite> for CfgPredicate {
8073    #[inline]
8074    fn from(node: CfgComposite) -> CfgPredicate { CfgPredicate::CfgComposite(node) }
8075}
8076impl AstNode for CfgPredicate {
8077    #[inline]
8078    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CFG_ATOM | CFG_COMPOSITE) }
8079    #[inline]
8080    fn cast(syntax: SyntaxNode) -> Option<Self> {
8081        let res = match syntax.kind() {
8082            CFG_ATOM => CfgPredicate::CfgAtom(CfgAtom { syntax }),
8083            CFG_COMPOSITE => CfgPredicate::CfgComposite(CfgComposite { syntax }),
8084            _ => return None,
8085        };
8086        Some(res)
8087    }
8088    #[inline]
8089    fn syntax(&self) -> &SyntaxNode {
8090        match self {
8091            CfgPredicate::CfgAtom(it) => &it.syntax,
8092            CfgPredicate::CfgComposite(it) => &it.syntax,
8093        }
8094    }
8095}
8096impl From<ArrayExpr> for Expr {
8097    #[inline]
8098    fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
8099}
8100impl From<AsmExpr> for Expr {
8101    #[inline]
8102    fn from(node: AsmExpr) -> Expr { Expr::AsmExpr(node) }
8103}
8104impl From<AwaitExpr> for Expr {
8105    #[inline]
8106    fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
8107}
8108impl From<BecomeExpr> for Expr {
8109    #[inline]
8110    fn from(node: BecomeExpr) -> Expr { Expr::BecomeExpr(node) }
8111}
8112impl From<BinExpr> for Expr {
8113    #[inline]
8114    fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
8115}
8116impl From<BlockExpr> for Expr {
8117    #[inline]
8118    fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
8119}
8120impl From<BreakExpr> for Expr {
8121    #[inline]
8122    fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
8123}
8124impl From<CallExpr> for Expr {
8125    #[inline]
8126    fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
8127}
8128impl From<CastExpr> for Expr {
8129    #[inline]
8130    fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
8131}
8132impl From<ClosureExpr> for Expr {
8133    #[inline]
8134    fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
8135}
8136impl From<ContinueExpr> for Expr {
8137    #[inline]
8138    fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
8139}
8140impl From<FieldExpr> for Expr {
8141    #[inline]
8142    fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
8143}
8144impl From<ForExpr> for Expr {
8145    #[inline]
8146    fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
8147}
8148impl From<FormatArgsExpr> for Expr {
8149    #[inline]
8150    fn from(node: FormatArgsExpr) -> Expr { Expr::FormatArgsExpr(node) }
8151}
8152impl From<IfExpr> for Expr {
8153    #[inline]
8154    fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
8155}
8156impl From<IncludeBytesExpr> for Expr {
8157    #[inline]
8158    fn from(node: IncludeBytesExpr) -> Expr { Expr::IncludeBytesExpr(node) }
8159}
8160impl From<IndexExpr> for Expr {
8161    #[inline]
8162    fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
8163}
8164impl From<LetExpr> for Expr {
8165    #[inline]
8166    fn from(node: LetExpr) -> Expr { Expr::LetExpr(node) }
8167}
8168impl From<Literal> for Expr {
8169    #[inline]
8170    fn from(node: Literal) -> Expr { Expr::Literal(node) }
8171}
8172impl From<LoopExpr> for Expr {
8173    #[inline]
8174    fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
8175}
8176impl From<MacroExpr> for Expr {
8177    #[inline]
8178    fn from(node: MacroExpr) -> Expr { Expr::MacroExpr(node) }
8179}
8180impl From<MatchExpr> for Expr {
8181    #[inline]
8182    fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
8183}
8184impl From<MethodCallExpr> for Expr {
8185    #[inline]
8186    fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
8187}
8188impl From<OffsetOfExpr> for Expr {
8189    #[inline]
8190    fn from(node: OffsetOfExpr) -> Expr { Expr::OffsetOfExpr(node) }
8191}
8192impl From<ParenExpr> for Expr {
8193    #[inline]
8194    fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
8195}
8196impl From<PathExpr> for Expr {
8197    #[inline]
8198    fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
8199}
8200impl From<PrefixExpr> for Expr {
8201    #[inline]
8202    fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
8203}
8204impl From<RangeExpr> for Expr {
8205    #[inline]
8206    fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
8207}
8208impl From<RecordExpr> for Expr {
8209    #[inline]
8210    fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
8211}
8212impl From<RefExpr> for Expr {
8213    #[inline]
8214    fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
8215}
8216impl From<ReturnExpr> for Expr {
8217    #[inline]
8218    fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
8219}
8220impl From<TryExpr> for Expr {
8221    #[inline]
8222    fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
8223}
8224impl From<TupleExpr> for Expr {
8225    #[inline]
8226    fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
8227}
8228impl From<UnderscoreExpr> for Expr {
8229    #[inline]
8230    fn from(node: UnderscoreExpr) -> Expr { Expr::UnderscoreExpr(node) }
8231}
8232impl From<WhileExpr> for Expr {
8233    #[inline]
8234    fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
8235}
8236impl From<YeetExpr> for Expr {
8237    #[inline]
8238    fn from(node: YeetExpr) -> Expr { Expr::YeetExpr(node) }
8239}
8240impl From<YieldExpr> for Expr {
8241    #[inline]
8242    fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) }
8243}
8244impl AstNode for Expr {
8245    #[inline]
8246    fn can_cast(kind: SyntaxKind) -> bool {
8247        matches!(
8248            kind,
8249            ARRAY_EXPR
8250                | ASM_EXPR
8251                | AWAIT_EXPR
8252                | BECOME_EXPR
8253                | BIN_EXPR
8254                | BLOCK_EXPR
8255                | BREAK_EXPR
8256                | CALL_EXPR
8257                | CAST_EXPR
8258                | CLOSURE_EXPR
8259                | CONTINUE_EXPR
8260                | FIELD_EXPR
8261                | FOR_EXPR
8262                | FORMAT_ARGS_EXPR
8263                | IF_EXPR
8264                | INCLUDE_BYTES_EXPR
8265                | INDEX_EXPR
8266                | LET_EXPR
8267                | LITERAL
8268                | LOOP_EXPR
8269                | MACRO_EXPR
8270                | MATCH_EXPR
8271                | METHOD_CALL_EXPR
8272                | OFFSET_OF_EXPR
8273                | PAREN_EXPR
8274                | PATH_EXPR
8275                | PREFIX_EXPR
8276                | RANGE_EXPR
8277                | RECORD_EXPR
8278                | REF_EXPR
8279                | RETURN_EXPR
8280                | TRY_EXPR
8281                | TUPLE_EXPR
8282                | UNDERSCORE_EXPR
8283                | WHILE_EXPR
8284                | YEET_EXPR
8285                | YIELD_EXPR
8286        )
8287    }
8288    #[inline]
8289    fn cast(syntax: SyntaxNode) -> Option<Self> {
8290        let res = match syntax.kind() {
8291            ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
8292            ASM_EXPR => Expr::AsmExpr(AsmExpr { syntax }),
8293            AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
8294            BECOME_EXPR => Expr::BecomeExpr(BecomeExpr { syntax }),
8295            BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
8296            BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
8297            BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
8298            CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
8299            CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
8300            CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
8301            CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
8302            FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
8303            FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
8304            FORMAT_ARGS_EXPR => Expr::FormatArgsExpr(FormatArgsExpr { syntax }),
8305            IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
8306            INCLUDE_BYTES_EXPR => Expr::IncludeBytesExpr(IncludeBytesExpr { syntax }),
8307            INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
8308            LET_EXPR => Expr::LetExpr(LetExpr { syntax }),
8309            LITERAL => Expr::Literal(Literal { syntax }),
8310            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
8311            MACRO_EXPR => Expr::MacroExpr(MacroExpr { syntax }),
8312            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
8313            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
8314            OFFSET_OF_EXPR => Expr::OffsetOfExpr(OffsetOfExpr { syntax }),
8315            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
8316            PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
8317            PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
8318            RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
8319            RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
8320            REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
8321            RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
8322            TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
8323            TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
8324            UNDERSCORE_EXPR => Expr::UnderscoreExpr(UnderscoreExpr { syntax }),
8325            WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
8326            YEET_EXPR => Expr::YeetExpr(YeetExpr { syntax }),
8327            YIELD_EXPR => Expr::YieldExpr(YieldExpr { syntax }),
8328            _ => return None,
8329        };
8330        Some(res)
8331    }
8332    #[inline]
8333    fn syntax(&self) -> &SyntaxNode {
8334        match self {
8335            Expr::ArrayExpr(it) => &it.syntax,
8336            Expr::AsmExpr(it) => &it.syntax,
8337            Expr::AwaitExpr(it) => &it.syntax,
8338            Expr::BecomeExpr(it) => &it.syntax,
8339            Expr::BinExpr(it) => &it.syntax,
8340            Expr::BlockExpr(it) => &it.syntax,
8341            Expr::BreakExpr(it) => &it.syntax,
8342            Expr::CallExpr(it) => &it.syntax,
8343            Expr::CastExpr(it) => &it.syntax,
8344            Expr::ClosureExpr(it) => &it.syntax,
8345            Expr::ContinueExpr(it) => &it.syntax,
8346            Expr::FieldExpr(it) => &it.syntax,
8347            Expr::ForExpr(it) => &it.syntax,
8348            Expr::FormatArgsExpr(it) => &it.syntax,
8349            Expr::IfExpr(it) => &it.syntax,
8350            Expr::IncludeBytesExpr(it) => &it.syntax,
8351            Expr::IndexExpr(it) => &it.syntax,
8352            Expr::LetExpr(it) => &it.syntax,
8353            Expr::Literal(it) => &it.syntax,
8354            Expr::LoopExpr(it) => &it.syntax,
8355            Expr::MacroExpr(it) => &it.syntax,
8356            Expr::MatchExpr(it) => &it.syntax,
8357            Expr::MethodCallExpr(it) => &it.syntax,
8358            Expr::OffsetOfExpr(it) => &it.syntax,
8359            Expr::ParenExpr(it) => &it.syntax,
8360            Expr::PathExpr(it) => &it.syntax,
8361            Expr::PrefixExpr(it) => &it.syntax,
8362            Expr::RangeExpr(it) => &it.syntax,
8363            Expr::RecordExpr(it) => &it.syntax,
8364            Expr::RefExpr(it) => &it.syntax,
8365            Expr::ReturnExpr(it) => &it.syntax,
8366            Expr::TryExpr(it) => &it.syntax,
8367            Expr::TupleExpr(it) => &it.syntax,
8368            Expr::UnderscoreExpr(it) => &it.syntax,
8369            Expr::WhileExpr(it) => &it.syntax,
8370            Expr::YeetExpr(it) => &it.syntax,
8371            Expr::YieldExpr(it) => &it.syntax,
8372        }
8373    }
8374}
8375impl From<Fn> for ExternItem {
8376    #[inline]
8377    fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
8378}
8379impl From<MacroCall> for ExternItem {
8380    #[inline]
8381    fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
8382}
8383impl From<Static> for ExternItem {
8384    #[inline]
8385    fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
8386}
8387impl From<TypeAlias> for ExternItem {
8388    #[inline]
8389    fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) }
8390}
8391impl AstNode for ExternItem {
8392    #[inline]
8393    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FN | MACRO_CALL | STATIC | TYPE_ALIAS) }
8394    #[inline]
8395    fn cast(syntax: SyntaxNode) -> Option<Self> {
8396        let res = match syntax.kind() {
8397            FN => ExternItem::Fn(Fn { syntax }),
8398            MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
8399            STATIC => ExternItem::Static(Static { syntax }),
8400            TYPE_ALIAS => ExternItem::TypeAlias(TypeAlias { syntax }),
8401            _ => return None,
8402        };
8403        Some(res)
8404    }
8405    #[inline]
8406    fn syntax(&self) -> &SyntaxNode {
8407        match self {
8408            ExternItem::Fn(it) => &it.syntax,
8409            ExternItem::MacroCall(it) => &it.syntax,
8410            ExternItem::Static(it) => &it.syntax,
8411            ExternItem::TypeAlias(it) => &it.syntax,
8412        }
8413    }
8414}
8415impl From<RecordFieldList> for FieldList {
8416    #[inline]
8417    fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
8418}
8419impl From<TupleFieldList> for FieldList {
8420    #[inline]
8421    fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
8422}
8423impl AstNode for FieldList {
8424    #[inline]
8425    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, RECORD_FIELD_LIST | TUPLE_FIELD_LIST) }
8426    #[inline]
8427    fn cast(syntax: SyntaxNode) -> Option<Self> {
8428        let res = match syntax.kind() {
8429            RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
8430            TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
8431            _ => return None,
8432        };
8433        Some(res)
8434    }
8435    #[inline]
8436    fn syntax(&self) -> &SyntaxNode {
8437        match self {
8438            FieldList::RecordFieldList(it) => &it.syntax,
8439            FieldList::TupleFieldList(it) => &it.syntax,
8440        }
8441    }
8442}
8443impl From<AssocTypeArg> for GenericArg {
8444    #[inline]
8445    fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
8446}
8447impl From<ConstArg> for GenericArg {
8448    #[inline]
8449    fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
8450}
8451impl From<LifetimeArg> for GenericArg {
8452    #[inline]
8453    fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
8454}
8455impl From<TypeArg> for GenericArg {
8456    #[inline]
8457    fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
8458}
8459impl AstNode for GenericArg {
8460    #[inline]
8461    fn can_cast(kind: SyntaxKind) -> bool {
8462        matches!(kind, ASSOC_TYPE_ARG | CONST_ARG | LIFETIME_ARG | TYPE_ARG)
8463    }
8464    #[inline]
8465    fn cast(syntax: SyntaxNode) -> Option<Self> {
8466        let res = match syntax.kind() {
8467            ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
8468            CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
8469            LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
8470            TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
8471            _ => return None,
8472        };
8473        Some(res)
8474    }
8475    #[inline]
8476    fn syntax(&self) -> &SyntaxNode {
8477        match self {
8478            GenericArg::AssocTypeArg(it) => &it.syntax,
8479            GenericArg::ConstArg(it) => &it.syntax,
8480            GenericArg::LifetimeArg(it) => &it.syntax,
8481            GenericArg::TypeArg(it) => &it.syntax,
8482        }
8483    }
8484}
8485impl From<ConstParam> for GenericParam {
8486    #[inline]
8487    fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
8488}
8489impl From<LifetimeParam> for GenericParam {
8490    #[inline]
8491    fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
8492}
8493impl From<TypeParam> for GenericParam {
8494    #[inline]
8495    fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
8496}
8497impl AstNode for GenericParam {
8498    #[inline]
8499    fn can_cast(kind: SyntaxKind) -> bool {
8500        matches!(kind, CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM)
8501    }
8502    #[inline]
8503    fn cast(syntax: SyntaxNode) -> Option<Self> {
8504        let res = match syntax.kind() {
8505            CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
8506            LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
8507            TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
8508            _ => return None,
8509        };
8510        Some(res)
8511    }
8512    #[inline]
8513    fn syntax(&self) -> &SyntaxNode {
8514        match self {
8515            GenericParam::ConstParam(it) => &it.syntax,
8516            GenericParam::LifetimeParam(it) => &it.syntax,
8517            GenericParam::TypeParam(it) => &it.syntax,
8518        }
8519    }
8520}
8521impl From<AsmExpr> for Item {
8522    #[inline]
8523    fn from(node: AsmExpr) -> Item { Item::AsmExpr(node) }
8524}
8525impl From<Const> for Item {
8526    #[inline]
8527    fn from(node: Const) -> Item { Item::Const(node) }
8528}
8529impl From<Enum> for Item {
8530    #[inline]
8531    fn from(node: Enum) -> Item { Item::Enum(node) }
8532}
8533impl From<ExternBlock> for Item {
8534    #[inline]
8535    fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
8536}
8537impl From<ExternCrate> for Item {
8538    #[inline]
8539    fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
8540}
8541impl From<Fn> for Item {
8542    #[inline]
8543    fn from(node: Fn) -> Item { Item::Fn(node) }
8544}
8545impl From<Impl> for Item {
8546    #[inline]
8547    fn from(node: Impl) -> Item { Item::Impl(node) }
8548}
8549impl From<MacroCall> for Item {
8550    #[inline]
8551    fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
8552}
8553impl From<MacroDef> for Item {
8554    #[inline]
8555    fn from(node: MacroDef) -> Item { Item::MacroDef(node) }
8556}
8557impl From<MacroRules> for Item {
8558    #[inline]
8559    fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
8560}
8561impl From<Module> for Item {
8562    #[inline]
8563    fn from(node: Module) -> Item { Item::Module(node) }
8564}
8565impl From<Static> for Item {
8566    #[inline]
8567    fn from(node: Static) -> Item { Item::Static(node) }
8568}
8569impl From<Struct> for Item {
8570    #[inline]
8571    fn from(node: Struct) -> Item { Item::Struct(node) }
8572}
8573impl From<Trait> for Item {
8574    #[inline]
8575    fn from(node: Trait) -> Item { Item::Trait(node) }
8576}
8577impl From<TypeAlias> for Item {
8578    #[inline]
8579    fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
8580}
8581impl From<Union> for Item {
8582    #[inline]
8583    fn from(node: Union) -> Item { Item::Union(node) }
8584}
8585impl From<Use> for Item {
8586    #[inline]
8587    fn from(node: Use) -> Item { Item::Use(node) }
8588}
8589impl AstNode for Item {
8590    #[inline]
8591    fn can_cast(kind: SyntaxKind) -> bool {
8592        matches!(
8593            kind,
8594            ASM_EXPR
8595                | CONST
8596                | ENUM
8597                | EXTERN_BLOCK
8598                | EXTERN_CRATE
8599                | FN
8600                | IMPL
8601                | MACRO_CALL
8602                | MACRO_DEF
8603                | MACRO_RULES
8604                | MODULE
8605                | STATIC
8606                | STRUCT
8607                | TRAIT
8608                | TYPE_ALIAS
8609                | UNION
8610                | USE
8611        )
8612    }
8613    #[inline]
8614    fn cast(syntax: SyntaxNode) -> Option<Self> {
8615        let res = match syntax.kind() {
8616            ASM_EXPR => Item::AsmExpr(AsmExpr { syntax }),
8617            CONST => Item::Const(Const { syntax }),
8618            ENUM => Item::Enum(Enum { syntax }),
8619            EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
8620            EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
8621            FN => Item::Fn(Fn { syntax }),
8622            IMPL => Item::Impl(Impl { syntax }),
8623            MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
8624            MACRO_DEF => Item::MacroDef(MacroDef { syntax }),
8625            MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
8626            MODULE => Item::Module(Module { syntax }),
8627            STATIC => Item::Static(Static { syntax }),
8628            STRUCT => Item::Struct(Struct { syntax }),
8629            TRAIT => Item::Trait(Trait { syntax }),
8630            TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
8631            UNION => Item::Union(Union { syntax }),
8632            USE => Item::Use(Use { syntax }),
8633            _ => return None,
8634        };
8635        Some(res)
8636    }
8637    #[inline]
8638    fn syntax(&self) -> &SyntaxNode {
8639        match self {
8640            Item::AsmExpr(it) => &it.syntax,
8641            Item::Const(it) => &it.syntax,
8642            Item::Enum(it) => &it.syntax,
8643            Item::ExternBlock(it) => &it.syntax,
8644            Item::ExternCrate(it) => &it.syntax,
8645            Item::Fn(it) => &it.syntax,
8646            Item::Impl(it) => &it.syntax,
8647            Item::MacroCall(it) => &it.syntax,
8648            Item::MacroDef(it) => &it.syntax,
8649            Item::MacroRules(it) => &it.syntax,
8650            Item::Module(it) => &it.syntax,
8651            Item::Static(it) => &it.syntax,
8652            Item::Struct(it) => &it.syntax,
8653            Item::Trait(it) => &it.syntax,
8654            Item::TypeAlias(it) => &it.syntax,
8655            Item::Union(it) => &it.syntax,
8656            Item::Use(it) => &it.syntax,
8657        }
8658    }
8659}
8660impl From<CfgAttrMeta> for Meta {
8661    #[inline]
8662    fn from(node: CfgAttrMeta) -> Meta { Meta::CfgAttrMeta(node) }
8663}
8664impl From<CfgMeta> for Meta {
8665    #[inline]
8666    fn from(node: CfgMeta) -> Meta { Meta::CfgMeta(node) }
8667}
8668impl From<KeyValueMeta> for Meta {
8669    #[inline]
8670    fn from(node: KeyValueMeta) -> Meta { Meta::KeyValueMeta(node) }
8671}
8672impl From<PathMeta> for Meta {
8673    #[inline]
8674    fn from(node: PathMeta) -> Meta { Meta::PathMeta(node) }
8675}
8676impl From<TokenTreeMeta> for Meta {
8677    #[inline]
8678    fn from(node: TokenTreeMeta) -> Meta { Meta::TokenTreeMeta(node) }
8679}
8680impl From<UnsafeMeta> for Meta {
8681    #[inline]
8682    fn from(node: UnsafeMeta) -> Meta { Meta::UnsafeMeta(node) }
8683}
8684impl AstNode for Meta {
8685    #[inline]
8686    fn can_cast(kind: SyntaxKind) -> bool {
8687        matches!(
8688            kind,
8689            CFG_ATTR_META | CFG_META | KEY_VALUE_META | PATH_META | TOKEN_TREE_META | UNSAFE_META
8690        )
8691    }
8692    #[inline]
8693    fn cast(syntax: SyntaxNode) -> Option<Self> {
8694        let res = match syntax.kind() {
8695            CFG_ATTR_META => Meta::CfgAttrMeta(CfgAttrMeta { syntax }),
8696            CFG_META => Meta::CfgMeta(CfgMeta { syntax }),
8697            KEY_VALUE_META => Meta::KeyValueMeta(KeyValueMeta { syntax }),
8698            PATH_META => Meta::PathMeta(PathMeta { syntax }),
8699            TOKEN_TREE_META => Meta::TokenTreeMeta(TokenTreeMeta { syntax }),
8700            UNSAFE_META => Meta::UnsafeMeta(UnsafeMeta { syntax }),
8701            _ => return None,
8702        };
8703        Some(res)
8704    }
8705    #[inline]
8706    fn syntax(&self) -> &SyntaxNode {
8707        match self {
8708            Meta::CfgAttrMeta(it) => &it.syntax,
8709            Meta::CfgMeta(it) => &it.syntax,
8710            Meta::KeyValueMeta(it) => &it.syntax,
8711            Meta::PathMeta(it) => &it.syntax,
8712            Meta::TokenTreeMeta(it) => &it.syntax,
8713            Meta::UnsafeMeta(it) => &it.syntax,
8714        }
8715    }
8716}
8717impl From<BoxPat> for Pat {
8718    #[inline]
8719    fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
8720}
8721impl From<ConstBlockPat> for Pat {
8722    #[inline]
8723    fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
8724}
8725impl From<DerefPat> for Pat {
8726    #[inline]
8727    fn from(node: DerefPat) -> Pat { Pat::DerefPat(node) }
8728}
8729impl From<IdentPat> for Pat {
8730    #[inline]
8731    fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
8732}
8733impl From<LiteralPat> for Pat {
8734    #[inline]
8735    fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
8736}
8737impl From<MacroPat> for Pat {
8738    #[inline]
8739    fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
8740}
8741impl From<NotNull> for Pat {
8742    #[inline]
8743    fn from(node: NotNull) -> Pat { Pat::NotNull(node) }
8744}
8745impl From<OrPat> for Pat {
8746    #[inline]
8747    fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
8748}
8749impl From<ParenPat> for Pat {
8750    #[inline]
8751    fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
8752}
8753impl From<PathPat> for Pat {
8754    #[inline]
8755    fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
8756}
8757impl From<RangePat> for Pat {
8758    #[inline]
8759    fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
8760}
8761impl From<RecordPat> for Pat {
8762    #[inline]
8763    fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
8764}
8765impl From<RefPat> for Pat {
8766    #[inline]
8767    fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
8768}
8769impl From<RestPat> for Pat {
8770    #[inline]
8771    fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
8772}
8773impl From<SlicePat> for Pat {
8774    #[inline]
8775    fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
8776}
8777impl From<TuplePat> for Pat {
8778    #[inline]
8779    fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
8780}
8781impl From<TupleStructPat> for Pat {
8782    #[inline]
8783    fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
8784}
8785impl From<WildcardPat> for Pat {
8786    #[inline]
8787    fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
8788}
8789impl AstNode for Pat {
8790    #[inline]
8791    fn can_cast(kind: SyntaxKind) -> bool {
8792        matches!(
8793            kind,
8794            BOX_PAT
8795                | CONST_BLOCK_PAT
8796                | DEREF_PAT
8797                | IDENT_PAT
8798                | LITERAL_PAT
8799                | MACRO_PAT
8800                | NOT_NULL
8801                | OR_PAT
8802                | PAREN_PAT
8803                | PATH_PAT
8804                | RANGE_PAT
8805                | RECORD_PAT
8806                | REF_PAT
8807                | REST_PAT
8808                | SLICE_PAT
8809                | TUPLE_PAT
8810                | TUPLE_STRUCT_PAT
8811                | WILDCARD_PAT
8812        )
8813    }
8814    #[inline]
8815    fn cast(syntax: SyntaxNode) -> Option<Self> {
8816        let res = match syntax.kind() {
8817            BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
8818            CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
8819            DEREF_PAT => Pat::DerefPat(DerefPat { syntax }),
8820            IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
8821            LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
8822            MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
8823            NOT_NULL => Pat::NotNull(NotNull { syntax }),
8824            OR_PAT => Pat::OrPat(OrPat { syntax }),
8825            PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
8826            PATH_PAT => Pat::PathPat(PathPat { syntax }),
8827            RANGE_PAT => Pat::RangePat(RangePat { syntax }),
8828            RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
8829            REF_PAT => Pat::RefPat(RefPat { syntax }),
8830            REST_PAT => Pat::RestPat(RestPat { syntax }),
8831            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
8832            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
8833            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
8834            WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
8835            _ => return None,
8836        };
8837        Some(res)
8838    }
8839    #[inline]
8840    fn syntax(&self) -> &SyntaxNode {
8841        match self {
8842            Pat::BoxPat(it) => &it.syntax,
8843            Pat::ConstBlockPat(it) => &it.syntax,
8844            Pat::DerefPat(it) => &it.syntax,
8845            Pat::IdentPat(it) => &it.syntax,
8846            Pat::LiteralPat(it) => &it.syntax,
8847            Pat::MacroPat(it) => &it.syntax,
8848            Pat::NotNull(it) => &it.syntax,
8849            Pat::OrPat(it) => &it.syntax,
8850            Pat::ParenPat(it) => &it.syntax,
8851            Pat::PathPat(it) => &it.syntax,
8852            Pat::RangePat(it) => &it.syntax,
8853            Pat::RecordPat(it) => &it.syntax,
8854            Pat::RefPat(it) => &it.syntax,
8855            Pat::RestPat(it) => &it.syntax,
8856            Pat::SlicePat(it) => &it.syntax,
8857            Pat::TuplePat(it) => &it.syntax,
8858            Pat::TupleStructPat(it) => &it.syntax,
8859            Pat::WildcardPat(it) => &it.syntax,
8860        }
8861    }
8862}
8863impl From<ExprStmt> for Stmt {
8864    #[inline]
8865    fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
8866}
8867impl From<Item> for Stmt {
8868    #[inline]
8869    fn from(node: Item) -> Stmt { Stmt::Item(node) }
8870}
8871impl From<LetStmt> for Stmt {
8872    #[inline]
8873    fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
8874}
8875impl From<ArrayType> for Type {
8876    #[inline]
8877    fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
8878}
8879impl From<DynTraitType> for Type {
8880    #[inline]
8881    fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
8882}
8883impl From<FnPtrType> for Type {
8884    #[inline]
8885    fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
8886}
8887impl From<ForType> for Type {
8888    #[inline]
8889    fn from(node: ForType) -> Type { Type::ForType(node) }
8890}
8891impl From<ImplTraitType> for Type {
8892    #[inline]
8893    fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
8894}
8895impl From<InferType> for Type {
8896    #[inline]
8897    fn from(node: InferType) -> Type { Type::InferType(node) }
8898}
8899impl From<MacroType> for Type {
8900    #[inline]
8901    fn from(node: MacroType) -> Type { Type::MacroType(node) }
8902}
8903impl From<NeverType> for Type {
8904    #[inline]
8905    fn from(node: NeverType) -> Type { Type::NeverType(node) }
8906}
8907impl From<ParenType> for Type {
8908    #[inline]
8909    fn from(node: ParenType) -> Type { Type::ParenType(node) }
8910}
8911impl From<PathType> for Type {
8912    #[inline]
8913    fn from(node: PathType) -> Type { Type::PathType(node) }
8914}
8915impl From<PatternType> for Type {
8916    #[inline]
8917    fn from(node: PatternType) -> Type { Type::PatternType(node) }
8918}
8919impl From<PtrType> for Type {
8920    #[inline]
8921    fn from(node: PtrType) -> Type { Type::PtrType(node) }
8922}
8923impl From<RefType> for Type {
8924    #[inline]
8925    fn from(node: RefType) -> Type { Type::RefType(node) }
8926}
8927impl From<SliceType> for Type {
8928    #[inline]
8929    fn from(node: SliceType) -> Type { Type::SliceType(node) }
8930}
8931impl From<TupleType> for Type {
8932    #[inline]
8933    fn from(node: TupleType) -> Type { Type::TupleType(node) }
8934}
8935impl AstNode for Type {
8936    #[inline]
8937    fn can_cast(kind: SyntaxKind) -> bool {
8938        matches!(
8939            kind,
8940            ARRAY_TYPE
8941                | DYN_TRAIT_TYPE
8942                | FN_PTR_TYPE
8943                | FOR_TYPE
8944                | IMPL_TRAIT_TYPE
8945                | INFER_TYPE
8946                | MACRO_TYPE
8947                | NEVER_TYPE
8948                | PAREN_TYPE
8949                | PATH_TYPE
8950                | PATTERN_TYPE
8951                | PTR_TYPE
8952                | REF_TYPE
8953                | SLICE_TYPE
8954                | TUPLE_TYPE
8955        )
8956    }
8957    #[inline]
8958    fn cast(syntax: SyntaxNode) -> Option<Self> {
8959        let res = match syntax.kind() {
8960            ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
8961            DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
8962            FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
8963            FOR_TYPE => Type::ForType(ForType { syntax }),
8964            IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
8965            INFER_TYPE => Type::InferType(InferType { syntax }),
8966            MACRO_TYPE => Type::MacroType(MacroType { syntax }),
8967            NEVER_TYPE => Type::NeverType(NeverType { syntax }),
8968            PAREN_TYPE => Type::ParenType(ParenType { syntax }),
8969            PATH_TYPE => Type::PathType(PathType { syntax }),
8970            PATTERN_TYPE => Type::PatternType(PatternType { syntax }),
8971            PTR_TYPE => Type::PtrType(PtrType { syntax }),
8972            REF_TYPE => Type::RefType(RefType { syntax }),
8973            SLICE_TYPE => Type::SliceType(SliceType { syntax }),
8974            TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
8975            _ => return None,
8976        };
8977        Some(res)
8978    }
8979    #[inline]
8980    fn syntax(&self) -> &SyntaxNode {
8981        match self {
8982            Type::ArrayType(it) => &it.syntax,
8983            Type::DynTraitType(it) => &it.syntax,
8984            Type::FnPtrType(it) => &it.syntax,
8985            Type::ForType(it) => &it.syntax,
8986            Type::ImplTraitType(it) => &it.syntax,
8987            Type::InferType(it) => &it.syntax,
8988            Type::MacroType(it) => &it.syntax,
8989            Type::NeverType(it) => &it.syntax,
8990            Type::ParenType(it) => &it.syntax,
8991            Type::PathType(it) => &it.syntax,
8992            Type::PatternType(it) => &it.syntax,
8993            Type::PtrType(it) => &it.syntax,
8994            Type::RefType(it) => &it.syntax,
8995            Type::SliceType(it) => &it.syntax,
8996            Type::TupleType(it) => &it.syntax,
8997        }
8998    }
8999}
9000impl From<Lifetime> for UseBoundGenericArg {
9001    #[inline]
9002    fn from(node: Lifetime) -> UseBoundGenericArg { UseBoundGenericArg::Lifetime(node) }
9003}
9004impl From<NameRef> for UseBoundGenericArg {
9005    #[inline]
9006    fn from(node: NameRef) -> UseBoundGenericArg { UseBoundGenericArg::NameRef(node) }
9007}
9008impl AstNode for UseBoundGenericArg {
9009    #[inline]
9010    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, LIFETIME | NAME_REF) }
9011    #[inline]
9012    fn cast(syntax: SyntaxNode) -> Option<Self> {
9013        let res = match syntax.kind() {
9014            LIFETIME => UseBoundGenericArg::Lifetime(Lifetime { syntax }),
9015            NAME_REF => UseBoundGenericArg::NameRef(NameRef { syntax }),
9016            _ => return None,
9017        };
9018        Some(res)
9019    }
9020    #[inline]
9021    fn syntax(&self) -> &SyntaxNode {
9022        match self {
9023            UseBoundGenericArg::Lifetime(it) => &it.syntax,
9024            UseBoundGenericArg::NameRef(it) => &it.syntax,
9025        }
9026    }
9027}
9028impl From<Struct> for VariantDef {
9029    #[inline]
9030    fn from(node: Struct) -> VariantDef { VariantDef::Struct(node) }
9031}
9032impl From<Union> for VariantDef {
9033    #[inline]
9034    fn from(node: Union) -> VariantDef { VariantDef::Union(node) }
9035}
9036impl From<Variant> for VariantDef {
9037    #[inline]
9038    fn from(node: Variant) -> VariantDef { VariantDef::Variant(node) }
9039}
9040impl AstNode for VariantDef {
9041    #[inline]
9042    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, STRUCT | UNION | VARIANT) }
9043    #[inline]
9044    fn cast(syntax: SyntaxNode) -> Option<Self> {
9045        let res = match syntax.kind() {
9046            STRUCT => VariantDef::Struct(Struct { syntax }),
9047            UNION => VariantDef::Union(Union { syntax }),
9048            VARIANT => VariantDef::Variant(Variant { syntax }),
9049            _ => return None,
9050        };
9051        Some(res)
9052    }
9053    #[inline]
9054    fn syntax(&self) -> &SyntaxNode {
9055        match self {
9056            VariantDef::Struct(it) => &it.syntax,
9057            VariantDef::Union(it) => &it.syntax,
9058            VariantDef::Variant(it) => &it.syntax,
9059        }
9060    }
9061}
9062impl ast::HasArgList for AnyHasArgList {}
9063impl AstNode for AnyHasArgList {
9064    #[inline]
9065    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CALL_EXPR | METHOD_CALL_EXPR) }
9066    #[inline]
9067    fn cast(syntax: SyntaxNode) -> Option<Self> {
9068        Self::can_cast(syntax.kind()).then_some(AnyHasArgList { syntax })
9069    }
9070    #[inline]
9071    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9072}
9073impl hash::Hash for AnyHasArgList {
9074    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9075}
9076impl Eq for AnyHasArgList {}
9077impl PartialEq for AnyHasArgList {
9078    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9079}
9080impl Clone for AnyHasArgList {
9081    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9082}
9083impl fmt::Debug for AnyHasArgList {
9084    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9085        f.debug_struct("AnyHasArgList").field("syntax", &self.syntax).finish()
9086    }
9087}
9088impl From<CallExpr> for AnyHasArgList {
9089    #[inline]
9090    fn from(node: CallExpr) -> AnyHasArgList { AnyHasArgList { syntax: node.syntax } }
9091}
9092impl From<MethodCallExpr> for AnyHasArgList {
9093    #[inline]
9094    fn from(node: MethodCallExpr) -> AnyHasArgList { AnyHasArgList { syntax: node.syntax } }
9095}
9096impl ast::HasAttrs for AnyHasAttrs {}
9097impl AstNode for AnyHasAttrs {
9098    #[inline]
9099    fn can_cast(kind: SyntaxKind) -> bool {
9100        matches!(
9101            kind,
9102            ARRAY_EXPR
9103                | ASM_CLOBBER_ABI
9104                | ASM_EXPR
9105                | ASM_OPERAND_NAMED
9106                | ASM_OPTIONS
9107                | ASSOC_ITEM_LIST
9108                | AWAIT_EXPR
9109                | BECOME_EXPR
9110                | BIN_EXPR
9111                | BLOCK_EXPR
9112                | BREAK_EXPR
9113                | CALL_EXPR
9114                | CAST_EXPR
9115                | CLOSURE_EXPR
9116                | CONST
9117                | CONST_PARAM
9118                | CONTINUE_EXPR
9119                | ENUM
9120                | EXTERN_BLOCK
9121                | EXTERN_CRATE
9122                | EXTERN_ITEM_LIST
9123                | FIELD_EXPR
9124                | FN
9125                | FOR_EXPR
9126                | FORMAT_ARGS_EXPR
9127                | IDENT_PAT
9128                | IF_EXPR
9129                | IMPL
9130                | INDEX_EXPR
9131                | ITEM_LIST
9132                | LET_EXPR
9133                | LET_STMT
9134                | LIFETIME_PARAM
9135                | LITERAL
9136                | LOOP_EXPR
9137                | MACRO_CALL
9138                | MACRO_DEF
9139                | MACRO_RULES
9140                | MATCH_ARM
9141                | MATCH_ARM_LIST
9142                | MATCH_EXPR
9143                | METHOD_CALL_EXPR
9144                | MODULE
9145                | OFFSET_OF_EXPR
9146                | PARAM
9147                | PAREN_EXPR
9148                | PATH_EXPR
9149                | PREFIX_EXPR
9150                | RANGE_EXPR
9151                | RECORD_EXPR_FIELD
9152                | RECORD_EXPR_FIELD_LIST
9153                | RECORD_FIELD
9154                | RECORD_PAT_FIELD
9155                | REF_EXPR
9156                | REST_PAT
9157                | RETURN_EXPR
9158                | SELF_PARAM
9159                | SOURCE_FILE
9160                | STATIC
9161                | STMT_LIST
9162                | STRUCT
9163                | TRAIT
9164                | TRY_EXPR
9165                | TUPLE_EXPR
9166                | TUPLE_FIELD
9167                | TYPE_ALIAS
9168                | TYPE_PARAM
9169                | UNDERSCORE_EXPR
9170                | UNION
9171                | USE
9172                | VARIANT
9173                | WHILE_EXPR
9174                | YEET_EXPR
9175                | YIELD_EXPR
9176        )
9177    }
9178    #[inline]
9179    fn cast(syntax: SyntaxNode) -> Option<Self> {
9180        Self::can_cast(syntax.kind()).then_some(AnyHasAttrs { syntax })
9181    }
9182    #[inline]
9183    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9184}
9185impl hash::Hash for AnyHasAttrs {
9186    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9187}
9188impl Eq for AnyHasAttrs {}
9189impl PartialEq for AnyHasAttrs {
9190    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9191}
9192impl Clone for AnyHasAttrs {
9193    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9194}
9195impl fmt::Debug for AnyHasAttrs {
9196    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9197        f.debug_struct("AnyHasAttrs").field("syntax", &self.syntax).finish()
9198    }
9199}
9200impl From<ArrayExpr> for AnyHasAttrs {
9201    #[inline]
9202    fn from(node: ArrayExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9203}
9204impl From<AsmClobberAbi> for AnyHasAttrs {
9205    #[inline]
9206    fn from(node: AsmClobberAbi) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9207}
9208impl From<AsmExpr> for AnyHasAttrs {
9209    #[inline]
9210    fn from(node: AsmExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9211}
9212impl From<AsmOperandNamed> for AnyHasAttrs {
9213    #[inline]
9214    fn from(node: AsmOperandNamed) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9215}
9216impl From<AsmOptions> for AnyHasAttrs {
9217    #[inline]
9218    fn from(node: AsmOptions) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9219}
9220impl From<AssocItemList> for AnyHasAttrs {
9221    #[inline]
9222    fn from(node: AssocItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9223}
9224impl From<AwaitExpr> for AnyHasAttrs {
9225    #[inline]
9226    fn from(node: AwaitExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9227}
9228impl From<BecomeExpr> for AnyHasAttrs {
9229    #[inline]
9230    fn from(node: BecomeExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9231}
9232impl From<BinExpr> for AnyHasAttrs {
9233    #[inline]
9234    fn from(node: BinExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9235}
9236impl From<BlockExpr> for AnyHasAttrs {
9237    #[inline]
9238    fn from(node: BlockExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9239}
9240impl From<BreakExpr> for AnyHasAttrs {
9241    #[inline]
9242    fn from(node: BreakExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9243}
9244impl From<CallExpr> for AnyHasAttrs {
9245    #[inline]
9246    fn from(node: CallExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9247}
9248impl From<CastExpr> for AnyHasAttrs {
9249    #[inline]
9250    fn from(node: CastExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9251}
9252impl From<ClosureExpr> for AnyHasAttrs {
9253    #[inline]
9254    fn from(node: ClosureExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9255}
9256impl From<Const> for AnyHasAttrs {
9257    #[inline]
9258    fn from(node: Const) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9259}
9260impl From<ConstParam> for AnyHasAttrs {
9261    #[inline]
9262    fn from(node: ConstParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9263}
9264impl From<ContinueExpr> for AnyHasAttrs {
9265    #[inline]
9266    fn from(node: ContinueExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9267}
9268impl From<Enum> for AnyHasAttrs {
9269    #[inline]
9270    fn from(node: Enum) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9271}
9272impl From<ExternBlock> for AnyHasAttrs {
9273    #[inline]
9274    fn from(node: ExternBlock) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9275}
9276impl From<ExternCrate> for AnyHasAttrs {
9277    #[inline]
9278    fn from(node: ExternCrate) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9279}
9280impl From<ExternItemList> for AnyHasAttrs {
9281    #[inline]
9282    fn from(node: ExternItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9283}
9284impl From<FieldExpr> for AnyHasAttrs {
9285    #[inline]
9286    fn from(node: FieldExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9287}
9288impl From<Fn> for AnyHasAttrs {
9289    #[inline]
9290    fn from(node: Fn) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9291}
9292impl From<ForExpr> for AnyHasAttrs {
9293    #[inline]
9294    fn from(node: ForExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9295}
9296impl From<FormatArgsExpr> for AnyHasAttrs {
9297    #[inline]
9298    fn from(node: FormatArgsExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9299}
9300impl From<IdentPat> for AnyHasAttrs {
9301    #[inline]
9302    fn from(node: IdentPat) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9303}
9304impl From<IfExpr> for AnyHasAttrs {
9305    #[inline]
9306    fn from(node: IfExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9307}
9308impl From<Impl> for AnyHasAttrs {
9309    #[inline]
9310    fn from(node: Impl) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9311}
9312impl From<IndexExpr> for AnyHasAttrs {
9313    #[inline]
9314    fn from(node: IndexExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9315}
9316impl From<ItemList> for AnyHasAttrs {
9317    #[inline]
9318    fn from(node: ItemList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9319}
9320impl From<LetExpr> for AnyHasAttrs {
9321    #[inline]
9322    fn from(node: LetExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9323}
9324impl From<LetStmt> for AnyHasAttrs {
9325    #[inline]
9326    fn from(node: LetStmt) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9327}
9328impl From<LifetimeParam> for AnyHasAttrs {
9329    #[inline]
9330    fn from(node: LifetimeParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9331}
9332impl From<Literal> for AnyHasAttrs {
9333    #[inline]
9334    fn from(node: Literal) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9335}
9336impl From<LoopExpr> for AnyHasAttrs {
9337    #[inline]
9338    fn from(node: LoopExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9339}
9340impl From<MacroCall> for AnyHasAttrs {
9341    #[inline]
9342    fn from(node: MacroCall) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9343}
9344impl From<MacroDef> for AnyHasAttrs {
9345    #[inline]
9346    fn from(node: MacroDef) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9347}
9348impl From<MacroRules> for AnyHasAttrs {
9349    #[inline]
9350    fn from(node: MacroRules) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9351}
9352impl From<MatchArm> for AnyHasAttrs {
9353    #[inline]
9354    fn from(node: MatchArm) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9355}
9356impl From<MatchArmList> for AnyHasAttrs {
9357    #[inline]
9358    fn from(node: MatchArmList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9359}
9360impl From<MatchExpr> for AnyHasAttrs {
9361    #[inline]
9362    fn from(node: MatchExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9363}
9364impl From<MethodCallExpr> for AnyHasAttrs {
9365    #[inline]
9366    fn from(node: MethodCallExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9367}
9368impl From<Module> for AnyHasAttrs {
9369    #[inline]
9370    fn from(node: Module) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9371}
9372impl From<OffsetOfExpr> for AnyHasAttrs {
9373    #[inline]
9374    fn from(node: OffsetOfExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9375}
9376impl From<Param> for AnyHasAttrs {
9377    #[inline]
9378    fn from(node: Param) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9379}
9380impl From<ParenExpr> for AnyHasAttrs {
9381    #[inline]
9382    fn from(node: ParenExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9383}
9384impl From<PathExpr> for AnyHasAttrs {
9385    #[inline]
9386    fn from(node: PathExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9387}
9388impl From<PrefixExpr> for AnyHasAttrs {
9389    #[inline]
9390    fn from(node: PrefixExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9391}
9392impl From<RangeExpr> for AnyHasAttrs {
9393    #[inline]
9394    fn from(node: RangeExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9395}
9396impl From<RecordExprField> for AnyHasAttrs {
9397    #[inline]
9398    fn from(node: RecordExprField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9399}
9400impl From<RecordExprFieldList> for AnyHasAttrs {
9401    #[inline]
9402    fn from(node: RecordExprFieldList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9403}
9404impl From<RecordField> for AnyHasAttrs {
9405    #[inline]
9406    fn from(node: RecordField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9407}
9408impl From<RecordPatField> for AnyHasAttrs {
9409    #[inline]
9410    fn from(node: RecordPatField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9411}
9412impl From<RefExpr> for AnyHasAttrs {
9413    #[inline]
9414    fn from(node: RefExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9415}
9416impl From<RestPat> for AnyHasAttrs {
9417    #[inline]
9418    fn from(node: RestPat) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9419}
9420impl From<ReturnExpr> for AnyHasAttrs {
9421    #[inline]
9422    fn from(node: ReturnExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9423}
9424impl From<SelfParam> for AnyHasAttrs {
9425    #[inline]
9426    fn from(node: SelfParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9427}
9428impl From<SourceFile> for AnyHasAttrs {
9429    #[inline]
9430    fn from(node: SourceFile) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9431}
9432impl From<Static> for AnyHasAttrs {
9433    #[inline]
9434    fn from(node: Static) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9435}
9436impl From<StmtList> for AnyHasAttrs {
9437    #[inline]
9438    fn from(node: StmtList) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9439}
9440impl From<Struct> for AnyHasAttrs {
9441    #[inline]
9442    fn from(node: Struct) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9443}
9444impl From<Trait> for AnyHasAttrs {
9445    #[inline]
9446    fn from(node: Trait) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9447}
9448impl From<TryExpr> for AnyHasAttrs {
9449    #[inline]
9450    fn from(node: TryExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9451}
9452impl From<TupleExpr> for AnyHasAttrs {
9453    #[inline]
9454    fn from(node: TupleExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9455}
9456impl From<TupleField> for AnyHasAttrs {
9457    #[inline]
9458    fn from(node: TupleField) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9459}
9460impl From<TypeAlias> for AnyHasAttrs {
9461    #[inline]
9462    fn from(node: TypeAlias) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9463}
9464impl From<TypeParam> for AnyHasAttrs {
9465    #[inline]
9466    fn from(node: TypeParam) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9467}
9468impl From<UnderscoreExpr> for AnyHasAttrs {
9469    #[inline]
9470    fn from(node: UnderscoreExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9471}
9472impl From<Union> for AnyHasAttrs {
9473    #[inline]
9474    fn from(node: Union) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9475}
9476impl From<Use> for AnyHasAttrs {
9477    #[inline]
9478    fn from(node: Use) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9479}
9480impl From<Variant> for AnyHasAttrs {
9481    #[inline]
9482    fn from(node: Variant) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9483}
9484impl From<WhileExpr> for AnyHasAttrs {
9485    #[inline]
9486    fn from(node: WhileExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9487}
9488impl From<YeetExpr> for AnyHasAttrs {
9489    #[inline]
9490    fn from(node: YeetExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9491}
9492impl From<YieldExpr> for AnyHasAttrs {
9493    #[inline]
9494    fn from(node: YieldExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
9495}
9496impl ast::HasDocComments for AnyHasDocComments {}
9497impl AstNode for AnyHasDocComments {
9498    #[inline]
9499    fn can_cast(kind: SyntaxKind) -> bool {
9500        matches!(
9501            kind,
9502            CONST
9503                | ENUM
9504                | EXTERN_BLOCK
9505                | EXTERN_CRATE
9506                | FN
9507                | IMPL
9508                | MACRO_CALL
9509                | MACRO_DEF
9510                | MACRO_RULES
9511                | MODULE
9512                | RECORD_FIELD
9513                | SOURCE_FILE
9514                | STATIC
9515                | STRUCT
9516                | TRAIT
9517                | TUPLE_FIELD
9518                | TYPE_ALIAS
9519                | UNION
9520                | USE
9521                | VARIANT
9522        )
9523    }
9524    #[inline]
9525    fn cast(syntax: SyntaxNode) -> Option<Self> {
9526        Self::can_cast(syntax.kind()).then_some(AnyHasDocComments { syntax })
9527    }
9528    #[inline]
9529    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9530}
9531impl hash::Hash for AnyHasDocComments {
9532    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9533}
9534impl Eq for AnyHasDocComments {}
9535impl PartialEq for AnyHasDocComments {
9536    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9537}
9538impl Clone for AnyHasDocComments {
9539    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9540}
9541impl fmt::Debug for AnyHasDocComments {
9542    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9543        f.debug_struct("AnyHasDocComments").field("syntax", &self.syntax).finish()
9544    }
9545}
9546impl From<Const> for AnyHasDocComments {
9547    #[inline]
9548    fn from(node: Const) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9549}
9550impl From<Enum> for AnyHasDocComments {
9551    #[inline]
9552    fn from(node: Enum) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9553}
9554impl From<ExternBlock> for AnyHasDocComments {
9555    #[inline]
9556    fn from(node: ExternBlock) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9557}
9558impl From<ExternCrate> for AnyHasDocComments {
9559    #[inline]
9560    fn from(node: ExternCrate) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9561}
9562impl From<Fn> for AnyHasDocComments {
9563    #[inline]
9564    fn from(node: Fn) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9565}
9566impl From<Impl> for AnyHasDocComments {
9567    #[inline]
9568    fn from(node: Impl) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9569}
9570impl From<MacroCall> for AnyHasDocComments {
9571    #[inline]
9572    fn from(node: MacroCall) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9573}
9574impl From<MacroDef> for AnyHasDocComments {
9575    #[inline]
9576    fn from(node: MacroDef) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9577}
9578impl From<MacroRules> for AnyHasDocComments {
9579    #[inline]
9580    fn from(node: MacroRules) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9581}
9582impl From<Module> for AnyHasDocComments {
9583    #[inline]
9584    fn from(node: Module) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9585}
9586impl From<RecordField> for AnyHasDocComments {
9587    #[inline]
9588    fn from(node: RecordField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9589}
9590impl From<SourceFile> for AnyHasDocComments {
9591    #[inline]
9592    fn from(node: SourceFile) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9593}
9594impl From<Static> for AnyHasDocComments {
9595    #[inline]
9596    fn from(node: Static) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9597}
9598impl From<Struct> for AnyHasDocComments {
9599    #[inline]
9600    fn from(node: Struct) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9601}
9602impl From<Trait> for AnyHasDocComments {
9603    #[inline]
9604    fn from(node: Trait) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9605}
9606impl From<TupleField> for AnyHasDocComments {
9607    #[inline]
9608    fn from(node: TupleField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9609}
9610impl From<TypeAlias> for AnyHasDocComments {
9611    #[inline]
9612    fn from(node: TypeAlias) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9613}
9614impl From<Union> for AnyHasDocComments {
9615    #[inline]
9616    fn from(node: Union) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9617}
9618impl From<Use> for AnyHasDocComments {
9619    #[inline]
9620    fn from(node: Use) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9621}
9622impl From<Variant> for AnyHasDocComments {
9623    #[inline]
9624    fn from(node: Variant) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
9625}
9626impl ast::HasGenericArgs for AnyHasGenericArgs {}
9627impl AstNode for AnyHasGenericArgs {
9628    #[inline]
9629    fn can_cast(kind: SyntaxKind) -> bool {
9630        matches!(kind, ASSOC_TYPE_ARG | METHOD_CALL_EXPR | PATH_SEGMENT)
9631    }
9632    #[inline]
9633    fn cast(syntax: SyntaxNode) -> Option<Self> {
9634        Self::can_cast(syntax.kind()).then_some(AnyHasGenericArgs { syntax })
9635    }
9636    #[inline]
9637    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9638}
9639impl hash::Hash for AnyHasGenericArgs {
9640    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9641}
9642impl Eq for AnyHasGenericArgs {}
9643impl PartialEq for AnyHasGenericArgs {
9644    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9645}
9646impl Clone for AnyHasGenericArgs {
9647    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9648}
9649impl fmt::Debug for AnyHasGenericArgs {
9650    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9651        f.debug_struct("AnyHasGenericArgs").field("syntax", &self.syntax).finish()
9652    }
9653}
9654impl From<AssocTypeArg> for AnyHasGenericArgs {
9655    #[inline]
9656    fn from(node: AssocTypeArg) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
9657}
9658impl From<MethodCallExpr> for AnyHasGenericArgs {
9659    #[inline]
9660    fn from(node: MethodCallExpr) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
9661}
9662impl From<PathSegment> for AnyHasGenericArgs {
9663    #[inline]
9664    fn from(node: PathSegment) -> AnyHasGenericArgs { AnyHasGenericArgs { syntax: node.syntax } }
9665}
9666impl ast::HasGenericParams for AnyHasGenericParams {}
9667impl AstNode for AnyHasGenericParams {
9668    #[inline]
9669    fn can_cast(kind: SyntaxKind) -> bool {
9670        matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TYPE_ALIAS | UNION)
9671    }
9672    #[inline]
9673    fn cast(syntax: SyntaxNode) -> Option<Self> {
9674        Self::can_cast(syntax.kind()).then_some(AnyHasGenericParams { syntax })
9675    }
9676    #[inline]
9677    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9678}
9679impl hash::Hash for AnyHasGenericParams {
9680    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9681}
9682impl Eq for AnyHasGenericParams {}
9683impl PartialEq for AnyHasGenericParams {
9684    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9685}
9686impl Clone for AnyHasGenericParams {
9687    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9688}
9689impl fmt::Debug for AnyHasGenericParams {
9690    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9691        f.debug_struct("AnyHasGenericParams").field("syntax", &self.syntax).finish()
9692    }
9693}
9694impl From<Const> for AnyHasGenericParams {
9695    #[inline]
9696    fn from(node: Const) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9697}
9698impl From<Enum> for AnyHasGenericParams {
9699    #[inline]
9700    fn from(node: Enum) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9701}
9702impl From<Fn> for AnyHasGenericParams {
9703    #[inline]
9704    fn from(node: Fn) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9705}
9706impl From<Impl> for AnyHasGenericParams {
9707    #[inline]
9708    fn from(node: Impl) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9709}
9710impl From<Struct> for AnyHasGenericParams {
9711    #[inline]
9712    fn from(node: Struct) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9713}
9714impl From<Trait> for AnyHasGenericParams {
9715    #[inline]
9716    fn from(node: Trait) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9717}
9718impl From<TypeAlias> for AnyHasGenericParams {
9719    #[inline]
9720    fn from(node: TypeAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9721}
9722impl From<Union> for AnyHasGenericParams {
9723    #[inline]
9724    fn from(node: Union) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
9725}
9726impl ast::HasLoopBody for AnyHasLoopBody {}
9727impl AstNode for AnyHasLoopBody {
9728    #[inline]
9729    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FOR_EXPR | LOOP_EXPR | WHILE_EXPR) }
9730    #[inline]
9731    fn cast(syntax: SyntaxNode) -> Option<Self> {
9732        Self::can_cast(syntax.kind()).then_some(AnyHasLoopBody { syntax })
9733    }
9734    #[inline]
9735    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9736}
9737impl hash::Hash for AnyHasLoopBody {
9738    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9739}
9740impl Eq for AnyHasLoopBody {}
9741impl PartialEq for AnyHasLoopBody {
9742    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9743}
9744impl Clone for AnyHasLoopBody {
9745    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9746}
9747impl fmt::Debug for AnyHasLoopBody {
9748    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9749        f.debug_struct("AnyHasLoopBody").field("syntax", &self.syntax).finish()
9750    }
9751}
9752impl From<ForExpr> for AnyHasLoopBody {
9753    #[inline]
9754    fn from(node: ForExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
9755}
9756impl From<LoopExpr> for AnyHasLoopBody {
9757    #[inline]
9758    fn from(node: LoopExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
9759}
9760impl From<WhileExpr> for AnyHasLoopBody {
9761    #[inline]
9762    fn from(node: WhileExpr) -> AnyHasLoopBody { AnyHasLoopBody { syntax: node.syntax } }
9763}
9764impl ast::HasModuleItem for AnyHasModuleItem {}
9765impl AstNode for AnyHasModuleItem {
9766    #[inline]
9767    fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ITEM_LIST | MACRO_ITEMS | SOURCE_FILE) }
9768    #[inline]
9769    fn cast(syntax: SyntaxNode) -> Option<Self> {
9770        Self::can_cast(syntax.kind()).then_some(AnyHasModuleItem { syntax })
9771    }
9772    #[inline]
9773    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9774}
9775impl hash::Hash for AnyHasModuleItem {
9776    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9777}
9778impl Eq for AnyHasModuleItem {}
9779impl PartialEq for AnyHasModuleItem {
9780    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9781}
9782impl Clone for AnyHasModuleItem {
9783    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9784}
9785impl fmt::Debug for AnyHasModuleItem {
9786    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9787        f.debug_struct("AnyHasModuleItem").field("syntax", &self.syntax).finish()
9788    }
9789}
9790impl From<ItemList> for AnyHasModuleItem {
9791    #[inline]
9792    fn from(node: ItemList) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
9793}
9794impl From<MacroItems> for AnyHasModuleItem {
9795    #[inline]
9796    fn from(node: MacroItems) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
9797}
9798impl From<SourceFile> for AnyHasModuleItem {
9799    #[inline]
9800    fn from(node: SourceFile) -> AnyHasModuleItem { AnyHasModuleItem { syntax: node.syntax } }
9801}
9802impl ast::HasName for AnyHasName {}
9803impl AstNode for AnyHasName {
9804    #[inline]
9805    fn can_cast(kind: SyntaxKind) -> bool {
9806        matches!(
9807            kind,
9808            ASM_OPERAND_NAMED
9809                | CONST
9810                | CONST_PARAM
9811                | ENUM
9812                | FN
9813                | IDENT_PAT
9814                | MACRO_DEF
9815                | MACRO_RULES
9816                | MODULE
9817                | RECORD_FIELD
9818                | RENAME
9819                | SELF_PARAM
9820                | STATIC
9821                | STRUCT
9822                | TRAIT
9823                | TYPE_ALIAS
9824                | TYPE_PARAM
9825                | UNION
9826                | VARIANT
9827        )
9828    }
9829    #[inline]
9830    fn cast(syntax: SyntaxNode) -> Option<Self> {
9831        Self::can_cast(syntax.kind()).then_some(AnyHasName { syntax })
9832    }
9833    #[inline]
9834    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9835}
9836impl hash::Hash for AnyHasName {
9837    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9838}
9839impl Eq for AnyHasName {}
9840impl PartialEq for AnyHasName {
9841    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9842}
9843impl Clone for AnyHasName {
9844    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9845}
9846impl fmt::Debug for AnyHasName {
9847    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9848        f.debug_struct("AnyHasName").field("syntax", &self.syntax).finish()
9849    }
9850}
9851impl From<AsmOperandNamed> for AnyHasName {
9852    #[inline]
9853    fn from(node: AsmOperandNamed) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9854}
9855impl From<Const> for AnyHasName {
9856    #[inline]
9857    fn from(node: Const) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9858}
9859impl From<ConstParam> for AnyHasName {
9860    #[inline]
9861    fn from(node: ConstParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9862}
9863impl From<Enum> for AnyHasName {
9864    #[inline]
9865    fn from(node: Enum) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9866}
9867impl From<Fn> for AnyHasName {
9868    #[inline]
9869    fn from(node: Fn) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9870}
9871impl From<IdentPat> for AnyHasName {
9872    #[inline]
9873    fn from(node: IdentPat) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9874}
9875impl From<MacroDef> for AnyHasName {
9876    #[inline]
9877    fn from(node: MacroDef) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9878}
9879impl From<MacroRules> for AnyHasName {
9880    #[inline]
9881    fn from(node: MacroRules) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9882}
9883impl From<Module> for AnyHasName {
9884    #[inline]
9885    fn from(node: Module) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9886}
9887impl From<RecordField> for AnyHasName {
9888    #[inline]
9889    fn from(node: RecordField) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9890}
9891impl From<Rename> for AnyHasName {
9892    #[inline]
9893    fn from(node: Rename) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9894}
9895impl From<SelfParam> for AnyHasName {
9896    #[inline]
9897    fn from(node: SelfParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9898}
9899impl From<Static> for AnyHasName {
9900    #[inline]
9901    fn from(node: Static) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9902}
9903impl From<Struct> for AnyHasName {
9904    #[inline]
9905    fn from(node: Struct) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9906}
9907impl From<Trait> for AnyHasName {
9908    #[inline]
9909    fn from(node: Trait) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9910}
9911impl From<TypeAlias> for AnyHasName {
9912    #[inline]
9913    fn from(node: TypeAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9914}
9915impl From<TypeParam> for AnyHasName {
9916    #[inline]
9917    fn from(node: TypeParam) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9918}
9919impl From<Union> for AnyHasName {
9920    #[inline]
9921    fn from(node: Union) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9922}
9923impl From<Variant> for AnyHasName {
9924    #[inline]
9925    fn from(node: Variant) -> AnyHasName { AnyHasName { syntax: node.syntax } }
9926}
9927impl ast::HasTypeBounds for AnyHasTypeBounds {}
9928impl AstNode for AnyHasTypeBounds {
9929    #[inline]
9930    fn can_cast(kind: SyntaxKind) -> bool {
9931        matches!(
9932            kind,
9933            ASSOC_TYPE_ARG | LIFETIME_PARAM | TRAIT | TYPE_ALIAS | TYPE_PARAM | WHERE_PRED
9934        )
9935    }
9936    #[inline]
9937    fn cast(syntax: SyntaxNode) -> Option<Self> {
9938        Self::can_cast(syntax.kind()).then_some(AnyHasTypeBounds { syntax })
9939    }
9940    #[inline]
9941    fn syntax(&self) -> &SyntaxNode { &self.syntax }
9942}
9943impl hash::Hash for AnyHasTypeBounds {
9944    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
9945}
9946impl Eq for AnyHasTypeBounds {}
9947impl PartialEq for AnyHasTypeBounds {
9948    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
9949}
9950impl Clone for AnyHasTypeBounds {
9951    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
9952}
9953impl fmt::Debug for AnyHasTypeBounds {
9954    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9955        f.debug_struct("AnyHasTypeBounds").field("syntax", &self.syntax).finish()
9956    }
9957}
9958impl From<AssocTypeArg> for AnyHasTypeBounds {
9959    #[inline]
9960    fn from(node: AssocTypeArg) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9961}
9962impl From<LifetimeParam> for AnyHasTypeBounds {
9963    #[inline]
9964    fn from(node: LifetimeParam) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9965}
9966impl From<Trait> for AnyHasTypeBounds {
9967    #[inline]
9968    fn from(node: Trait) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9969}
9970impl From<TypeAlias> for AnyHasTypeBounds {
9971    #[inline]
9972    fn from(node: TypeAlias) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9973}
9974impl From<TypeParam> for AnyHasTypeBounds {
9975    #[inline]
9976    fn from(node: TypeParam) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9977}
9978impl From<WherePred> for AnyHasTypeBounds {
9979    #[inline]
9980    fn from(node: WherePred) -> AnyHasTypeBounds { AnyHasTypeBounds { syntax: node.syntax } }
9981}
9982impl ast::HasVisibility for AnyHasVisibility {}
9983impl AstNode for AnyHasVisibility {
9984    #[inline]
9985    fn can_cast(kind: SyntaxKind) -> bool {
9986        matches!(
9987            kind,
9988            CONST
9989                | ENUM
9990                | EXTERN_CRATE
9991                | FN
9992                | IMPL
9993                | MACRO_DEF
9994                | MACRO_RULES
9995                | MODULE
9996                | RECORD_FIELD
9997                | STATIC
9998                | STRUCT
9999                | TRAIT
10000                | TUPLE_FIELD
10001                | TYPE_ALIAS
10002                | UNION
10003                | USE
10004                | VARIANT
10005        )
10006    }
10007    #[inline]
10008    fn cast(syntax: SyntaxNode) -> Option<Self> {
10009        Self::can_cast(syntax.kind()).then_some(AnyHasVisibility { syntax })
10010    }
10011    #[inline]
10012    fn syntax(&self) -> &SyntaxNode { &self.syntax }
10013}
10014impl hash::Hash for AnyHasVisibility {
10015    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
10016}
10017impl Eq for AnyHasVisibility {}
10018impl PartialEq for AnyHasVisibility {
10019    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
10020}
10021impl Clone for AnyHasVisibility {
10022    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
10023}
10024impl fmt::Debug for AnyHasVisibility {
10025    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10026        f.debug_struct("AnyHasVisibility").field("syntax", &self.syntax).finish()
10027    }
10028}
10029impl From<Const> for AnyHasVisibility {
10030    #[inline]
10031    fn from(node: Const) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10032}
10033impl From<Enum> for AnyHasVisibility {
10034    #[inline]
10035    fn from(node: Enum) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10036}
10037impl From<ExternCrate> for AnyHasVisibility {
10038    #[inline]
10039    fn from(node: ExternCrate) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10040}
10041impl From<Fn> for AnyHasVisibility {
10042    #[inline]
10043    fn from(node: Fn) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10044}
10045impl From<Impl> for AnyHasVisibility {
10046    #[inline]
10047    fn from(node: Impl) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10048}
10049impl From<MacroDef> for AnyHasVisibility {
10050    #[inline]
10051    fn from(node: MacroDef) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10052}
10053impl From<MacroRules> for AnyHasVisibility {
10054    #[inline]
10055    fn from(node: MacroRules) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10056}
10057impl From<Module> for AnyHasVisibility {
10058    #[inline]
10059    fn from(node: Module) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10060}
10061impl From<RecordField> for AnyHasVisibility {
10062    #[inline]
10063    fn from(node: RecordField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10064}
10065impl From<Static> for AnyHasVisibility {
10066    #[inline]
10067    fn from(node: Static) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10068}
10069impl From<Struct> for AnyHasVisibility {
10070    #[inline]
10071    fn from(node: Struct) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10072}
10073impl From<Trait> for AnyHasVisibility {
10074    #[inline]
10075    fn from(node: Trait) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10076}
10077impl From<TupleField> for AnyHasVisibility {
10078    #[inline]
10079    fn from(node: TupleField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10080}
10081impl From<TypeAlias> for AnyHasVisibility {
10082    #[inline]
10083    fn from(node: TypeAlias) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10084}
10085impl From<Union> for AnyHasVisibility {
10086    #[inline]
10087    fn from(node: Union) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10088}
10089impl From<Use> for AnyHasVisibility {
10090    #[inline]
10091    fn from(node: Use) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10092}
10093impl From<Variant> for AnyHasVisibility {
10094    #[inline]
10095    fn from(node: Variant) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
10096}
10097impl std::fmt::Display for Adt {
10098    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10099        std::fmt::Display::fmt(self.syntax(), f)
10100    }
10101}
10102impl std::fmt::Display for AsmOperand {
10103    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10104        std::fmt::Display::fmt(self.syntax(), f)
10105    }
10106}
10107impl std::fmt::Display for AsmPiece {
10108    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10109        std::fmt::Display::fmt(self.syntax(), f)
10110    }
10111}
10112impl std::fmt::Display for AssocItem {
10113    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10114        std::fmt::Display::fmt(self.syntax(), f)
10115    }
10116}
10117impl std::fmt::Display for CfgPredicate {
10118    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10119        std::fmt::Display::fmt(self.syntax(), f)
10120    }
10121}
10122impl std::fmt::Display for Expr {
10123    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10124        std::fmt::Display::fmt(self.syntax(), f)
10125    }
10126}
10127impl std::fmt::Display for ExternItem {
10128    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10129        std::fmt::Display::fmt(self.syntax(), f)
10130    }
10131}
10132impl std::fmt::Display for FieldList {
10133    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10134        std::fmt::Display::fmt(self.syntax(), f)
10135    }
10136}
10137impl std::fmt::Display for GenericArg {
10138    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10139        std::fmt::Display::fmt(self.syntax(), f)
10140    }
10141}
10142impl std::fmt::Display for GenericParam {
10143    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10144        std::fmt::Display::fmt(self.syntax(), f)
10145    }
10146}
10147impl std::fmt::Display for Item {
10148    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10149        std::fmt::Display::fmt(self.syntax(), f)
10150    }
10151}
10152impl std::fmt::Display for Meta {
10153    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10154        std::fmt::Display::fmt(self.syntax(), f)
10155    }
10156}
10157impl std::fmt::Display for Pat {
10158    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10159        std::fmt::Display::fmt(self.syntax(), f)
10160    }
10161}
10162impl std::fmt::Display for Stmt {
10163    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10164        std::fmt::Display::fmt(self.syntax(), f)
10165    }
10166}
10167impl std::fmt::Display for Type {
10168    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10169        std::fmt::Display::fmt(self.syntax(), f)
10170    }
10171}
10172impl std::fmt::Display for UseBoundGenericArg {
10173    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10174        std::fmt::Display::fmt(self.syntax(), f)
10175    }
10176}
10177impl std::fmt::Display for VariantDef {
10178    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10179        std::fmt::Display::fmt(self.syntax(), f)
10180    }
10181}
10182impl std::fmt::Display for Abi {
10183    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10184        std::fmt::Display::fmt(self.syntax(), f)
10185    }
10186}
10187impl std::fmt::Display for ArgList {
10188    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10189        std::fmt::Display::fmt(self.syntax(), f)
10190    }
10191}
10192impl std::fmt::Display for ArrayExpr {
10193    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10194        std::fmt::Display::fmt(self.syntax(), f)
10195    }
10196}
10197impl std::fmt::Display for ArrayType {
10198    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10199        std::fmt::Display::fmt(self.syntax(), f)
10200    }
10201}
10202impl std::fmt::Display for AsmClobberAbi {
10203    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10204        std::fmt::Display::fmt(self.syntax(), f)
10205    }
10206}
10207impl std::fmt::Display for AsmConst {
10208    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10209        std::fmt::Display::fmt(self.syntax(), f)
10210    }
10211}
10212impl std::fmt::Display for AsmDirSpec {
10213    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10214        std::fmt::Display::fmt(self.syntax(), f)
10215    }
10216}
10217impl std::fmt::Display for AsmExpr {
10218    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10219        std::fmt::Display::fmt(self.syntax(), f)
10220    }
10221}
10222impl std::fmt::Display for AsmLabel {
10223    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10224        std::fmt::Display::fmt(self.syntax(), f)
10225    }
10226}
10227impl std::fmt::Display for AsmOperandExpr {
10228    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10229        std::fmt::Display::fmt(self.syntax(), f)
10230    }
10231}
10232impl std::fmt::Display for AsmOperandNamed {
10233    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10234        std::fmt::Display::fmt(self.syntax(), f)
10235    }
10236}
10237impl std::fmt::Display for AsmOption {
10238    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10239        std::fmt::Display::fmt(self.syntax(), f)
10240    }
10241}
10242impl std::fmt::Display for AsmOptions {
10243    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10244        std::fmt::Display::fmt(self.syntax(), f)
10245    }
10246}
10247impl std::fmt::Display for AsmRegOperand {
10248    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10249        std::fmt::Display::fmt(self.syntax(), f)
10250    }
10251}
10252impl std::fmt::Display for AsmRegSpec {
10253    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10254        std::fmt::Display::fmt(self.syntax(), f)
10255    }
10256}
10257impl std::fmt::Display for AsmSym {
10258    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10259        std::fmt::Display::fmt(self.syntax(), f)
10260    }
10261}
10262impl std::fmt::Display for AssocItemList {
10263    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10264        std::fmt::Display::fmt(self.syntax(), f)
10265    }
10266}
10267impl std::fmt::Display for AssocTypeArg {
10268    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10269        std::fmt::Display::fmt(self.syntax(), f)
10270    }
10271}
10272impl std::fmt::Display for Attr {
10273    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10274        std::fmt::Display::fmt(self.syntax(), f)
10275    }
10276}
10277impl std::fmt::Display for AwaitExpr {
10278    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10279        std::fmt::Display::fmt(self.syntax(), f)
10280    }
10281}
10282impl std::fmt::Display for BecomeExpr {
10283    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10284        std::fmt::Display::fmt(self.syntax(), f)
10285    }
10286}
10287impl std::fmt::Display for BinExpr {
10288    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10289        std::fmt::Display::fmt(self.syntax(), f)
10290    }
10291}
10292impl std::fmt::Display for BlockExpr {
10293    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294        std::fmt::Display::fmt(self.syntax(), f)
10295    }
10296}
10297impl std::fmt::Display for BoxPat {
10298    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10299        std::fmt::Display::fmt(self.syntax(), f)
10300    }
10301}
10302impl std::fmt::Display for BreakExpr {
10303    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10304        std::fmt::Display::fmt(self.syntax(), f)
10305    }
10306}
10307impl std::fmt::Display for CallExpr {
10308    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10309        std::fmt::Display::fmt(self.syntax(), f)
10310    }
10311}
10312impl std::fmt::Display for CastExpr {
10313    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10314        std::fmt::Display::fmt(self.syntax(), f)
10315    }
10316}
10317impl std::fmt::Display for CfgAtom {
10318    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10319        std::fmt::Display::fmt(self.syntax(), f)
10320    }
10321}
10322impl std::fmt::Display for CfgAttrMeta {
10323    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10324        std::fmt::Display::fmt(self.syntax(), f)
10325    }
10326}
10327impl std::fmt::Display for CfgComposite {
10328    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10329        std::fmt::Display::fmt(self.syntax(), f)
10330    }
10331}
10332impl std::fmt::Display for CfgMeta {
10333    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10334        std::fmt::Display::fmt(self.syntax(), f)
10335    }
10336}
10337impl std::fmt::Display for ClosureExpr {
10338    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10339        std::fmt::Display::fmt(self.syntax(), f)
10340    }
10341}
10342impl std::fmt::Display for Const {
10343    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10344        std::fmt::Display::fmt(self.syntax(), f)
10345    }
10346}
10347impl std::fmt::Display for ConstArg {
10348    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10349        std::fmt::Display::fmt(self.syntax(), f)
10350    }
10351}
10352impl std::fmt::Display for ConstBlockPat {
10353    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10354        std::fmt::Display::fmt(self.syntax(), f)
10355    }
10356}
10357impl std::fmt::Display for ConstParam {
10358    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10359        std::fmt::Display::fmt(self.syntax(), f)
10360    }
10361}
10362impl std::fmt::Display for ContinueExpr {
10363    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10364        std::fmt::Display::fmt(self.syntax(), f)
10365    }
10366}
10367impl std::fmt::Display for DerefPat {
10368    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10369        std::fmt::Display::fmt(self.syntax(), f)
10370    }
10371}
10372impl std::fmt::Display for DynTraitType {
10373    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10374        std::fmt::Display::fmt(self.syntax(), f)
10375    }
10376}
10377impl std::fmt::Display for Enum {
10378    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10379        std::fmt::Display::fmt(self.syntax(), f)
10380    }
10381}
10382impl std::fmt::Display for ExprStmt {
10383    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10384        std::fmt::Display::fmt(self.syntax(), f)
10385    }
10386}
10387impl std::fmt::Display for ExternBlock {
10388    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10389        std::fmt::Display::fmt(self.syntax(), f)
10390    }
10391}
10392impl std::fmt::Display for ExternCrate {
10393    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10394        std::fmt::Display::fmt(self.syntax(), f)
10395    }
10396}
10397impl std::fmt::Display for ExternItemList {
10398    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10399        std::fmt::Display::fmt(self.syntax(), f)
10400    }
10401}
10402impl std::fmt::Display for FieldExpr {
10403    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10404        std::fmt::Display::fmt(self.syntax(), f)
10405    }
10406}
10407impl std::fmt::Display for Fn {
10408    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10409        std::fmt::Display::fmt(self.syntax(), f)
10410    }
10411}
10412impl std::fmt::Display for FnPtrType {
10413    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10414        std::fmt::Display::fmt(self.syntax(), f)
10415    }
10416}
10417impl std::fmt::Display for ForBinder {
10418    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10419        std::fmt::Display::fmt(self.syntax(), f)
10420    }
10421}
10422impl std::fmt::Display for ForExpr {
10423    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10424        std::fmt::Display::fmt(self.syntax(), f)
10425    }
10426}
10427impl std::fmt::Display for ForType {
10428    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10429        std::fmt::Display::fmt(self.syntax(), f)
10430    }
10431}
10432impl std::fmt::Display for FormatArgsArg {
10433    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10434        std::fmt::Display::fmt(self.syntax(), f)
10435    }
10436}
10437impl std::fmt::Display for FormatArgsArgName {
10438    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10439        std::fmt::Display::fmt(self.syntax(), f)
10440    }
10441}
10442impl std::fmt::Display for FormatArgsExpr {
10443    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10444        std::fmt::Display::fmt(self.syntax(), f)
10445    }
10446}
10447impl std::fmt::Display for GenericArgList {
10448    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10449        std::fmt::Display::fmt(self.syntax(), f)
10450    }
10451}
10452impl std::fmt::Display for GenericParamList {
10453    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10454        std::fmt::Display::fmt(self.syntax(), f)
10455    }
10456}
10457impl std::fmt::Display for IdentPat {
10458    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10459        std::fmt::Display::fmt(self.syntax(), f)
10460    }
10461}
10462impl std::fmt::Display for IfExpr {
10463    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10464        std::fmt::Display::fmt(self.syntax(), f)
10465    }
10466}
10467impl std::fmt::Display for Impl {
10468    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10469        std::fmt::Display::fmt(self.syntax(), f)
10470    }
10471}
10472impl std::fmt::Display for ImplRestriction {
10473    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10474        std::fmt::Display::fmt(self.syntax(), f)
10475    }
10476}
10477impl std::fmt::Display for ImplTraitType {
10478    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10479        std::fmt::Display::fmt(self.syntax(), f)
10480    }
10481}
10482impl std::fmt::Display for IncludeBytesExpr {
10483    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10484        std::fmt::Display::fmt(self.syntax(), f)
10485    }
10486}
10487impl std::fmt::Display for IndexExpr {
10488    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10489        std::fmt::Display::fmt(self.syntax(), f)
10490    }
10491}
10492impl std::fmt::Display for InferType {
10493    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10494        std::fmt::Display::fmt(self.syntax(), f)
10495    }
10496}
10497impl std::fmt::Display for ItemList {
10498    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10499        std::fmt::Display::fmt(self.syntax(), f)
10500    }
10501}
10502impl std::fmt::Display for KeyValueMeta {
10503    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10504        std::fmt::Display::fmt(self.syntax(), f)
10505    }
10506}
10507impl std::fmt::Display for Label {
10508    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10509        std::fmt::Display::fmt(self.syntax(), f)
10510    }
10511}
10512impl std::fmt::Display for LetElse {
10513    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10514        std::fmt::Display::fmt(self.syntax(), f)
10515    }
10516}
10517impl std::fmt::Display for LetExpr {
10518    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10519        std::fmt::Display::fmt(self.syntax(), f)
10520    }
10521}
10522impl std::fmt::Display for LetStmt {
10523    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10524        std::fmt::Display::fmt(self.syntax(), f)
10525    }
10526}
10527impl std::fmt::Display for Lifetime {
10528    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10529        std::fmt::Display::fmt(self.syntax(), f)
10530    }
10531}
10532impl std::fmt::Display for LifetimeArg {
10533    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10534        std::fmt::Display::fmt(self.syntax(), f)
10535    }
10536}
10537impl std::fmt::Display for LifetimeParam {
10538    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10539        std::fmt::Display::fmt(self.syntax(), f)
10540    }
10541}
10542impl std::fmt::Display for Literal {
10543    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10544        std::fmt::Display::fmt(self.syntax(), f)
10545    }
10546}
10547impl std::fmt::Display for LiteralPat {
10548    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10549        std::fmt::Display::fmt(self.syntax(), f)
10550    }
10551}
10552impl std::fmt::Display for LoopExpr {
10553    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10554        std::fmt::Display::fmt(self.syntax(), f)
10555    }
10556}
10557impl std::fmt::Display for MacroCall {
10558    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10559        std::fmt::Display::fmt(self.syntax(), f)
10560    }
10561}
10562impl std::fmt::Display for MacroDef {
10563    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10564        std::fmt::Display::fmt(self.syntax(), f)
10565    }
10566}
10567impl std::fmt::Display for MacroExpr {
10568    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10569        std::fmt::Display::fmt(self.syntax(), f)
10570    }
10571}
10572impl std::fmt::Display for MacroItems {
10573    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10574        std::fmt::Display::fmt(self.syntax(), f)
10575    }
10576}
10577impl std::fmt::Display for MacroPat {
10578    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10579        std::fmt::Display::fmt(self.syntax(), f)
10580    }
10581}
10582impl std::fmt::Display for MacroRules {
10583    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10584        std::fmt::Display::fmt(self.syntax(), f)
10585    }
10586}
10587impl std::fmt::Display for MacroStmts {
10588    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10589        std::fmt::Display::fmt(self.syntax(), f)
10590    }
10591}
10592impl std::fmt::Display for MacroType {
10593    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594        std::fmt::Display::fmt(self.syntax(), f)
10595    }
10596}
10597impl std::fmt::Display for MatchArm {
10598    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10599        std::fmt::Display::fmt(self.syntax(), f)
10600    }
10601}
10602impl std::fmt::Display for MatchArmList {
10603    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10604        std::fmt::Display::fmt(self.syntax(), f)
10605    }
10606}
10607impl std::fmt::Display for MatchExpr {
10608    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10609        std::fmt::Display::fmt(self.syntax(), f)
10610    }
10611}
10612impl std::fmt::Display for MatchGuard {
10613    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10614        std::fmt::Display::fmt(self.syntax(), f)
10615    }
10616}
10617impl std::fmt::Display for MethodCallExpr {
10618    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10619        std::fmt::Display::fmt(self.syntax(), f)
10620    }
10621}
10622impl std::fmt::Display for Module {
10623    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10624        std::fmt::Display::fmt(self.syntax(), f)
10625    }
10626}
10627impl std::fmt::Display for MutRestriction {
10628    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10629        std::fmt::Display::fmt(self.syntax(), f)
10630    }
10631}
10632impl std::fmt::Display for Name {
10633    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10634        std::fmt::Display::fmt(self.syntax(), f)
10635    }
10636}
10637impl std::fmt::Display for NameRef {
10638    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10639        std::fmt::Display::fmt(self.syntax(), f)
10640    }
10641}
10642impl std::fmt::Display for NeverType {
10643    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10644        std::fmt::Display::fmt(self.syntax(), f)
10645    }
10646}
10647impl std::fmt::Display for NotNull {
10648    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10649        std::fmt::Display::fmt(self.syntax(), f)
10650    }
10651}
10652impl std::fmt::Display for OffsetOfExpr {
10653    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10654        std::fmt::Display::fmt(self.syntax(), f)
10655    }
10656}
10657impl std::fmt::Display for OrPat {
10658    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10659        std::fmt::Display::fmt(self.syntax(), f)
10660    }
10661}
10662impl std::fmt::Display for Param {
10663    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10664        std::fmt::Display::fmt(self.syntax(), f)
10665    }
10666}
10667impl std::fmt::Display for ParamList {
10668    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10669        std::fmt::Display::fmt(self.syntax(), f)
10670    }
10671}
10672impl std::fmt::Display for ParenExpr {
10673    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10674        std::fmt::Display::fmt(self.syntax(), f)
10675    }
10676}
10677impl std::fmt::Display for ParenPat {
10678    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10679        std::fmt::Display::fmt(self.syntax(), f)
10680    }
10681}
10682impl std::fmt::Display for ParenType {
10683    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10684        std::fmt::Display::fmt(self.syntax(), f)
10685    }
10686}
10687impl std::fmt::Display for ParenthesizedArgList {
10688    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10689        std::fmt::Display::fmt(self.syntax(), f)
10690    }
10691}
10692impl std::fmt::Display for Path {
10693    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10694        std::fmt::Display::fmt(self.syntax(), f)
10695    }
10696}
10697impl std::fmt::Display for PathExpr {
10698    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10699        std::fmt::Display::fmt(self.syntax(), f)
10700    }
10701}
10702impl std::fmt::Display for PathMeta {
10703    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10704        std::fmt::Display::fmt(self.syntax(), f)
10705    }
10706}
10707impl std::fmt::Display for PathPat {
10708    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10709        std::fmt::Display::fmt(self.syntax(), f)
10710    }
10711}
10712impl std::fmt::Display for PathSegment {
10713    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10714        std::fmt::Display::fmt(self.syntax(), f)
10715    }
10716}
10717impl std::fmt::Display for PathType {
10718    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10719        std::fmt::Display::fmt(self.syntax(), f)
10720    }
10721}
10722impl std::fmt::Display for PatternType {
10723    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10724        std::fmt::Display::fmt(self.syntax(), f)
10725    }
10726}
10727impl std::fmt::Display for PrefixExpr {
10728    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10729        std::fmt::Display::fmt(self.syntax(), f)
10730    }
10731}
10732impl std::fmt::Display for PtrType {
10733    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10734        std::fmt::Display::fmt(self.syntax(), f)
10735    }
10736}
10737impl std::fmt::Display for RangeExpr {
10738    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10739        std::fmt::Display::fmt(self.syntax(), f)
10740    }
10741}
10742impl std::fmt::Display for RangePat {
10743    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10744        std::fmt::Display::fmt(self.syntax(), f)
10745    }
10746}
10747impl std::fmt::Display for RecordExpr {
10748    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10749        std::fmt::Display::fmt(self.syntax(), f)
10750    }
10751}
10752impl std::fmt::Display for RecordExprField {
10753    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10754        std::fmt::Display::fmt(self.syntax(), f)
10755    }
10756}
10757impl std::fmt::Display for RecordExprFieldList {
10758    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10759        std::fmt::Display::fmt(self.syntax(), f)
10760    }
10761}
10762impl std::fmt::Display for RecordField {
10763    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10764        std::fmt::Display::fmt(self.syntax(), f)
10765    }
10766}
10767impl std::fmt::Display for RecordFieldList {
10768    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10769        std::fmt::Display::fmt(self.syntax(), f)
10770    }
10771}
10772impl std::fmt::Display for RecordPat {
10773    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10774        std::fmt::Display::fmt(self.syntax(), f)
10775    }
10776}
10777impl std::fmt::Display for RecordPatField {
10778    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10779        std::fmt::Display::fmt(self.syntax(), f)
10780    }
10781}
10782impl std::fmt::Display for RecordPatFieldList {
10783    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10784        std::fmt::Display::fmt(self.syntax(), f)
10785    }
10786}
10787impl std::fmt::Display for RefExpr {
10788    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10789        std::fmt::Display::fmt(self.syntax(), f)
10790    }
10791}
10792impl std::fmt::Display for RefPat {
10793    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10794        std::fmt::Display::fmt(self.syntax(), f)
10795    }
10796}
10797impl std::fmt::Display for RefType {
10798    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10799        std::fmt::Display::fmt(self.syntax(), f)
10800    }
10801}
10802impl std::fmt::Display for Rename {
10803    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10804        std::fmt::Display::fmt(self.syntax(), f)
10805    }
10806}
10807impl std::fmt::Display for RestPat {
10808    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10809        std::fmt::Display::fmt(self.syntax(), f)
10810    }
10811}
10812impl std::fmt::Display for RetType {
10813    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10814        std::fmt::Display::fmt(self.syntax(), f)
10815    }
10816}
10817impl std::fmt::Display for ReturnExpr {
10818    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10819        std::fmt::Display::fmt(self.syntax(), f)
10820    }
10821}
10822impl std::fmt::Display for ReturnTypeSyntax {
10823    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10824        std::fmt::Display::fmt(self.syntax(), f)
10825    }
10826}
10827impl std::fmt::Display for SelfParam {
10828    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10829        std::fmt::Display::fmt(self.syntax(), f)
10830    }
10831}
10832impl std::fmt::Display for SlicePat {
10833    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10834        std::fmt::Display::fmt(self.syntax(), f)
10835    }
10836}
10837impl std::fmt::Display for SliceType {
10838    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10839        std::fmt::Display::fmt(self.syntax(), f)
10840    }
10841}
10842impl std::fmt::Display for SourceFile {
10843    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10844        std::fmt::Display::fmt(self.syntax(), f)
10845    }
10846}
10847impl std::fmt::Display for Static {
10848    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10849        std::fmt::Display::fmt(self.syntax(), f)
10850    }
10851}
10852impl std::fmt::Display for StmtList {
10853    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10854        std::fmt::Display::fmt(self.syntax(), f)
10855    }
10856}
10857impl std::fmt::Display for Struct {
10858    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10859        std::fmt::Display::fmt(self.syntax(), f)
10860    }
10861}
10862impl std::fmt::Display for TokenTree {
10863    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10864        std::fmt::Display::fmt(self.syntax(), f)
10865    }
10866}
10867impl std::fmt::Display for TokenTreeMeta {
10868    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10869        std::fmt::Display::fmt(self.syntax(), f)
10870    }
10871}
10872impl std::fmt::Display for Trait {
10873    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10874        std::fmt::Display::fmt(self.syntax(), f)
10875    }
10876}
10877impl std::fmt::Display for TryBlockModifier {
10878    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10879        std::fmt::Display::fmt(self.syntax(), f)
10880    }
10881}
10882impl std::fmt::Display for TryExpr {
10883    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884        std::fmt::Display::fmt(self.syntax(), f)
10885    }
10886}
10887impl std::fmt::Display for TupleExpr {
10888    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10889        std::fmt::Display::fmt(self.syntax(), f)
10890    }
10891}
10892impl std::fmt::Display for TupleField {
10893    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10894        std::fmt::Display::fmt(self.syntax(), f)
10895    }
10896}
10897impl std::fmt::Display for TupleFieldList {
10898    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10899        std::fmt::Display::fmt(self.syntax(), f)
10900    }
10901}
10902impl std::fmt::Display for TuplePat {
10903    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10904        std::fmt::Display::fmt(self.syntax(), f)
10905    }
10906}
10907impl std::fmt::Display for TupleStructPat {
10908    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10909        std::fmt::Display::fmt(self.syntax(), f)
10910    }
10911}
10912impl std::fmt::Display for TupleType {
10913    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10914        std::fmt::Display::fmt(self.syntax(), f)
10915    }
10916}
10917impl std::fmt::Display for TypeAlias {
10918    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10919        std::fmt::Display::fmt(self.syntax(), f)
10920    }
10921}
10922impl std::fmt::Display for TypeAnchor {
10923    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10924        std::fmt::Display::fmt(self.syntax(), f)
10925    }
10926}
10927impl std::fmt::Display for TypeArg {
10928    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10929        std::fmt::Display::fmt(self.syntax(), f)
10930    }
10931}
10932impl std::fmt::Display for TypeBound {
10933    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10934        std::fmt::Display::fmt(self.syntax(), f)
10935    }
10936}
10937impl std::fmt::Display for TypeBoundList {
10938    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10939        std::fmt::Display::fmt(self.syntax(), f)
10940    }
10941}
10942impl std::fmt::Display for TypeParam {
10943    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10944        std::fmt::Display::fmt(self.syntax(), f)
10945    }
10946}
10947impl std::fmt::Display for UnderscoreExpr {
10948    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10949        std::fmt::Display::fmt(self.syntax(), f)
10950    }
10951}
10952impl std::fmt::Display for Union {
10953    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10954        std::fmt::Display::fmt(self.syntax(), f)
10955    }
10956}
10957impl std::fmt::Display for UnsafeMeta {
10958    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10959        std::fmt::Display::fmt(self.syntax(), f)
10960    }
10961}
10962impl std::fmt::Display for Use {
10963    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10964        std::fmt::Display::fmt(self.syntax(), f)
10965    }
10966}
10967impl std::fmt::Display for UseBoundGenericArgs {
10968    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10969        std::fmt::Display::fmt(self.syntax(), f)
10970    }
10971}
10972impl std::fmt::Display for UseTree {
10973    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10974        std::fmt::Display::fmt(self.syntax(), f)
10975    }
10976}
10977impl std::fmt::Display for UseTreeList {
10978    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10979        std::fmt::Display::fmt(self.syntax(), f)
10980    }
10981}
10982impl std::fmt::Display for Variant {
10983    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10984        std::fmt::Display::fmt(self.syntax(), f)
10985    }
10986}
10987impl std::fmt::Display for VariantList {
10988    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10989        std::fmt::Display::fmt(self.syntax(), f)
10990    }
10991}
10992impl std::fmt::Display for Visibility {
10993    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10994        std::fmt::Display::fmt(self.syntax(), f)
10995    }
10996}
10997impl std::fmt::Display for VisibilityInner {
10998    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10999        std::fmt::Display::fmt(self.syntax(), f)
11000    }
11001}
11002impl std::fmt::Display for WhereClause {
11003    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11004        std::fmt::Display::fmt(self.syntax(), f)
11005    }
11006}
11007impl std::fmt::Display for WherePred {
11008    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11009        std::fmt::Display::fmt(self.syntax(), f)
11010    }
11011}
11012impl std::fmt::Display for WhileExpr {
11013    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11014        std::fmt::Display::fmt(self.syntax(), f)
11015    }
11016}
11017impl std::fmt::Display for WildcardPat {
11018    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11019        std::fmt::Display::fmt(self.syntax(), f)
11020    }
11021}
11022impl std::fmt::Display for YeetExpr {
11023    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11024        std::fmt::Display::fmt(self.syntax(), f)
11025    }
11026}
11027impl std::fmt::Display for YieldExpr {
11028    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11029        std::fmt::Display::fmt(self.syntax(), f)
11030    }
11031}